If you try JAW’s Very Simple GWT Template, all you need to do is follow a few conventions and you get the following.

1. Create a html file with your complex layout. For instance a really fancy 12×12 html table with all sorts of colspans and rowspans for displaying detailed tabular data.
2. Create a value object (in Java, on the GWT side) that you want to automatically use to dump some attributes into the template.
3. In the html template, use ${valueObject.someProperty} style notation where you want automatic setting of values into the template.
4. In the html template, use $${specialDoubleDollarSign} notation where you want to manually bind the template values.

Really, it is very simple and no frills. It solved my need of presenting data in a visually rich way, into html that a designer could produce without any knowledge of GWT. Also, you can embed it into other widgets, or other widgets into it.

I think it’s cool in two ways:

1. Automatic data binding from your value object, into the ${myObj.property} template slots.
2. Ability to manually attach complex widgets (with GWT defined event behavior), into the $${doubleDollarSignSlot} template slots.

I’ve created a Google Code project with the source code and some examples (as tests). Please take a look and leave criticism and feedback.

If you’re curious how this is implemented, it’s all with defered binding and generators in GWT. As all code I actually want to work, I’ve test driven it and you can look at the tests for details.

Here’s a peek at the different flaws to watch out for, and warn your co-workers about. If you see this in code that is getting checked in, bring it to the attention to your team. See Miško’s post for the full list.

Flaw #1: Constructor does Real Work (link)

• If you have a constructor that is doing “work” you’ve established a contract that everyone who wants to create this object also is forced to wait for that “work” to happen. This becomes a huge problem in small unit tests. Frequently unit tests create many, many instances of the object under test - and any work you do in the constructor slows down tests.
• The solution? Break up the responsibility into two objects: a builder of factory to do all the heavy lifting to construct the object, and whatever the original object was that had the heavy constructor. When you split the responsibilities up you will have a better object oriented design, and make it easy for more flexible construction. If you’re tempted to create an init() method and put the work in there - avoid this siren song. It’s a smell of mixed responsibilities and a poorly behaving object that isn’t really ready when the constructor completes.
• Warning signs are:
  • new keyword in a constructor or at field declaration
  • Static method calls in a constructor or at field declaration
  • Anything more than field assignment in constructors
  • Object not fully initialized after the constructor finishes (watch out for initialize methods)
  • Control flow (conditional or looping logic) in a constructor
  • Code does complex object graph construction inside a constructor rather than using a factory or builder
  • Adding or using an initialization block

Flaw #2: Digging into Collaborators (link)

• Jumping from one object to another to another to get what you want makes for hard to test and hard to refactor code. This is commonly viewed as the Law of Demeter violation, however you can dig into collaborators without breaking the letter of the law. This is hard to work with in tests, because your tests need to do a great deal of setup stuffing objects in objects into other objects, or else you’ll get null pointers.
• Warning signs are:
  • Objects are passed in but never used directly (only used to get access to other objects)
  • Law of Demeter violation: method call chain walks an object graph with more than one dot (.)
  • Suspicious names: context, environment, principal, container, or manager

Flaw #3: Brittle Global State & Singletons (link)

• Global state (usually made possible through the static keyword in Java) creates hard to test and modify code. Parallelizing tests is often impossible, and tests that forget to clean up the global state after running interact undesirably with other tests (causing unexpected failures).
• Warning signs are:
  • Adding or using singletons
  • Adding or using static fields or static methods
  • Adding or using static initialization blocks
  • Adding or using registries
  • Adding or using service locators

Flaw #4: Class Does Too Much (link)

• Object oriented design allows you to split responsibilities into individually tested objects. Using an object oriented language does not prevent people from writing procedural code. In fact, most times when someone does not want to write tests it is because their code is hard to test.
• Warning Signs:
  • Summing up what the class does includes the word “and”
  • Class would be challenging for new team members to read and quickly “get it”
  • Class has fields that are only used in some methods
  • Class has static methods that only operate on parameters

There’s typically no magic wand to wave and make hard to test code instantly testable. Engineers need to have an open mind and learn how to write code designed for testability. (In my experience 90% of the time this involves test driven design and test driven development.) These ideas above, and many of Miško’s other posts are a fantastic starting point for adopting that new way of thinking.

