What debate as is as vitriolic or virulent as one involving coding style? What subject more a flame inducing napalm? And when pride is on the line, what clash more titanic?

Yesterday, I was presenting a graph structure API indented for use as the model layer in a MVP style map visualizer. I’d spent the better part of December refining and reworking the approach until order was born of choice, consistency from confusion, simplicity from complexity. As a result, there were few complaints except a matter style.

“Why,” asks the Proud Programmer, “are you leaving out the space after method names?”

“Leaving out a space? Where?”

“Here for example,” says the Proud Programmer, “you wrote:

public Object put(Object key, double value);

“where the style guideline requires a space:

public Object put (Object key, double value);

“You always put a space after the method name if the method takes arguments.”

I am dumbfounded, “where did you come up with that? What style guideline? I’ve never seen it before?”

The Proud Programer retorts, “It’s the style for both Nomads and CmapTools.”

I reply, “that may be true. I’ve never worked on either of the projects. None of my projects do that; moreover, I’ve never seen it before. Where did you come up with it? The Java Book (Arnold, Gosling, and Holmes) has no space.”

The Proud Programmer calls on authority, “Surely you’re mistaken. The space is in the Java coding conventions. It goes back all the way to K&R.”

The Proud Programmer has gone too far. Now I’m liberal person. I believe man can do what he wants with is spaces, his tabs, and his curly braces. His spaces end where my curly braces begin, but I’m an accommodating person. When a guest in your blocks or your classes, I will live by your rule no matter how repugnant. But you have made mistake my proud friend. Invoking K&R is serious. K&R is scripture. Misrepresentation is blasphemy. Such offenses cannot go unchecked. Therefore, I am obliged to call, “No it doesn’t. It’s fine that you have your own style. But K&R don’t use a space.”

Proud Programmer is confident, “Of course it does.”

Too confident he is, “I’m sure it was the other way. Perhaps one of us has not reviewed K&R recently.”

With this, the meeting is over. No discussion can continue until matters of doctrine are settled. I go to my office. Check the Java book. Have I forgotten the way? No, no, I see the methods and there is no space. To the Proud Programmer’s office. He’s just opening K&R as I enter. He looks, again no space. He’s shocked, confused, he denies the truth though it’s right in front of his face. “Why do they do that? The arguments run together with the function name. That’s just wrong.” I show him the Java book. He doesn’t consider it authoritative. “What does this Gosling fellow know about Java? I’m sure the Java style guide as a space.”

