After a bit of chaos, a beginning.

A major family emergency drove all thought of this stuff from my head for a while, but now I'm back and ready to actually make good the promise I made myself earlier this year.

The project which has generated the most interest in my circle of (online) friends is the game server (Silt Server). Thus it will be my first piece of work. I've done a preliminary document explaining the reasons for the project and my goals with it, but I'll repeat some of the key points here. At any point you can just hit the main document for a more complete explanation.

The Silt Server (the name is a bit of an inside joke) is intended to solve the following problems with online text-based games:

1. Appearance (MUDs and co. are ugly);
2. Enhancement (MUDs and co. are difficult to expand on and feature unpopular/unknown languages);
3. Modularity (it's difficult to make plug-in code for MUDs and co.);
4. Usability (MUDs and co. are incoherent and confusing).

Incidentally, the term "MUDs and co." (or various other alternatives like "MU*es") are clumsy to type. I will be from this point on be using the term favoured by my (online) friend: MUTE (for Multi-User Text Environment).

The Silt Server's goals are to address each of the above issues:

1. The native (but not only) environment is the World Wide Web and will look familiar and comfortable to the modern Internet user;
2. Will be extensible in a variety of well-known languages including (obviously) Java as well as any other language which can be used through the BSF;
3. Being based on a modern, enterprise-oriented language like Java and written inside of the Java EE 5 framework mandates modularity;
4. Coherent, consistent interfaces and command structures are central to the design.

There is one last goal which is not necessary to the creation nor success of Silt, but should be stated before anybody starts telling me how X language on Y framework is simply a much better platform: I'm using this project to brush up on my Java skills and to teach myself the Java EE environment. This is for purely pragmatic reasons related to job searching.

Over the next few days I will be outlining the architecture of the Silt Server starting from the client perspective and moving down through the (optional, but default) web tier, into the server tier and finally, if necessary, down to the data store tier.

Dusting out the cobwebs.

So, it's been slightly over a year since I last did anything in this blog. (Anybody who's seen my personal blog can likely guess why I've not had a lot of time to commit to anything software-related.) In that year a few things have changed and the nature of this blog will change as well.

The first thing that has changed is that I'm going to re-enter the field of software development properly now. I'm looking for a job because teaching doesn't pay enough for what I want out of life and the only other talent I have boils down to software. Given my needs for quickly re-entering the software scene, I'm heading down the dark path of Java. Yes, I hate the language. It's turgid. It's verbose. It's ugly. It is, however, the best place to go to quickly get a job and make cash. To this end I'm working toward getting SCJP-, SCJD- and SCEA-certified. (Of those three, only the last one looks like any kind of real challenge. The first is basically a trivia test and the second is a test on whether I know design patterns or not, it seems.)

This doesn't mean I've given up on my hobby of learning languages to do cool things. Even now that I've decided my professional future is a Java one, I'm still looking outside the box. I've already assembled over 20 different programming languages based on the JVM, for example, including everything from a serious Auld Skhool BASIC dialect to languages like Scala and Clojure. No reason why I can't program to the JVM in a language that doesn't suck completely, after all.

That and I'm also still going to be playing around with things like Erlang, Ruby and Haskell. I just don't see any real chance of ever getting serious work with any of those three (although Erlang prospects are marginally better).

Over the upcoming months I'll be working on two Java-related projects to learn the field. The first of these is an online text game client (MUD, MUSH, MOO, MUCK, et al). This should give me a good taste of Swing, a limited look at things like data persistence (perhaps db4o?) and a good all-round pile of Java tedium. I'll be using this as my exploratory bed for the SCJP/D stuff, getting my head around the Java way of doing things and the accumulated wisdom of the Java community when dealing with the inevitable problems the language's rigid restrictions causes.

The second project is a re-envisioning of the online text game. I think it's a mistake to use Telnet as the basis for a game in this modern age. Telnet is ugly and limited in ways that show off the WORST qualities of such games. I intend instead to make a web-based project that does the same thing as a MU*, only provides the added goodness of the modern World Wide Web as well. It may well even support a Telnet interface for the die-hard grognards who refuse to try anything new. Since this project is intended to hammer out Java EE comprehension, I will be using a Java EE application server as the platform.

My toolkit for this so far includes the Netbeans IDE, the jEdit text editor environment and the Glassfish application server. Over the next few months I'll be talking about the interesting things I find while I'm working on these, as well as using this as a sounding board for design ideas.

All of my projects will, of course, be F/OSS. I'll probably dual-licence under the CDDL and the GPL2.