Please link it up with your favorite testability mindset readings.

When you make changes to a server, there are always risks. And even if you have a great backup strategy (I recommend backupninja), sometimes you change a config in the wrong way, which can ruin an otherwise great night. Why don’t we have an easy way to version control this very important configuration directory? (Ubuntu is working on it).

Here’s what $ sudo gitk will show you after a few changes in your /etc.

It’s no surprise that this comes from Joey Hess, who also wrote how to keep your life in svn. I was going to check into subversion all of /etc, but this has been a better experience so far: it has automatic hooks to do pre and post apt-get update commits. So you can more easily see what each package does to your configuration. Also, etckeeper takes care of permissions where svn can’t.

If you’re ready to install, here’s how you do it. I didn’t use the deb distribution because it is quite out of date, instead I pulled down the newest directly from Joey’s git repository.

$ sudo apt-get install git-core gitk
$ cd ~/
$ git://git.kitenet.net/etckeeper
$ cd etckeeper
( read the README and INSTALL files )
( possibly edit etckeeper.conf if you want to use bazaar or mecurial instead of git )
$ sudo make install  ( It's okay if it warns that bzr support not installed if you're not using it )
# sudo etckeeper init
$ cd /etc
$ sudo git status
$ sudo git commit -m "Initial checkin"

That’s it! Check out the README for day to day examples.

Whenever you use apt to install a program, it checks in any uncommitted changes, and then checks in the /etc after apt finishes. /etc is just a regular git repository (except for security permissions require using sudo), so you can also commit changes anytime you want.

Here’s another person’s take on etckeeper. New to Git? Check out Git for Computer Scientists.

You can implement UserType to transparently convert a proprietorially formatted field into first class objects of your choice.

And you can do it in a testable manner.

I’ll show the tests first, then the custom UserType. Right after the bump. (Click the post permalink to read the rest).

/**
 * @author Jonathan Andrew Wolter
 */
public class DimensionsUserTypeTest {
 
  // Fortunately there is no work done in the constructor, so we can easily create an instance
  // of a DimensionsUserType for exercising.
  private DimensionsUserType dimensionsUserType = new DimensionsUserType();
 
  @Test
  public void readsCorrectDimensions() throws Exception {
    // See how we can easily call our "sprouted method" in the test
    assertEquals(new DimensionsDto(1,2,3), dimensionsUserType.processNullSafeGet("001X002X003"));
    assertEquals(new DimensionsDto(100,200,300), dimensionsUserType.processNullSafeGet("100X200X300"));
    assertEquals(new DimensionsDto(1,2,3), dimensionsUserType.processNullSafeGet("01X2X3"));
  }
 
  @Test
  public void readsInvalidDimensions() throws Exception {
    assertEquals(null, dimensionsUserType.processNullSafeGet(null));
  }
 
  @Test
  public void setsCorrectDimensions() throws Exception {
    assertEquals("001X002X003", dimensionsUserType.processNullSafeSet(new DimensionsDto(1,2,3)));
    assertEquals("100X200X300", dimensionsUserType.processNullSafeSet(new DimensionsDto(100, 200, 300)));
  }
 
  @Test
  public void setIncorrectDimensions() throws Exception {
    assertThat(dimensionsUserType.processNullSafeSet(new DimensionsDto(1000,2000,3000)), is(nullValue()));
    assertThat(dimensionsUserType.processNullSafeSet(new DimensionsDto(1000,2,3000)), is(nullValue()));
  }
 
  @Test
  public void setsDimensionsWithDecimalRoundsToInteger() throws Exception {
    assertEquals(new DimensionsDto(2, 2, 3), dimensionsUserType.processNullSafeGet("1.5X2.X3.4"));
    assertEquals(new DimensionsDto(1,0,3), dimensionsUserType.processNullSafeGet("1.0X0.2X3."));
  }
 
  @Test
  public void setsNullDimensions() throws Exception {
    assertThat(dimensionsUserType.processNullSafeSet(null), is(nullValue()));
  }
 
  @Test
  public void interfaceContractualMethods() throws Exception {
    assertEquals(DimensionsDto.class, dimensionsUserType.returnedClass());
    assertThat(dimensionsUserType.sqlTypes(), is(new int[] { Types.VARCHAR }));
  }
 
