There has been much debate concerning the relative merits of static and dynamic languages. Dynamic language enthusiasts feel they are far more productive when using languages such as Smalltalk, Python, and Ruby compared to static languages like Java or C++. Static language enthusiasts feel that although dynamic languages are great for quickly building a small prototype, languages such as Java and C++ are better suited to the job of building large, robust systems. I recently noticed that in my own day-to-day programming with Java and Python, I approach programming with a different mindset depending upon the language I'm using. I began to wonder to what extent the mindset encouraged by a language and its surrounding culture influences people's perceived productivity when they use that language.

Refactoring JSPs to Poor Man's Struts

A year ago at Artima I had a large number of JSPs that weren't organized in an model-view-controller (MVC) architecture. In these JSPs, the business logic was mixed with logic responsible for generating the HTML view. I wanted to start making incremental improvements to these JSPs by refactoring each JSP into an MVC architecture whenever I needed to make a change to that JSP. I didn't want to change any existing URLs, and wasn't pleased with the frameworks I investigated such as Struts and WebWork, so I adopted an interim approach I called "poor man's struts."

For each JSP I refactored to the poor man's struts architecture, I created a Page class (the controller) with a static process method. I moved the business logic from the JSP into the process method, and called the process method from the top of the JSP, like this:

// Imagine this is the top of a JSP,...
ExamplePage.Context context = ExamplePage.process(request, response, session);

After executing the business logic, the process method returned a context object filled with objects that the remainder of the JSP needed to render the page. Because the business logic often included explicit redirects, I decided to let the context object indicate whether or not the process method had already redirected the client. If the so, the JSP simply returned:

// Imagine this is the top of a JSP,...
ExamplePage.Context context = ExamplePage.process(request, response, session);

if (context.isRedirected()) {
    return;
}

// Imagine this is the top of a JSP,...
ExamplePage.Context context = ExamplePage.process(request, response, session);

if (context.isRedirected()) {
    return;
}

long forumID = context.getForumID();
boolean reply = context.isReply();
String subject = context.getSubject();
String body = context.getBody();

The Context Classes

public class ControllerContext {

    private boolean redirected;

    public ControllerContext(boolean redirected) {
        this.redirected = redirected;
    }

    public boolean isRedirected() {
        return redirected;
    }
}

For each Page class, I created a nested class called Context. The constructor of this class accepted a boolean redirected flag and a parameter for each value or object needed by the JSP. Here's an example:

// Declared inside the ExamplePage controller class

public static class Context extends ControllerContext {

    private long forumID;
    private boolean reply;
    private String subject;
    private String body;

    public Context(boolean redirected, long forumID, boolean reply,
                    String subject, String body) {

        super(redirected);

        if (forumID < 0) {
            throw new IllegalArgumentException();
        }
        if (subject == null || body == null) {
            throw new NullPointerException();
        }

        this.forumID = forumID;
        this.reply = reply;
        this.subject = subject;
        this.body = body;
    }

    public long getForumID() {
        return forumID;
    }

    public boolean isReply() {
        return reply;
    }

    public String getSubject() {
        return subject;
    }

    public String getBody() {
        return body;
    }
}

Attitudes on Multi-Valued Returns

The context object is a vehicle that enables the process method to return multiple values to the JSP. In several Java MVC frameworks, the context object is essentially a Map. The controller places objects into the context Map identified by named keys. Had I taken this approach in poor man's struts, for example, the process method of ExamplePage could have placed the subject string "A Tale of Two Cities" into the Map with the key "subject". I rejected this approach primarily because I felt creating a specific Context class for each controller would allow me to employ the type system to enforce constraints. The ControllerContext superclass, for example, enforces that all context objects supply a boolean redirected value. The ExamplePage.Context subclass enforces that ExamplePage.process always provides a non-negative forumID. My theory was that such constraint checking would help me achieve robust code.

In practice, however, I found I was always in a hurry when I refactored a JSP to poor man's struts, because I only performed this kind of refactoring when I otherwise had some enhancement or bug fix to make to the JSP. I also found that this approach to the context object required a lot of code. To speed up the process, I wrote a Python script that, given a simple list of types and variable names, generated much of the needed Java code. The Python script did not generate any validation of input parameters in the Context constructor. I needed to write those by hand, and I discovered that I rarely felt it worth the time to do so.

Given this experience, I ultimately decided that the added type safety wasn't really worth the extra effort it required in this situation. In our new MVC architecture, the controllers return essentially a Map context, and we enforce constraints with unit tests. The wierd thing is that I realized that if I had been designing poor man's struts in Python, I probably wouldn't have thought twice about just returning all that information in a tuple, as in:

(redirected, forumID, reply, subject, body) = ExamplePage.process(req, resp, session)

From a safety perspective, a tuple seems even more error prone than a Map, because I have to get the order correct on both sides, not just the names. If the thirteenth element in the tuple is a message ID, then I have to make sure the thirteenth element in both the return and assignment tuples is messageID. While order is generally random, names of keys and variables are usually similar, such as:

String subject = context.get("subject");

One reason is that Python supports this multi-valued return technique better in its syntax than Java, but I realized that the availability of syntax isn't the main reason I do it in Python. The main reason is that's the way it's usually done in Python. By contrast, that's not the way it's usually done in Java. The cultures are different. The culture that guided the design of a language influences my attitudes and mindset when I use the language. The Java culture encourages me to build solid bricks that can be combined to build large, dependable systems. The Python culture encourages me to glide smoothly and quickly to a solution.

class Context(dict):
  def __init__(self, *kwargs):
    self.update(kwargs)
    assert isinstance(self['forumID'], int)
    assert self['forumID'] > 0

// Tuple API written once!
// J5 Only - Note class Tuple defines static classes and static methods
public class Tuple {
    // ... other Tuples
    public static class T5<E1,E2,E3,E4,E5> {
        public E1 e1;
        // ...
        public E5 e5;
        public T5(E1 e1,E2 e2,E3 e3,E4 e4,E5 e5) {
            this.e1=e1;
            // ...
            this.e5=e5;
        }
    }
    public static <E1,E2,E3,E4,E5> T5 t((E1 e1,E2 e2,E3 e3,E4 e4,E5 e5) {
        return new T5(e1,e2,e3,e4,e5);
    }
}
 
// Then for ExamplePage
import static Tuple.*; // Note static import
public class ExamplePage {
    public static T5 process(Request request,Response response,Session session) {
        // ...
        return t(redirected,forumID,reply,subject,body);
    }
}
 
// Then in use - using same names as original example
T5<Boolean,Boolean,Long,String,String> redirectedReplyForumIDSubjectBody=ExamplePage.process(request,response,session);
 
// Then when you want to refactor into a class
import static Tuple.*; // Note static import
public class Process extends T5<Boolean,Boolean,Long,String,String> {
    public Boolean getRedirected() { return e1; }
    // ...
    public String getBody() { return e5; }
    // Other methods
}