diff --git a/Makefile b/Makefile
index 74cc19d..0cd42a0 100644
--- a/Makefile
+++ b/Makefile
@@ -17,6 +17,9 @@ PATH_MANUAL_TEXI=${PATH_DOC}/manual.texi
 
 COMBINE=${PATH_TOOLS}/combine
 
+TESTS_JS    := $(shell find "./test" -name 'test-*.js')
+TESTS_SHELL := $(shell find "./test" -name 'test-[^\.]*')
+
 
 .PHONY: test doc
 
@@ -26,23 +29,21 @@ all:     combine doc
 
 # create build dir
 mkbuild:
-	@mkdir -p "${PATH_BUILD}"
+	mkdir -p "${PATH_BUILD}"
 
 # combine all modules into easily redistributable ease.js file (intended for
 # browser)
 combine: mkbuild
 	${COMBINE} > "${PATH_COMBINE_OUTPUT}"
 	INC_TEST=1 "${COMBINE}" > "${PATH_COMBINE_OUTPUT_FULL}"
-	@cp "${PATH_BROWSER_TEST}" "${PATH_BUILD}"
+	cp "${PATH_BROWSER_TEST}" "${PATH_BUILD}"
 
 # run tests
-test: default
-	for test in `find ./test -name 'test-*.js'`; do \
-		node $${test}; \
-	done; \
-	for test in `find ./test -regex '.*/test-[^\.]*'`; do \
-		./$$test; \
-	done;
+test: default $(TESTS_JS) $(TESTS_SHELL)
+test-%.js: default
+		node $@
+test-%: default
+		./$@
 
 # generate texinfo documentation (twice to generate TOC), then remove the extra
 # files that were generated
@@ -57,7 +58,7 @@ doc: mkbuild
 		! -name '*.pdf' -a \
 		! -name '*.css' \
 		| xargs rm
-	@mv -f "${PATH_DOC}"/*.pdf "${PATH_DOC_OUTPUT}"
+	mv -f "${PATH_DOC}"/*.pdf "${PATH_DOC_OUTPUT}"
 	cd "${PATH_DOC}"; \
 		makeinfo -o "${PATH_DOC_OUTPUT_INFO}" "${PATH_MANUAL_TEXI}"; \
 		makeinfo --plain "${PATH_MANUAL_TEXI}" > "${PATH_DOC_OUTPUT_PLAIN}"; \
diff --git a/TODO b/TODO
index 60c58ad..925d8c8 100644
--- a/TODO
+++ b/TODO
@@ -2,61 +2,68 @@
 #
 # This is by no means a complete list.
 
-Misc
-  - Deep cloning level for util.clone()
-  - Optional preprocessing support
-    - Ability to disable features that wouldn't impact base functionality
-      - For example, one may wish to have type checking enabled for development
-        but may not want the performance hit for their production code.
-        Disabling type checking, as long as the proper types are passed to the
-        functions, will not impact function logic.
-    - Should be able to run source file without preprocessing, so C-style macros
-      cannot be used (# is not a valid token)
-  - Class module is becoming too large; refactor
+[ target: 0.1.0 ]
+  Misc
+    - Class module is becoming too large; refactor
 
-Member Keywords
-  - Restrictions; throw exceptions when unknown keywords are used
-  - const; immutable properties
-  - final; methods cannot be overridden by subtypes
-  - static; method/property accessible via class definition
-  - event; designates a supported event
-  - Concrete types must implement member with same visibility, or greater
-    visibility, than the abstract implementation defined
+  Member Keywords
+    - Restrictions; throw exceptions when unknown keywords are used
+    - Concrete types must implement member with same visibility, or greater
+      visibility, than the abstract implementation defined
 
-Typing
-  - Support JSDoc-style type definitions for parameters
-  - Syntax:
-    [ 'string', 'number', function( name, age ) {} ]
-  - Optional; if a function is simply provided, rather than an array, no type
-    checking will be performed
-  - For abstract methods, simply leave the function off (last index)
-    - Provide option to throw errors on any type mismatch
-  - Auto-cast, unless casting is impossible, then throw error
+  Documentation
+    - Ensure all docblocks contain only valid JSDoc tags
+    - Generate documentation
+      - Add to Makefile
+    - Begin technical documentation for developers
+      - Include designs and project decisions
+      - Wiki, LaTeX, Texinfo?
+    - API documentation
+      - Wiki, LaTeX, Texinfo?
 
-Reflection
-  - Rather than exposing internal data via properties, fully encapsulate
-  - Classes, not just modules like the rest of ease.js
+  Client-Side
+    - implement assert.deepEqual()
 
-Patterns
-  - Provide automated means to generate classes for common patterns (primarily
-    GoF)
-    - Generating classes at runtime gives us the powerful benefit of being able
-      to generate the classes however we wish. Therefore, we do not need code
-      generation techniques to generate classes. We can simply call a method.
-      This will remove repetitive tasks and duplicate code needed to properly
-      implement the various patterns, and serve as an excellent tool for those
-      unfamiliar with them.
 
-Documentation
-  - Ensure all docblocks contain only valid JSDoc tags
-  - Generate documentation
-    - Add to Makefile
-  - Begin technical documentation for developers
-    - Include designs and project decisions
-    - Wiki, LaTeX, Texinfo?
-  - API documentation
-    - Wiki, LaTeX, Texinfo?
+[ future ]
+  Misc
+    - Deep cloning level for util.clone()
+    - Optional preprocessing support
+      - Ability to disable features that wouldn't impact base functionality
+        - For example, one may wish to have type checking enabled for development
+          but may not want the performance hit for their production code.
+          Disabling type checking, as long as the proper types are passed to the
+          functions, will not impact function logic.
+      - Should be able to run source file without preprocessing, so C-style macros
+        cannot be used (# is not a valid token)
 
-Client-Side
-  - implement assert.deepEqual()
+  Member Keywords
+    - const; immutable properties
+    - final; methods cannot be overridden by subtypes
+    - static; method/property accessible via class definition
+    - event; designates a supported event
+
+  Typing
+    - Support JSDoc-style type definitions for parameters
+    - Syntax:
+      [ 'string', 'number', function( name, age ) {} ]
+    - Optional; if a function is simply provided, rather than an array, no type
+      checking will be performed
+    - For abstract methods, simply leave the function off (last index)
+      - Provide option to throw errors on any type mismatch
+    - Auto-cast, unless casting is impossible, then throw error
+
+  Reflection
+    - Rather than exposing internal data via properties, fully encapsulate
+    - Classes, not just modules like the rest of ease.js
+
+  Patterns
+    - Provide automated means to generate classes for common patterns (primarily
+      GoF)
+      - Generating classes at runtime gives us the powerful benefit of being able
+        to generate the classes however we wish. Therefore, we do not need code
+        generation techniques to generate classes. We can simply call a method.
+        This will remove repetitive tasks and duplicate code needed to properly
+        implement the various patterns, and serve as an excellent tool for those
+        unfamiliar with them.