  @Test
  public void deepCopyAndEquals() throws Exception {
    // VERY IMPORTANT!
    // If this is not implemented correctly, you can potentially be forcing Hibernate to make
    // update calls on EVERY object containing a field of this UserType.
    assertTrue(dimensionsUserType.equals(null, dimensionsUserType.deepCopy(null)));
 
    DimensionsDto dimensions123 = new DimensionsDto(1, 2, 3);
    assertFalse(dimensionsUserType.equals(null, dimensionsUserType.deepCopy(dimensions123)));
    assertFalse(dimensionsUserType.equals(dimensions123, dimensionsUserType.deepCopy(null)));
 
    assertTrue(dimensionsUserType.equals(
            new DimensionsDto(1, 2, 3),
            dimensionsUserType.deepCopy(dimensions123)));
    assertFalse(dimensionsUserType.equals(
            new DimensionsDto(1, 2, 3),
            dimensionsUserType.deepCopy(new DimensionsDto(100, 2, 3))));
 
    DimensionsDto old = new DimensionsDto(100, 2, 3);
    assertNotSame(old, dimensionsUserType.deepCopy(old));
  }
}

The class under test is our implementation of UserType:

/**
 * Custom database field type to convert (transparently) between "004X005X006" varchar fields
 * into a DimensionsDto object of width, length and height properties.
 * @author Jonathan Andrew Wolter
 */
public class DimensionsUserType implements UserType {
 
  public Object assemble(Serializable arg0, Object arg1) throws HibernateException {
    // TODO Tests don't indicate we need to implement this yet.
    return null;
  }
 
  public Object deepCopy(Object dimensions) throws HibernateException {
    if (dimensions == null) {
      return null;
    }
    DimensionsDto dim = (DimensionsDto)dimensions;
    return new DimensionsDto(dim.getLength(), dim.getWidth(), dim.getHeight());
  }
 
  public Serializable disassemble(Object arg0) throws HibernateException {
    // TODO Tests don't indicate we need this now
    return null;
  }
 
  public boolean equals(Object dimensions1, Object dimensions2) throws HibernateException {
    // Extremely, ultra, very important to implement correctly, otherwise we could read out
    // a value from the database, make no changes to the object with the field of type
    // DimensionsUserType, and then isDirty would be true and Hibernate would be forced to make
    // an update statement for every object with this type read.
    if (dimensions1 == null && dimensions2 == null) {
      return true;
    } else if (dimensions1 == null || dimensions2 == null ) {
      return false;
    }
    return dimensions1.equals(dimensions2);
  }
 
  public int hashCode(Object dimensions) throws HibernateException {
    // Very important to implement correctly
    return dimensions.hashCode();
  }
 
  public boolean isMutable() {
    //  Tests are saying it is not mutable is easier for now, as the application is read only,
    // we may need to revisit this later.
    return false;
  }
 
  /** What Hibernate calls when it wants to read a field annoated as using the Type declared by
   * this UserType implementation. We convert the varcar field into a first class DimensionsDto
   * object.
   */
  public Object nullSafeGet(ResultSet resultSet, String[] names, Object owner) throws HibernateException,
          SQLException {
    String rawDimensions = (String) Hibernate.STRING.nullSafeGet(resultSet, names[0]);
    return processNullSafeGet(rawDimensions);
  }
 
  /** Visible for testing. (Sprouted Method)
   *  We call this method directly for testing, because to exercise the {@code nullSafeGet} is
   * difficult in a test. (It would require a ResultSet to be passed in). This method is simple,
   * and can be hammered easily in tests. */
  DimensionsDto processNullSafeGet(String rawDimensions) {
    if (rawDimensions == null) {
      return null;
    }
    String[] split = rawDimensions.split("X");
    if (split.length != 3) {
      // invalid dimensions
      return null;
    }
    return new DimensionsDto(
            Math.round(valueOf(split[0]).floatValue()),
            Math.round(valueOf(split[1]).floatValue()),
            Math.round(valueOf(split[2]).floatValue()));
  }
 
