What I Know and What I'm Learning

I am always learning new techniques and practices. This page shows what tools I use now, what I am learning currently, and what I am watching hopefully to learn in the future.

Environment

I choose to work in Unix. Unix offers easy, quick scripting which I use to automate many routine processes. Unix has a history of reliability. I can find many high quality Unix tools with thorough manuals on the Internet, often free and open source. Unix scales well from lap tops to mainframes, so I can confidently test my software in my environment and expect it to work everywhere. Even on my lap top, I rarely reboot my machine; I measure up time in months. I have been using Unix for ten years and am still a journeyman.

I chose Linux over BSD Unix because Linux JDKs are available earlier, and because the Linux software community is stronger. From my background reading I have learned that BSD Unix has a better underlying architecture. I hope to switch over when Sun supports JDKs for BSD Unix.

"Write once, test everywhere." I do have environments to test software on WindowsMe and MacOSX. By automating tests, I can quickly test an application in new environments at any point in development.

Languages

• Languages I use now:

  • While I design software, I write down what that software will do in English. I try to use the active voice, make sure that every "this" points somewhere, avoid words with vague Latin endings like "transcription," and avoid vague terms like "manager." This technique uncovers hidden flaws in designs and plans long before those flaws cause problems.

  • I sometimes use parts of UML to explain specific design details. Creating UML diagrams can produce tomes of useless documents that quickly become irrelevant. I only use UML to work through particularly challenging aspects of a design, and to explain the design to others. TogetherSoft's Control Center helps keep UML diagrams up to date.

  • I try to use either plain text or HTML for all my documents. Plain text is the most reliable format of all; it has been available on computers for thirty years. Unix provides a cornucopia of tools for manipulating plain text. When I need to include some formatting, links, or a diagram, I use HTML. Most environments have HTML browsers available, making it nearly as universal as plain text.

  • I do most of my work in Java, a powerful language from Sun designed for building and running applications inside the bounds of a virtual machine. The virtual machine makes creating secure reliable applications possible. Java's standardized memory and thread management allow me to use another's code with confidence. A friend gave me a copy of Java alpha 3 in 1994. I have never looked back.

  • I use XML extensively to store telephone transcripts in a current client's project, and have used it for a few years in Wildfire's telephony user interface languages, Time0's logging system, J2EE deployment descriptors, and ant build scripts. XML is a format for general data structures. I expect to use more XML in the future as various groups agree on standard XML tag sets. At BD-X, we are using a custom tag set to store documents in a simple, verifiable format. I am using both SAX and DOM parsers to validate the documents and make them easy to edit. I haven't learned XSL yet.

  • Every so often I use C, especially in server side code and numerical simulations. I spent the first three years of my career creating statistical and fractal simulations which took advantage of C's speed. C can take advantage of hardware- and environment-specific features that Java can not reach. Some Java code I write contains tiny C libraries. For example, the logging system I wrote for Time0 returned the current process's Unix identification number via a C function.

  • I use SQL to manipulate data in databases. SQL is fairly simple. Unfortunately, SQL follows a loose standard. Each database vendor interprets the language differently; I often have to write slightly different database code for each vendor's software. My net.walend.support.jdbc package in Lyophilizer helps generalize these differences. SQL's simplicity keeps it from solving every problem in database queries, but it will usually do 99% of what people expect. I hope to start using JDO as a more standard replacement for JDBC, or at least an overlay for SQL.

  • I use JSPs to dynamically generate web pages. (Some day I will make this page JSP.) JSP embeds a dynamic protocol inside of HTML or XML that provides ready access to Java Servlets and JavaBeans. I prefer to use JSPs for web-based user interfaces.

  • I use bsh, the bean shell language to embed scripts in jEdit for some projects.

• Languages I am currently learning:

  • In Somnifugi, I will be generating java bytecodes using BCEL to create dynamic classes from message selector strings.

  • This year, I plan to learn how to do very dynamic queries using DROOLS, and to start some experiments in genetic programming. I am learning Lisp for both of these projects.

  • On the other end of the academic/pragmatic spectrum, I have written a few simple perl scripts, but don't feel comfortable marketing this skill yet.

  • My JDigraph project has many instances of repeated patterns of code that implements a common interface. Aspect programming would help reduce repeated code by letting me apply aspects to objects to give them new behaviors. AspectJ extends the Java language with constructs for aspects that would let me add these behaviors consistently.

