Change History

An informal running diary of recent changes with indications of things to come (as time allows).

Unreleased

Started development of DTD. Application.dtd completed, but pages.dtd is not. The W3C "Modularation of XHTML" notion is almost impossible to understand, and absolutely so in the case of XSchema. DTD seems more feasible, but just barely.

Cleaned up generated XML to pass w3c's validator. 100% solid now except for three problems that seem to be caused by the use of privoxy on the development machine. These should affect only those who validate privoxied output.

Moved all XPath instances to private static variables on the chance that XPath allocations are expensive. The documentation implies that they are.

Version 2.0: Mar 2004

Major revision to convert the demo and cover pages to feature XML-based HTML in lieu of the Java+ precompiler technique used to date. Java+ support is still in place (several of my applications rely on it). It is not featured in the JWAA documentation because Java+ now has its own web page.

Support for persistent forms has been ported from ALE to JWAA on a provisional (experimental) basis. Further changes in this area are likely. See Persistent Forms for more information.

I'm very satisfied with the XML code but dissatisfied with Velocity as the embedded programming language. I don't like the culture (Jakarta) that produced it (too many opinions, too little maturity, inept sense of software style, etc). The Velocity code seems ad-hoc and poorly thought out. Its macro support is inept and is incompatible with the XML approach because velocity output does not pass through the XML handling code. Velocity error reporting strategy is inconsistent, ignoring errors in places, throwing exceptions in others. There is no way to access constructors or static methods, which makes it almost impossible to use Fields in any reasonable way. Velocity sticks out like a sore thumb. I'm sick of it.

The only stuck with it this long because I've been unable to find a suitable replacement. I investigated FreeMarker but its input syntax is explicitly incompatible with XML and they are committed to it regardless. I've tried using JRuby and JPython as alternatives, but these were too buggy at the time and imposed severe performance and size implications.

All of these "embedded language" approaches violate the XML spirit by "hiding" executable code as XML text strings. I might wind up taking "purist" approach by defining XML elements for if, foreach, set, etc. The syntax implications of trying to wedge programming statements into a data representation language are sufficiently nasty that I've avoided this approach. It might well turn out to be the best road in the end.

I temporarily removed the XPATH("..//@href") logic that automatically subjects all href attributes to URL-rewriting. Interference with the URLs in the Source page. There was a conflict between the XML and Velocity views of the world no doubt. To be revisited when I get this release out the door.

Need more work to ensure that we're emitting pure XHTML; i.e. that we're catching all JWAA additions and replacing all of them with compliant XHTML code. May have missed some here and there.

Feb 2004

As a hint of things to come, I'm considering moving support pioneered in Action Learing Environment into JWAA so all applications can inherit it. Although JWAA's explicit goal is to make web applications as easy to build as conventional ones, a thorny problem has remained: web applications exist in two worlds; one containing the program and the other, the html data.

The first shot at repairing this difference was the Java+ Preprocessor , which provided a simple syntax for maintaining html data right inside program space. Although the whole idea is abhorrent to separation of concern zealots, this actually worked well in single-developer shops such as mine and is far more efficient in both space and time. I'd probably be doing it this way yet were it not for one single snag: eclipse integration.

The JWAA system came at it from an entirely different direction that worked so well I'm considering adopting it throughout. This is to express the HTML data as XML files. Markup commands are written in XHTML to adapt to XML syntax requirements, with programmatic content (executable inclusions) written in the Velocity template language. JWAA's MetaPage information can then be expressed via ordinary XML syntax, which is parsed and removed when the XML file is loaded.

Although XML loading is many orders of magnitude slower than the Java+ technique and requires megabytes of XML parsing code, the cost of the former is only incurred when XML files are loaded or changed and the cost of latter is probably incurred already, since servlet engines like Jetty are increasingly XML intensive; a trend that is certain to continue.

With the new system, all of an application's data content can be gathered into a single XML file (or multiple ones if you prefer). This simplifies editing since there is no need to navigate to multiple tiny HTML pages. This is more convenient than the Java+ technique because the server can automatically reload this file when it changes.

Database handling completely reworked to support (and require) ACID transactions. The earlier collection of database handling routines (ConnectionPool, Query, SQLUtil, etc) have been rewritten and moved to their own package, edu.virtualschool.jwaa.dbms. ConnectionPool is now DBPool and a new class, DB, was added with the functionality of Connection. DB wraps a JDBC connection and a pointer to the DBPool instance from which it was obtained so that it can automatically return the DB to that pool when the DB is closed. DB provides two new methods, commit and rollback, for transactional locking. MySQL users should convert their tables to one of the types that support transactions, currently InnoDB and BDB.

Removed all JCBC handling from GenericPage to support servlets that manage multiple applications, each with their own database.

The term, capability, was replaced by the new term, Role, throughout.

The interface name, Account, was replaced by AccountAbstraction throughout, to reduce the confusion between interface and class names for a widely used name like this one.

Split the demo and documentation classes into several packages to make them easier to follow.

Adopted log4j as the logging engine throughout.

Internal design stabilized. Released as major version upgrade to bring public site up to date with development version.

Version 1.3.5: Unreleased

Enhanced MLS with a graphical interface and to support localization and released it as an independent project, Java+ Preprocessor and removed all references to MLS per se.

Version 1.3.4: Aug 2002

Added syntax color coding to BrowserPage

Version 1.3.4: Jan 2003

Released the Java+ Preprocessor as an independent project by adding a graphical interface and support for localization to the older MLS component of JWAA.

Version 1.3.3: Jun 2002