  /** The important entrypoint that Hibernate calls when we want to persist an object with a field
   * declared to have this UserType. The DimensionsDto object is passed in, and we then convert it
   * into the proprietary database schema used in the legacy database.
   */
  public void nullSafeSet(PreparedStatement ps, Object dimensions, int index) throws HibernateException,
          SQLException {
    Hibernate.STRING.nullSafeSet(ps, processNullSafeSet((DimensionsDto)dimensions), index);
  }
 
  /** Visible for testing. (Sprouted Method)
   *  We call into this method from the {@code nullSafeSet} above, because that is difficult to
   *  exercise in a test. However, we can call this method all day long. */
  String processNullSafeSet(DimensionsDto dim) {
    if (dim == null) {
      return null;
    }
    String formattedString = String.format("%03dX%03dX%03d", dim.getLength(), dim.getWidth(), dim.getHeight());
    if (formattedString.length() != 11) {
      // could throw, but we'll be nice instead, because the data is sometimes dirty.
       return null;
    }
    return formattedString;
  }
 
  public Object replace(Object arg0, Object arg1, Object arg2) throws HibernateException {
    // TODO not sure if we need this, tests say we don't so far
    return null;
  }
 
  /** This is the type that we convert TO when using this custom user type. Anywhere you
   * want to use a DimensionsDto object, annotate it with Type(type='xyz.MyUserType') */
  public Class returnedClass() {
    return DimensionsDto.class;
  }
 
  /** This is the SQL time that is stored in the column of the database */
  public int[] sqlTypes() {
    // We return a new array each time, becuase if we used a final array, the elements within
    // could still be mutated.
    return new int[] { Types.VARCHAR };
  }
 
}

If you want to read more about this, check out:

• Hibernate JavaDoc on UserType
• Hibernate docs article
• This blog post from the people at Intelliware

The alternative to using UserTypes is to have your application code do the translations. And you could isolate this potentially within your Repository / DAO layer. So you’d guarantee any object handed off to the rest of your application would have Dimension objects, and not an unparsed String. And that still might be the best thing to do sometimes, because UserTypes have one fatal flaw.

The fatal flaw with UserType’s is they offer no opportunity for dependency injection or configuration. This is a huge disappointment. This means if you need to do more complicated parsing of the raw field, you may be forced to reach out in to the ether and use a static method. Example: what if we parsed some string out of the raw sql row which was a foreign key to another table. How can we look that up? We can’t inject in a service to do this lookup. Read more at a thread over on the Spring Forums about the lack of DI. If you have any doubts of Singletons and Statics as the worst thing ever, please stand up and argue your point.