• Languages I am watching hopefully:

  • I hope to use DROOLS, an implementation of the Rete algorithm that runs inside a Java virtual machine, to do the 1% of searches that SQL can not do.

  • I touched Python briefly two years ago and may pick it up after Lisp. JPython will allow me to write powerful scripts for Java using the Python language.

Automating Software Builds, Tests and Diagnostics

• Jakarta's ant build scripting tool lets me create reliable, repeatable build processes. I use ant to build, package, test and distribute software. ant has a simple, human-readable XML syntax. I simply create a target for each step in the procedure. Then I can always repeat every compilation, test, and tar ball. This keeps my projects consistent. I helped write part of ant's user manual. At Wildfire, I am teaching how to use ant successfully in a large project by keeping the build files simple.

• I write my tests using the JUnit framework. JUnit is becoming the standard unit test suite for Java. I have used it for broader system tests. JUnit itself is nothing special, but does provide a standard that many developers follow. I've contributed two patches to JUnit to simplify generating test cases.

• I've just started using JFCUnit, an extension to JUnit that helps create tests for Swing user interfaces.

• This fall I started using HTTPUnit to automate web user interface testing.

• I created a logging system while at Time0. It's been superseded by the java.logging package. Good diagnostic logs let me quickly determine what happened during a testing run. They also help me determine what caused any problems a client may encounter.

• I sometimes use OptimizeIt to uncover choke points in code. OptimizeIt helps identify the most useful places in code to improve performance. I've used this tool to increase the speed of Johnson's algorithm for shortest paths by several orders of magnitude. OptimizeIt is from Borland.

Editing Tools

• I primarily use emacs to create software. I use it for plain text, html, JSP, xml, sql, Java, C and lisp code.

• I have started using jEdit as the base for a client's custom mark up tool. jEdit is a text editor written in Java. jEdit comes with a GPL license, but I can write macros and plugins independent from those restrictions.

• I use Control Center from TogetherSoft to work with UML diagrams. Control Center is one of two commercial products on this page. Control Center provides two-way interaction between the diagrams and the code. Inside Control Center, I can keep UML diagrams up to date without effort. Otherwise, I would have to edit them by hand whenever I changed code or let the diagrams drift out of date.

Source Code Control

• I keep every file that has anything to do with the success of a project inside of source code control. I can always return to a previous state. That ability frees me to refactor or try experiments when I need to, and makes consistent builds possible. It also makes backing up files simple, which prevents disasters. I currently use CVSat home and Perforce at work, but am looking forward to when Tigris finishes Subversion.

Web Presentation

• I use the Apache web server from apache.org. Apache scales up to loads greater than my server will ever need to carry.

• I use Servlets and JSPs to present dynamic web pages. I use Tomcat as a servlet and JSP engine during development.

• Apache-Jakarta is working on a framework for JSPs called Struts which looks very promising. I worked with it briefly at Time0, but have not built anything permanent yet.

• I plan to use Java Web Start to deliver snap shots of my projects to my clients now that JSDK 1.4 supplies it. Java Web Start will provide a nice alternative to emailing, unpacking and installing tar balls.

Data Storage and Search

• Any but the simplest data storage involves using a database. Most viable databases are relational. However, most data is object-oriented and doesn't fit into relational database tables easily. I created the Lyophilizer kit to quickly map JavaBeans to persistent long-term storage. Lyophilizer provides a toolkit for mapping Java objects into relational databases. This tool kit helps me create and test this mapping very quickly. Lyophilizer's persistent layer will soon be superseded by JDO. I plan to split the other segments into their own projects.

• I am forming plans to create my own JDO implementation on top of Xindice, but am waiting for the JAXB standard to be finished.

• When I write JDBC code, I reuse a group of objects I keep in the net.walend.support.jdbc package. These objects let me make frequent, simple database calls in a standard way.

• For small scale projects, I like to use HSQLDB. HSQLDB is an open source pure-Java database that can run on a local disk, over a network, or in memory. I have contributed a test case to HSQLDB. Aside from that one case, it's worked fine.