Adopted consistent naming scheme for all Field classes.

API changes to bring JWAA up to date with the XML-based architecture pioneered by ALE.

Name changes: Query instead of SQLResults, QueryIterator instead of SQLIterator and SQLEnumeration.

Use CSS (Cascading Style Sheets) instead of tables for look and feel.

Eliminated the Ctx/JdbcCtx/Ctx lashup. Page instances now represent pages while they're executing and hold the old Ctx information as instance variables. MetaPage instances represent the static state of a page and represent the page hierarchy, anchor, title, capability level, and so forth.

Improved the demo application

Version 1.3.2: Jan 2002

Added a modified time check to Mls so that it will only convert a file if File(input)modifiedTime() > File(output).modifiedTime(). Works Before this change, all .java files were rewritten by the precompiler which required that they all be checked out for edit.

Version 1.3.1: Nov 2001

Refactored Fault handling system-wide. See JavaDox for edu.virtualschool.fault.Fault for write up.

Repaired recursion error in Fault.printStackTrace().

Major (all day) website outage caused by JDK1.1 versus JDK1.2 versus JDK1.3 inconsistency in java.security.interface.RSAKey. The deployment server runs Blackdown Linux JDK 1.2.2 since modern versions don't exist for FreeBSD. My development server (Linux) runs IBM JDK 1.3.x. It seems java.security packages differ, causing one of the mybank servlets to hang solid while initializing the JCE, preventing the JWAA servlets from starting. Diagnosed by reverting to the same JDK version on the development and recompiling everything to generate compiler diagnostics. Sigh.

Version 1.3: Nov 2001

Miscellaneous source fixups, improved Makefile and JavaDox.

Build into /jwaa/src/classes, not /jwaa/WEB-INF/classes, so that servlet engines use /jwaa/WEB-INF/lib exclusively.

Moved jwaa and demo into separate jars, jwaa.jar and jwaaDemo.jar, to more easily document the claims mad in the documentation re: the small size of the jwaa kernel classes.

Added manifest to jwaa.jar so mls will be launched by java -jar jwaa.jar. Indexed in same in case servlet engines actually take advantage of this.

Added preController and postController methods to Servlet. Pages can override these to generate per-page boilerplate, do logging, and so forth. Radically simplifies page dispatch.

Replaced boolean acquires(GenericAccount) with the more general filterAccess(GenericAccount) method.

Eliminated SessionExpiredFault in favor of ctx.getViewer(), which returns the viewing account if one exists, otherwise null, which plays well with the filterAccess() change mentioned above.

Removed SessionExpiredException which is no longer needed or used.

Logout no longer invalidates the session but replaces the accountID of the user in the current session with null. This is to remove lingering doubts about how invalidating the session interacts with other parts of the runtime, particular redirect() and forward, on various servlet engines.

Version 1.2: Jul 12 2001

Added <<fileName>> feature to Java+ as the initial basis for compile-time template language support. I hope to extend this idea someday into a carefully designed implementation that fully supports Velocity's template language within JWAA's precompile-time approach.

Replaced Ctx.DoNotReturnException by FakeReturnException to reduce the number of inner classes.

Started an attempt to integrate Velocity within JWAA, then abandoned it for reasons described in the documentation. Made several changes to JWAA behavior while backing out from this attempt

Various cleanups to Mls.java. No externally visible changes except in error messages, etc.

Version 1.1: Jun 28 2001

Renamed from JWAP to JWAA to eliminate confusion with the wireless protocol, WAP.

Moved all/most static Vectors/Hashtables from the architectural JWAA classes out to the application level to eliminate concerns over how they're behaving in tomcat's classloading environment.

Deployment server down all day Thursday Jun 21 with a mysterious JServ failure. Ultimately gave up on JServ and converted to mod_jk. No source changes were needed; the changes were confined to the config files in the etc directories.

Modified JdbcCtx's constructor to not throw PoolFault if the driver list couldn't be loaded by deferring the loading until the first connection is requested.

Renamed Fault -> Fault and used that throughout JWAA as a SoftwareFault replacement.

Moved MailSender and the libraries it depends on (activation, javamail) to the application level to reduce download size, since MailSender isn't used in the JWAA demo.

Version 1.0: Jun 1 2001

Began maintaining versions and change histories with this release.

Changed page.redirect() semantics to throw Ctx.DoNotReturnException instead of returning to the caller to repair a problem that is only apparent with the MacOS X OmiWeb browser. The exception is automatically caught and handled by the dispatch logic and should not be apparent to application.

Extended the Ctx object to manage an application's entire execution context instead of just the application to browser context. In particular, an application's logfile and database connectivity are now managed by the Ctx object. This radically cuts down on the need to pass many different context objects (PrintWriters, Connections, HttpServletRequest, etc) as arguments to low-level routines.

Eliminated log4j throughout the system by incorporating logging commands into the servlet context (Ctx) object.

Moved connection pool handling into Ctx. Now relies on the connection pool to handle connections instead of retaining them in the session structure. Moving the whole responsibility into Ctx should eliminate lingering concerns that poorly written applications might cause connection pool leaks.

Tightened security. Most inherited methods are now final. Replaced Node's Vector getChildren() method with Enumeration children() to inhibit malicious or accidental abuse.

Adopted Doxygen for Java dox. Nice!

Refinements and bug fixes too numerous to list.

Version 0.1: May 2001

Started maintaining the change history.

Version 0.0: April 2001

The prerelease software was released with the May 2001 Dr. Dobb's Journal and is still on their website. The details have changed considerably since then, but the fundamental architecture is essentially unchanged.