Go to the camera app and view the picture you want to send, click the send button and email it to one of the special email addresses below, based on their phone number and carrier. These are the SMS gateways from the carriers so the picture will be converted into a picture mail message and you’ll make somebody’s day (-;

I hope this helps you.

There is nothing so precious as your time. I am only more convinced of this every day.

In the last 3 weeks, I listened to:

• Confessions of an Economic Hitman - even though I don’t agree with his conclusions, it is an excellent memoir. It was personally thought provoking to listen to a man’s entire career life unfold in 5 days on my work commute. Takeaway: life can be very exciting, and some people are very powerful. Move faster, driving for results.
• Banker to the Poor - fantastic book. If you don’t know about microfinance, this is your introductory course. Imagine in your mind what the marriage of finance and social justice would look like. I read it with friends–which led to great conversation–and scheduled a tentative meeting with the great folks at Kiva.org for my friend with an NGO in India.
• Travels of a T-Shirt in a Global Economy - So far it’s entertaining. It is a story telling format asking “where did your T-Shirt come from?” And the government-subsidy-enabled-irony of the cotton planted in Texas, woven and sewn in China, and imported back to Florida.

To effective time.

UPDATE (10/26): Listening to more of the last book tonight. Around the 3h 30min mark, I learn the key driver our present industrial economy: the Spinning Jenny. This was a big deal. One person used to have one spinner to make the yarn. In 1764 they suddenly had eight spinners: a tremendous productivity boost in an under supplied marketplace. By 1800, spinning jenny’s had 80 spinners. And by the 1830’s the price was 1/20th of the 1700’s price.

This breakthrough –mechanized yarn production– propelled the world into the industrial age, and brought consumers into expecting constantly improving technology and quality of life. To me the parallels of present day high tech are remarkable, and the “so what” factor noteworthy.

Two “so what” takeaways:

1. The invention of the spinning jenny came because of great bottlenecks in yarn production. In the 1760’s mostly farmers produced cotton yarn, and this was a cottage industry. When harvest time came the families were far too busy harvesting, and weavers had a great difficulties buying yarn. Often they had to walk six miles each day to gather up enough material for that same day’s weaving. This bottleneck –as all bottlenecks– created a great pressure. A pressure that burst forth in invention, and technological revolution.
2. In the face of such bottlenecks, Britain sanctioned a contest of which the spinning jenny was an entrant. An example from the past of how using prizes compelled innovation. See the X Prize Foundation for present day contests in medicine, automotive, education, or (Google’s just announced) Lunar X Prize.

A few weeks ago I was at a large web 2.0 social networking site working with selenium grid automation. They were great clients, fully receptive to automated testing. Next week I’ll be heading to another leading internet company to work triage:

1. Work on troubled teams whose code is poorly tested
2. Enable groups to test legacy code
3. Attempt to spread a pervasive test driven mindset.

I’m joining a senior team of ThoughtWorkers and in preparation I’ve thought of various arguments I’ve heard (or used myself) against testing code. I’ll be challenged working with these very experienced people, but I am eagerly looking forward to the experience.

Argument #1

Adding all these tests only makes more code to maintain, debug, and write. This can’t be good - I want less work, not more!

Rebuttal: Would you agree code and requirements often change? Would it be valuable if something could automatically and accurately catch bugs introduced with changes? How about if the original developers are no longer on the project? Testing can enable less work — in a dynamically changing environment. Immediately the work is greater, but over time it is less.

Argument #2

Ok, fair enough, there are some good reasons to do this. BUT, when I want to change something later, I now have two points of failure - the code I’m changing, and all the tests that depend on that code. I haven’t really bought myself all that much security, because if my tests don’t catch the problem well, I’m just as hosed as if I had no tests. ^{Source: first comment from here}
Rebuttal:

1. You get better and faster with tests the more you write them.
2. By writing tests you further understand the business domain and craft a better thought out solution.
3. Whenever making changes in the future you actually have 1 + n points of failure. That which you are changing plus the other interacting systems within the code. By writing tests you will automatically catch the interactions, as well as the initial point of failure. Sure the tests need maintaining, but now with two things to maintain, you catch (almost all) these failure points.

Argument #3

I generally think testing is a good idea. But I’m stressed out, I’ll get to it later… tomorrow I’ll add tests… as soon as I get this working
Rebuttal: Take a page from Agile Software Development: Principles, Patterns, and Practices by Robert C. Martin.. He argues for refactoring but since the two concepts are so tightly entwined, I think the argument applies here:

“Refactoring is like cleaning up the kitchen after dinner. The first time you skip it, you are done with dinner more quickly. But that lack of clean dishes and clear working space makes dinner take longer to prepare the next day. This makes you want to skip cleaning again. Indeed, you can always finish dinner faster today if you skip cleaning, but the mess builds and builds. Eventually you are spending an inordinate amount of time hunting for the right cooking utensils, chiseling the encrusted dried food off of the dishes, and scrubbing them down so that they are suitable to cook with. Dinner takes forever. Skipping the cleanup does not really make dinner go faster.”

Skipping testing does not really make software development faster, because changes are guaranteed. (You’ll have to cook another dinner eventually). Without an easy way to baseline and build upon existing code, time is spent bugfixing that could instead be adding features or writing new tests.

Argument #4

I’m awesome. I don’t write bugs. So I don’t need tests.
Rebuttal: Great. I’m excited to be working with you. I’m sure I’ll be able to learn a great deal. I imagine you like fresh challenges. And in six months or a year this current project won’t be as interesting to you as it is today. In fact, you’ll be on to something more challenging and worthy of your awesomeness.

So that means someone else — possibly a junior developer — will be maintaining and working on this code. Without tests, they will be frequently seeking your assistance and guidance to prevent bugs. This is not what you want, is it? You want new challenges, not constantly being hassled by old code. So write the tests now to ensure your ego and intellect can move forward to bigger and better things.

Elaborating and paraphrasing, Neal Ford argued at eRubycon 2007:

Now I look at not testing as professionally irresponsible. I’m paid to create software, to deliver on a client’s business needs. If I don’t rigorously and automatically ensure I have accomplished this with the minimum amount of bugs — I am committing malpractice.

What arguments have you encountered, and how have you responded?

I believe working full time, with great people, and doing my own projects on the side will be vastly more productive than having full time for my own projects.

After leaving FeedBurner with the Google acquisition, I gave myself 2 months of running my own business full time. After that period, I would either be hiring folks, giving myself a few more months, or getting more experience at a startup or consulting.

Second Valley’s revenues are up a healthy 25-40% compared to May. I’ve been spending time in Ruby on Rails, and have started rebuilding the full ecommerce and delivery platform for one of Second Valley’s sites. But I missed the smart coworkers.

My decision Wednesday was to email ThoughtWorks and continue my interview process I started prior to joining FeedBurner. Well, thanks to the amazing Carrie McComb, I interviewed Thursday and had an informal offer that night. Friday morning I signed and it’s official.

In 10 days I’ll be off to India for ThoughtWorks Immersion training, and then I’m relocating to San Francisco.

Photo credits: meaux, and artview (my previous trip to India)

1. I left the botique enterprise content management software consulting company, Technology Services Group. ^[1]
2. I joined FeedBurner, as an engineer in February.
3. I did some really cool ad serving optimization code. My IE degree let me do some fun multivariate linear regressions to prioritize ad serving into their feed ad network. The code base was great to work in. Plus the team was great and I’ll really miss them. This leads to #4.
4. Thanks to the Chicago PHP users’ group, as well as my Chicago tech event calendar site Techsocial, I was able to attend php|tek. The presentations are now available. ^[2]
5. Google acquired FeedBurner in July. I don’t have much to say here, other than I learned a ton living through the acquisition process.
6. Meanwhile, I incorporated a side business that I’ve been working on since 2003. It’s been profitable since the launch in September ‘06. The entity is Second Valley, Inc, but I”m operating under another name. ^[3]
7. I pretty much had the perfect opportunity to ramp up my business by working on it full time. I’ll spend a few months at marketing, product development, (more) SEO, statistical analysis enhancements, and rebuilding the PHP app in Ruby on Rails.

Notes:

Note: this is a technical post, it assumes you’re interested in, and familiar with Rails.

Rails wants to be RESTful. Many sites and books go into depth explaining REST. Last year’s Railsconf keynote by DHH can give you the big picture of CRUD and RESTful applications. (Be sure to follow along with the pdf slides, while you watch the video).

Look at an existing mature project (Beast) to learn how to make RESTful models

Nitty gritty RESTful implementation details have been hard to find. So I started searching out open source projects that are known for good design. And I read the code.

Beast is a forum program written in Rails by Rick Olson and Josh Goebel. Best of all, it’s a great example of a REST application.

I’m a visual person, so I created the chart below to help me get the hang of what the Models and relationships look like in Beast. Big bold squares are actual database backed objects. Dotted squares are just regular models.

Please contact me if you catch an error or omission.

Here’s how you use the diagram

Right now, browse here: http://svn.techno-weenie.net/projects/beast/trunk/app/models to the Subversion source of Beast. Back already? My you’re fast. Read over the different model objects. See how they relate. Think about what’s been abstracted into additional Resources, rather than creating actions willy nilly in the controllers.

Then check it out and run it in your local environment. Even if you couldn’t care less about the (quite nice) forum software that it is, it’s good to learn by taking it for a spin.

But I think I need more actions than CRUD gives me!

As DHH said in the 2006 Railsconf keynote, sometimes you think you need another non-CRUD verb to your controller. Say you have a Forum that has Users and Topics. Some users want to monitor topics. At first blush, you may want to add an action to Topic. You’d then post to /topic/monitor/123 to start monitoring topic 123.

There is another way.

Relationships, events and states can all be models. When a new topic is to be monitored, you’ll GET to /monitorships/new to get the new Monitorship object form. Then POST to /monitorships to actually create it.

Models are more than things.