• For mid-scale projects, I typically use MySQL, a fast, free enterprise-class database.

• On large scale projects, my clients have always asked me to use Oracle or Sybase.

• At some point I hope to provide a way for DROOLS to use a JDO database as its fact base. DROOLS still needs to grow up, so I don't expect to start this work until this summer at the earliest.

Application Servers and Distributed Software

• At Wildfire, we use Weblogic and JBoss. At Time0, we used Weblogic's application server to provide EJBs. In Lyophilizer, I have used JBoss, Weblogic and Jonas. I use the interface-driver pattern extensively when creating systems of EJBs. This technique makes it possible to switch EJB management on, when transactions matter, and off, when the don't, especially for testing and development. The technique also makes my EJB code easy to understand and maintain.

• Lyophilizer provides a generic layer over EJBs to make them look and behave like JavaBeans. Lyophilizer separates the EJB code completely from the business logic and storage code. This modularity isolates small changes and makes unit testing possible. Lyophilizer matches JDO feature for feature, so I've abandoned Lyophilizer for the industry standard.

• I created Somnifugi JMS, an in-memory JMS system. Somnifugi works within a single JVM, picking up where distributed JMS implementations stop. Somnifugi JMS is especially useful for prototyping systems and in systems where different JMS clients can benefit from sharing memory. This project also let me learn about JNDI compatibility.

Open Source Projects

My open source projects include

• Cricket Cage automatically creates JUnit TestCases for repeatable bugs and test scenarios. Including Cricket Cage's AspectJ code in a compilation installs the code generator. Running the scenario generates the TestCase from a Velocity template. Adding the new TestCase to an ant build script insures that every successful build passes that test, so no code changes break the scenario.

• JEnum is a Java runtime jar for working with enumerated types, as described in Josh Bloch's Effective Java Item 21, and a one-way code generator to create the needed classes from xml and Velocity templates. The API is patterned after the Java Collections API.

• Somnifugi JMS is an implementation of JMS that works inside a single JVM to send JMS Messages between Threads. Somnifugi is particularly useful for isolating the AWT Thread so that the user interface will stay lively, for decoupling calls to external resources such as database connections, and for speeding up systems of generic JMS clients by allowing decoupled JMS clients to share memory in the same JVM.

• JDigraph is a Java library for representing and working with directed graphs and paths. The JDigraph API is patterned after the Java Collections API. It provides interfaces and implementations of unique-edge, common-edge and generic-edge directed graphs and paths, supporting classes, and implementations of Dijkstra's, Bellman-Ford's, Floyd-Warshall and Johnson's algorithms. JDigraph also shows my best example of automated building, testing and packaging of a project.

• Lyophilizer provides a robust generic kit of interfaces so that developers can create algorithms and systems of JavaBeans without worrying about different kinds of persistence back ends. Lyophilizer uses the "interface & driver" pattern extensively to insulate developer's interesting code from changes in the system's distribution, persistence, security or transaction support.

I have helped out in a few other open source projects

• I helped rewrite the ant user manual when I found a few errors in the examples.

• I added a few methods in JUnit to better handle exceptions.

• With Slava Pestov, I revived the XML tools for JEdit.

• I added a unit test to HSQLDB.

• I recommended several new features in Java. The most prominent is the Shutdown Hooks API in Java 1.3. They even used the method name I suggested in the bug report.

I'm thinking about taking up these open source projects in the future:

• Fixing ant to clean up the stray properties files ant creates when using JUnit tasks.

• An extension for JUnit that measures computational complexity via AspectJ.

• A web scanner to let me know when web page content has changed on pages I care about.

• A JDO implementation on top of Xindice and JMS.

• A distributed SciLab farm system based on JMS or JINI.

Book Recommendation

• I rarely recommend books, but The Pragmatic Programmer by Andrew Hunt and David Thomas changed the way I work. If I could write, I would have written half of this book. The other half gave me great ideas and insights into how to get projects done.

Here's my current reading stack:

• Papers for school

• Pizza compiler for java

• Xindice's documentation

• JAXB and XPath specifications

• A LISP language book

• Designing Web Usability

Contact Information

http://www.walend.net
mailto:david@walend.net
88 Ripley St
Newton MA 02459
617 916 2763

Home How What Resume