I return to my office. Just to ensure that I’ll have the freedom from spaces in my own code, I look up the Code Conventions for the Java Programming Language hoping to trample all claims of authority. I’m luck. Page 15 of the PDF, “No space between a method name and the parenthesis ’(’ starting its parameter list,” unequivocal vindication. I close my message, “So you see, I’m still curious where you came up with your conventions.”

This is an honest question. Orthodox or heretic, it’s all a matter of style. I may have precise preferences. But I can tell when I’m in the mainstream or a heretic headed upstream. Semicolons at the end of lines in

JavaScript, for example. I won’t have them, but that’s certainly not the received style as outlined by the Rhino book. (Not that the Rhino book can be truly authoritative. After all, it conflicts with K&R and Java on the point of spaces after for, while, and switch.)

Another example, I always put spaces around arithmetic operators and I never put spaces around string concatenate . I think the space improves readability for arithmetic. But ends up unwieldy for strings. Compare ”(” + x + ”, ” + y + ”)” and ”(”+x”, ”y”)”. As a nice side effect, one can tell without context, whether I mean strings or numbers. Though when given free choice, I’d prefer spicing. Of all the forms, my favorite is ”({x}, {y})”. I don’t know where it comes from. I first encountered it with Factor.

Which brings us back to the question. Who uses space and why? Where does the practice come from? Though I had never seen it in Java, it is used in Lua. (Not that Lua’s syntax wins many beauty pageants. It does do well in the object literal competition and is simply marvelous when it comes to nested comments and here documents.) Likewise, it’s used in Lua’s source. So I imagine the space comes from some C practitioner though I’d like to know who.

For the last year or two I’ve been developing desktop applications with the Eclipse Rich Client Platform (RCP). One of the most difficult aspects of this sort of development has been testing. GUI testing can be tricky and there’s lots of reasonable reasons why someone would avoid GUI testing as much as possible. However, seeing how the test driven development (TDD) approach has helped me in other areas, I’ve wanted to discover a good TDD process for Eclipse RCP development.

After spending time reading up on GUI design patterns I felt I had a reasonable grasp on several architectural approaches, but not on a preferred development process. This week Tim Ottinger pointed me to presenter first and I think it may be the final key to getting everything just right. Atomic Object’s papers on the pattern are decent but I’ve but together another example to see the process step by step.

Imagine a simple screen with two lists and two buttons, one for moving items from list A to list B and the other button for movement of B to A. List A constains “Good, Fast, Cheap, Done” and the constraint is that you can only pick 3. Once you do, the A to B button must be disabled. Using a test driven approach, development go like this:

We create 4 objects:

 IProjectModel       <-- the model interface
 IProjectView        <-- the view interface
 ProjectPresenter    <-- presenter that takes view and model in constructor
 Option              <-- the model data object (wraps a string)

Then we start creating tests. Our first test looks like this:

 public void setUp() {
good = new Option(“good”);

    cheap = new Option(“cheap”);

    fast = new Option(“fast”);

    done = new Option(“done”);
List options = new ArrayList();

    options.add(good);

    options.add(cheap);

    options.add(fast);

    options.add(done);
model = new MockProjectModel( options );

    view = new MockProjectView();
presenter = new ProjectPresenter(model,view);

 }
public void testModelAndViewInitialization() {
int viewOptions = view.getAvailableOptions().size();

    int modelOptions = model.getAvailableOptions().size();
assertTrue( viewOptions == modelOptions );
}

Okay, so what are we testing here? We’re testing if the presenter has initialized the view. That is, the only way the view will have the same available options is if the presenter does the wiring. However, if you actually look at our test code, the presenter only appears once, and that is in the setup. So for this test to pass, we go into our presenter:

  // presenter constructor
  public ProjectPresenter( IProjectModel model, IProjectView view ) {
     this.model = model;
     this.view = view;
     initializeView();
  }
private void initializeView() {

     view.setAvailableOptions;

  }

Now, notice what has happened. We’ve added methods to the model and view in the test and in the presenter. In this case, we’re using hand mocked objects so the methods we added in the test can be added directly to the mocks (not to the interface). In the case of the presenter we only have access to the interfaces so those two methods (view.setAvailableOptions and model.getAvailableOptions) must be added to the interface. In this way we naturally determine what methods should be in the interfaces.

We implicitly test the presenter by running methods and assertions on the view and model. Ultimately the model and the view are what’s most important. At the same time, during testing we have only mock views and mock models. That’s okay because our purpose is to experientially determine the proper model and view interfaces. Once we have a fairly complete set of tests we can then go off with our interfaces and implement the real view and model. Our model can easily be tested itself and our view is very thin, a passive view in Fowler’s terms. Moreover, we’ll only be implementing what we know we need from testing.

Let’s look at one more test as an example:

 public void testChooseAvailableOption() {
assertTrue( model.getSelectedOptions().size() == 0 );
view.selectOption(  good );
assertTrue( model.getSelectedOptions().size() == 1 );

    assertTrue( view.isAddButtonEnabled() );

 }

Again, our test is describing real functionality. It’s becoming a specification. That is, if you select an option that option should now be selected in the model and the view’s add (A to B) button should remain enabled. To implement this, we’ll need to have the view delegate all events to the presenter.

In the end the presenter is just a bunch of wiring. But that’s okay. Our real goal here isn’t to have a smart presenter. Our real goal is twofold: (1) to have a testable user interface and (2) to separate the model and the view. The presenter is merely a necessary evil for the second. And by going the TDD route, we get goal one by definition.

I’ve put together a working example with source code as an Eclipse plugin. You should be able to import this plugin (File -> Import Plugins and Fragments) into your Ecplise workspace and run the tests. If your drop the plugin directly into your Eclipse plugins directory you’ll find the example available under the “MPV Examples” view.

So I just got out of Greg Stein’s announcement about Google Code Hosting . Someone on IRC mentioned that the site was being OSCON‘d and slashdotted at the same time. Turns out Slashdot already had an article posted about the new project. Surprised at the speed to which the news made it to Slashdot, I commented on the story. A few minutes later, Jamie from Slashdot replied to my comment, mentioning he was in the same room.

As the session ended and I got up to leave, I complemented the guy who had been sitting next to me on his reddit shirt. The conversation turned from reddit to slashdot at which point we realized that he had just replied to my comment on slashdot. We had not only been in the same room, but sitting right next to each other.

Yesterday’s OSCON‘s Executive Briefing could have been subtitled “Challenges to the traditional Open Source Model” or at least that seems to be what Tim wanted everyone to come away with. Apparently it was also the theme of his keynote this morning (which I missed). The chief challenge has been provocatively declared, “open source licenses are obsolete.” What he means is that the current wave of web application or software as a service don’t follow the traditional open source model. For example, Flickr isn’t open source. You can’t download the Flickr source code and even if you did, what good would it do? The code would be optimised for their particular infrastructure and, quite honestly, wouldn’t do much of anyone any real good. So if more and more software follows this model (something yet to be seen), what is the role of open source?

Also, consider this: what does it mean for a web application or service to be open? Which would be more important: Flickr providing source code or Flickr providing an open API? Is open data more important than open source?

Personally, I don’t think open sourcing web apps makes any sense. Open sourcing web app frameworks? Definitely. Providing open APIs and easy access to data? Absolutely. So what we see here then is a broadening of the “open” concept—Open source, open services, open data. And I also don’t see this as a very large jump for the open source community (perhaps for the free software community though). In fact, while it’s not said anywhere explicitly, the concept feels at home with much of open source.

So what’s the face of open source in the future? Tim suggests it may look like:

• Proprietary Application -> Open API (Flickr, Google, Yahoo!, ...)
• Proprietary Application -> Open framework (Basecamp/Ruby, ...)
• Cloneable apps (Ning)

So, are open source licenses obsolete? No, I don’t think they’re obsolete. But at the same time, the open source community needs to broaden to the larger “open” community of data, source, and services.

Updated slides for my OSCON talk are now online . Hope to see you this afternoon!

When I mention that my talk is on the Apache Incubator the most common response I’ve had so far is “What’s that?” I suspect that may have something to do with the fact that I’ve been bumping into python and perl people. If you haven’t noticed, the incubator is mostly full of Java projects, but that’s another subject.

If you haven’t heard of the Apache Incubator, it’s home to projects seeking to enter the Apache Software Foundation. These projects and programmers may be brand new open source efforts or existing projects that are relocating to Apache. To find out more, visit the Incubator site or if you happen to be at OSCON you can attend my talk or visit the Apache booth.

Along with a couple hundred or maybe thousand other geeks, I’ve arrived in Portland for OSCON. If you’re interested in finding me, I’ve posted a calendar of sessions and places I’ll be at. The best way to find me is to attend my talk So, You Want to Build an Open Source Community, Learning from Apache on Tuesday at 1:45 PM.

My experience is that Eclipse’s GEF can be a little intimidating to pick up. The easiest way I’ve found to explain it is something like the following:

We start with a Canvas on which we can draw things—lines, shapes, text, etc. In order to make drawing more convenient we gather up drawing commands into reusable Figures. So now we’re at the state of Eclipse’s Draw2D—we can create 2D drawings on a canvas. But suppose we want to do more than just look at pretty drawings? Suppose we want to manipulate them and the corresponding data they represent? This is where GEF comes in.

GEF adds an Model View Controller (MVC) layer to Draw2D. Each editable figure has its own controller called an EditPart. EditParts are responsible for linking views to models and handling user input. User interaction is handled by a request/response model. GEF captures all user interaction and then forwards these requests to the appropriate edit part. The edit part can in turn delegate these requests to one or more policies which allow for grouping of common response behaviors.

The end result is a lot of objects with specific roles and if one doesn’t understand the design pattern layers in GEF it can be a little confusing. I’ve put together a simple presentation of these ideas that I use to introduce GEF. This is all explained in much more detail on the GEF website and particularly the wiki . Also, the EclipseCon 2005 GEF tutorial is pretty good.

The popular open source network traffic analyzer Ethereal is now Wireshark . The name change came about because Gerald Combs, the founder of the project, changed jobs and his old employer held the Ethereal trademark. NewsForge has the details . In discussing the situation and the solutions, Gerald mentions the need for open source foundations:

I’d like opinions from the community about where we should proceed after that. If you’re comfortable with me holding the trademarks, I’d be proud to do so. If you’d rather see an organization formed to ensure the continued success of the project, I’d be happy about that too. If you have any other (realistic, constructive) suggestions, please send them.

[ BTW, why aren’t there more umbrella organizations for open source like the ASF? In particular, why isn’t there an umbrella organization for open source networking software? ]

I’ve read complaints by some developers that foundations like Apache come with too much “overhead”. However at a certain point that sort of overhead is a necessary evil. And what is that overhead anyway? Mostly it’s nothing more than properly keeping track of contributions and licensing matters. Something responsible projects should be doing anyways. And until there are more ASFs out there, the foundation is open to projects via the incubator . Of course, not every project is going to find a home with the ASF; but if nothing else there is always an open invitation to come and see how we work.

Reddit just brought David Owen’s NYC is the Greenest City in America article to my attention. His argument, briefly, is that NYC is significantly more “green” than tree-lined American suburbs due to economies of scale. One comes to this counter intuitive conclusion upon considering the total environmental cost per capita of the dense NYC model versus urban or suburban sprawl. More efficient living conditions are perhaps just one solution to the problem of sustainability .

I’ve just finished listening to Jared Diamond’s Guns, Germs and Steel and Collapse . I highly recommend both.

The issue of sustainability has increasingly got my attension and Collapse is an excellent study of civilization’s sustainability struggle. My recent MBA studies have had me researching the effects of globalization on inequality rates—that is, are the gaps between the rich and the poor increasing or decreasing and how is globalization affecting this trend. In approaching this problem we assume to prefer to decrease the gap by pulling up the bottom, not by dragging down the top. However, Diamond argues that current first world living conditions are already unsustainable and should we “succeed” in globalizing first world standards we risk an overall collapse. This is not really the bulk of his book, Collapse, but given what I’ve already recently been reading, it’s the thought I walked away with.

I started listening to audio books when I began my MBA program almost a year ago. At the time I was looking to fill my commute to downtown Pittsburgh. However now I get much more listening time during my weekly travel between Pittsburgh and Philadelphia. Thus far I’ve listened to:

• 1776 by David McCullough
• Freakonomics by Levitt and Dubner
• The World Is Flat by Thomas Friedman
• Anasni Boys by Neil Gaiman
• A Short History of Nearly Everything by Bill Bryson
• Irrational Exhuberance by Robert Shiller
• The Tipping Point by Malcolm Gladwell
• Getting Things Done by David Allen
• The Wisdom of Crowds by James Surowiecki
• Guns, Germs, and Steel by Jared Diamond
• Collapse by Jared Diamond

I’ve also been listening to Venture Voice , Chinese Pod , Ruby on Rails Podcast , and Feathercast (Apache’s podcast). I’m particularly interested in listening to more Chinese podcasts, so if anyone has any suggestions, let me know.

I’ve finally moved a lot of my photos from my original gallery to flickr . And yes, most of them are of Maeli right now.

Speaking of photos, during our trip to Seattle and Portland a little over a week ago for Angela’s wedding , we lost our digital camera and camcorder. Jenny and I aren’t sure yet when we might get replacements. So it may be a little while before any new photos actually show up.

Why do most academic written assignments suck? No audience. It’s difficult to compose an article when you have no real audience. My impression is that most students effectively use the professor as their audience—writing what they think he or she wants to read. But honestly, who wants to read these essays? I try to write articles which I wouldn’t mind reading myself someday. I figure if I don’t ever want to read it again, why should I inflict it on my professor.

My advice is to pick an audience for every essay even if the professor may be the only one to actually read the work. For example, I try to write my assignments as if I were going to post them on my blog and some of them I will. Defining an audience makes the process and result of writing a paper significantly better.

Is what my computer said after finding the prices of toasters listed on Froogle.

As you may know, I am a researcher at the Florida Institute for Human and Machine Cognition. For the last year, I’ve been working on a project called PLOW (pdf) for doing Procedure Learning on the Web.

If you call recording macros learning by demonstration, you might call our approach learning by discussion. You don’t just go through the motions, you also say what you’re doing. By “say” I mean speak, talk, vocalize. You tell PLOW what you’re doing, and it listens. From what you say, it’s able to learn what parts of a web page are relevant to the task and why (pdf).

PLOW doesn’t just listen and watch. It can talk too, ask questions, perform actions, and diagram what it’s thinking. Here’s the transcript of my Froogle teaching experience:

Will: Let me show you how to find the cheapest product.

PLOW: All right.

Will: Go to Froogle.
I type froogle.com in the address bar of the browser and hit return.

PLOW: Okay.

Will: Put the product info here.

PLOW: Okay.

I type “rice cooker” into Froogle’s search field.

PLOW: Okay.

Will: Click “Search Froogle”.
I click on the button labeled “Search Froogle”.

PLOW: All right.

Will: Select sort by price.

PLOW: All right.

The page has a “Sort by relevance” popup button. I click on it revealing the options. I select “Sort by price: low to high” by clicking on it.

PLOW: All right.

Will: Here is the list of products.

PLOW: All right.

I option+click on the list until it’s highlighted. (I added this option+click gesture to the browser. It lets you point to specific elements on a page.)

PLOW: Okay.
Plow opens a new window with individual list items delimited. Whatever I do to one item is repeated for the rest.
PLOW: Can you check that I understand the data?

Will: Here is the price.

PLOW: All right.

I select the price for one item by clicking and dragging: normal text selection.

PLOW: All right.
PLOW highlights the price for the rest of the times displaying the value in a new column. PLOW labels the new column with “the buck” which shows you something about how PLOW understands language. If you tell me story, I won’t be able to repeat it word for word to someone else. I’ll remember what happened but not the exact words. PLOW is similar except it often says funny things since it doesn’t know what sounds most natural.

Will: We’re done.

PLOW: Okay.

Will: Let’s practice.

PLOW: What is the product information?
Plow opens a window with a text field where I can make corrections to what it hears before it continues. I type in “toast” and hit return. PLOW goes through the steps it just learned. It starts at froogle.com. It puts “toast” in the search field, clicks the search button, waits for the new page to load, selects “Sort by price: low to high”, waits for that page to load, and finds the list of items. Finally for each item, it remembers the value of “the buck”.
PLOW: I am finished.

I bought my PowerBook last Fall. The first PowerBook I got had all sorts of issues and it was replaced. This second PowerBook appeared much more stable, but I still got occasional system freezes. Not kernel panics (though I’ve had those too) but complete system freeze without any nice error screen or panic log.

Anyway, last night I did more investigating and came across a thread in the Apple Discussions forum. It appears I’m not the only one. The suggested fix is to turn off processor napping though solution did not come from Apple. In fact, Apple appears to be completely ignoring the problem.

So if you have a 15 inch 1.67 MHz PowerBook, check out the discussion form link above.

Edward Morley claims it’s time to end ‘Physics for Poets’ classes in university curriculums. He laments the lower math and science standards we have for college students. I have to agree with him.

The class most feared by fellow students in my MBA program is quantitative analysis. Instructors in our economics and accounting classes go to great pains to lesson the pain of any math that might be inflicted on the students. The take-home message? You don’t need math to manage. Math skills are too demanding, too difficult, to be expected of graduate students.

The folksonomy plugin for PyBlosxom has been giving me trouble lately. If you’ve tried to view individual articles, you may have gotten an error and that would be the reason why. I’m working on it now.

I’m still settling into the new blog. Finally got the PyBlosxom textile parser to work. Anyway, it’s late, but I thought I’d at least jot down some of the list of things I’m hoping to write about soon:

• Releasing rails apps via capistrano on TextDrive
• Automated testing of Eclipse RCP applications (why is it so incredibly difficult to test Eclipse plugins ?) Has anyone actually approached plugin or RCP development via TDD? If so, I’d be interested in hearing about it.
• Using basecamp for keeping notes and group projects for my MBA
• I’ve got several MBA-related articles I’ve been meaning to post
• And of course, much, much more…

My OSCON proposal has been accepted: So, You Want to Build an Open Source Community: Learning from Apache . The hope is to share lessons learned from the Apache Incubator . There are a number of audiences that I can imagine interested in this topic:

• Foundations and groups looking to create their own “incubator”
• Project teams seeking to enter Apache’s incubator
• Project teams seeking to simply grow or strengthen their existing community
• Anyone interested in how open source communities work

An important philosophical distinction of the Apache Software Foundation is the emphasis of community over code. For ASF projects, a broad and active developer and user community is a critical measure of health and success. Ted Husted recently wrote some great entries on this subject. It’s something I’m hoping to expand on further at OSCON.

As I’m still putting the talk together, feel free to send me any suggestions or questions, especially if you’ll be attending the conference too.

Everyone's still grumbling about the price of Sony's PS3. And certainly $499 or $599 is not pocket change. But it's interesting when you start comparing it to other electronic gadgets. For example, I recently purchased a Treo 650 for my father. It was $300 used. The new Treo 700p will run $500 even after signing up for a two year cellular plan. A 60GB iPod will put you back $399. PCs with anywhere near the gaming ability of an XBox 360 or PS3 will be well more than $599. And a first generation blu-ray player could easily be almost twice the price of a PS3. Yet despite all that, the PS3 will still feel expensive.

I just had someone ask me how I keep up to date with Eclipse development. How do you know about such-and-such API or changes to this-or-that? It's a good question and personally I don't feel like I'm completely in tune with the happenings of the Eclipse community, but there are some resources I use to stay abreast.

• I subscribe to the Eclipse News RSS feed. This gives me very broad news about Eclipse events. Usually nothing too surprising here, but I'd hate to miss something so well broadcast.
• I also subscribe to a the Eclipse Planet newsfeed. This allows me to follow several Eclipse-related blogs.
• I subscribe to several of the developer mailing lists. Specifically, I subscribe to eclipse-dev and equinox-dev. Mailing lists are reserved for developer discussion only, so I only listen on these lists.
• Finally, I subscribe to several Eclipse newsgroups such as the GEF, SWT, RCP, and Equinox groups. I can't keep up with the volume of messages, but I skim for interesting topics and whenever I'm trying to figure something out I search the newsgroups first. The newsgroups are an appropriate forum for users (such as myself) to ask questions.

These sort of steps are appropriate for keeping up to date with any particular open source technology. The real news always happens on a mailing list, newsgroup, or sometimes an IRC channel. That's the place you want to lurk if you want to have a heads up on what's happening.

Welcome!

So I've finally got this new website up and running (in theory). In a week or so, I'll put the redirects in place so old jadetower.org links will find their way here. If you notice any broken links, please leave a comment or send an email.

This new site is using PyBlosxom and is hosted at TextDrive. Over the next month or so, all the sites I maintain will be moved to TextDrive. William and I also have some new plans for JadeTower, which is why we're moving content off of that domain and to this one.

Overall the move to pyblosxom wasn't too painful. I was able to easily modify the MT conversion script to include comments and create URLs that can be easily mapped from the old domain. Originally I was looking at Hobix, a Ruby weblog framework from the mind of Why The Lucky Stiff, but it's still very rough around the edges. I also tried out Text Pattern which is really impressive but missing one important feature -- easy export of data.

In the end, I wanted something simpler. I wanted something that would allow me to author entries in my favorite text editor and would store them in an open format. No database and as little code running the site as possible. Which is kinda funny when you think about it because a lot of people wouldn't consider that simpler. Many would find editing flat files in a text editor and then uploading them to a server via subversion complex and barbaric, not simple and advanced.

"Simple" all depends on the audience. For example, to a chef, the simplest solution, the most basic, might be one involving lots of raw, fresh ingredients. Nothing between the cook and an excellent meal. However, to a college student, the simplest solution is something processed, packaged, and microwavable. The chef scenario requires only basic components in their most natural form. The student scenario requires factories and microwaves. Complexity and simplicity exist in both, but reside in different locations.

The same is true of software. To me, a developer, a text editor, subversion, and a simple CGI script is software bliss. It's about as basic and un-complicated as it gets. However this same solution would not be acceptable for many other computer users, even relatively sophisticated ones. I believe this is an important factor to consider when developing less software. Less for whom? Less for the developers or less for the users?