How I learned about customer value

Confidence by h.koppdelaney, on Flickr
Confidence by h.koppdelaney, on Flickr

The article do users change their settings remembered me about a program I wrote as a student. I created a tool to categorize my expenses similar like Yunoo a.k.a. Afas Personal. This was however a local application. Why the heck should you share your finances on the internet? But let me go back to my memory. At the time I started building the application I did a little bit of research if there was this kind of software available. Sure there was, I just thought it didn’t look nice so I build it myself using Swing (I do know better now ;-)). I was just a little bit overconfident and suffered from the NIH syndrome.

Basically the application enabled me to download a file with all my transactions, load it to my program and categorize my expenses. I even created some rule engine like thing to categorize recurring transactions automatically. All these transaction are then shown in a JTable structure. The program also included budgeting, reports, some graphs, etc.

Back then I didn’t like how the information was shown in the transaction overview. There was too much information shown and it was shown in the same order as was used by the import file. So I made this table structure configurable. The configuration made it possible to hide columns and rearrange them. Also I created some ways to edit the configuration and store it into an XML file (it was the common fashion back then). This change resulted in al lot of work. I needed to create file handling & XML parsing code. But the main issue was that I used the UI as the (view) model.

Every transaction had an id which was shown in a column. It was quite easy to create the logic to find the transactions id as long as the id column was shown. If it wasn’t shown however it was not possible to match a row in the table to any transaction stored in the database. This was especially difficult because every other column may or may not be visible. So I created a view model that made is possible to find the transaction corresponding to the data shown in the UI. Because I wasn’t used to writing automated test (as everyone knows a real programmer doesn’t test), it took quite a while to create the model, hook it up to the interface and make it configurable. I think I spent at least some 40-60 hours on this feature. When I was done I was pretty proud as a developer that I was able to create this feature.

As the only customer of the product I wasn’t happy though. Yes the new feature improved my application a bit. But it didn’t help to support the main goal of the application: getting more insight in my expenses. The day I realized this I was pretty disappointed. If I look back now I learned a lot about customer value by making this (classic) mistake. This is also why I keep emphasizing customer value in the Agile/Scrum team I’m part of. By the way I learned a lot more by building this toy project. I still have all the sources of the program & I use it from time to time to experiment with new languages (I have some Scala classes that mimic the original functionality in Java), new practices and new IDE’s. As a software developer I think every other developer should have toy projects to experiment and improve his/her skills and become a craftsman.

Now I’m using an off-the-shelf product to categorize my expenses and make budgets. Sometimes I still have that nagging feeling that I could make a better program than the one I bought. I learned however that if I’m going to build this thing I need to spend a lot of time to have the same capabilities I like in that product and I think I can spend my precious time more effective.

Review: The pragmatic programmer

The Pragmatic programmer
The Pragmatic programmer

Finally I had time to read the pragmatic programmer: From journeyman to master. I wish I prioritized differently. The book is written by @PragmaticAndy & @pragdave. This is the second book written by Andy Hunt I’ve read. Read my blog posts about that book. The pragmatic programmer is ranked 2nd in “Top Ten Most Influential Programming Books of All Time”. I don’t know if that is true but I think every software developer should read this book.

First of all the book is easy to read. It sometimes reads like a novel. In the book many topics are covered. From using a VCS via architectural principles to practical advice how to handle problem solving. Throughout the book you find 70 tips. These tips are also collected in a quick reference guide in the back of the book. Some of the tips:

3. Provide options, Don’t make lame excuses
Instead of excuses, provide options. Don’t say it can’t be done; explain what can be done.

8. Invest regularly in your knowledge portfolio
Make learning a habit.

20. Keep your knowledge in plain text
Plain text won’t become obsolte. It helps leverage your work and simplifies debugging and testing.

55. Don’t think outside the box – Find the box
When faced with an impossible problem, identify the real constraints. Ask yourself: “Does it have to be done this way? Does it have to be done at all?”

In the book there are many analogies used. These make the advice easier to remember. I won’t forget broken windows theory and Cooking stone soup. The book is pretty old. It has been published in 1999, but for me it is still accurate. Yes there are some things when you notice that the book is that old. CORBA is named and EJB is marked as a good example for configuration over integration. As a developer working in the Java world using Spring, Hibernate and all the other frameworks. I agree that configuration has his place. However many times I’ve been in configuration hell. For me this mantra has evolved to be convention over configuration, mostly popularized by Ruby on Rails.

Overall the book overall covers many practices and tips that are still useful. Some of them you know already, some might be new. I gained the most insight in the plain text chapter. The combination of plain text with version control is fantastic. I would strongly recommend reading this book.

Het nationale park de Hoge Veluwe

Zonnestralen in het nationale park de Hoge Veluwe
Zonnestralen in het nationale park de Hoge Veluwe

Vanmorgen vroeg op. Misschien wel de laatste mooi weer dag van het jaar. Lekker wandelen en fietsen in het nationale park de Hoge Veluwe. Fantastisch dat er ook nog mist is. Dat kan een fantastische foto worden met laagjes als in een kijkdoos. Helaas is mijn compositie niet zo gelukt.

Laagjes in het nationale park de Hoge Veluwe
Laagjes in het nationale park de Hoge Veluwe

Heerlijk wandelen over eindeloze wegen.

Eindeloze weg in het nationale park de Hoge Veluwe
Eindeloze weg in het nationale park de Hoge Veluwe

Gelukkig ook nog wat wilde dieren op de foto kunnen zetten ;-).

Wild in het nationale park de Hoge Veluwe
Wild in het nationale park de Hoge Veluwe

Developer certificates are similar to triple A ratings

 

Coin Operated by xcode, on Flickr

Maybe it is a far-fetched comparison but to me developer certificates (e.g. the Sun Java Certified Programmer) are quite similar to the triple A ratings issued by companies like S&P. Let me try to explain why I think they are similar.

Basically a rating or certification agency does some quality checks for you. Banks are outsourcing the risk assessment of certain financial products to the rating agencies. I think banks should always check the risks of the product they are buying themselves. Software companies use the developer certificates to outsource the quality checking of a (potential) new employee. And if I was the person who was hiring people I wouldn’t even think about outsourcing this pre-employment check.

By outsourcing these checks we explicitly trust trust the companies providing the service. Initially this makes sense, especially when you are an HR person who doesn’t know the details about the job a potential employee has to do. The problem however is that the certification agency benefits most if they check as many people as possible with the least possible effort. Also a developer pays for his certification resulting in the situation that the developer is the main customer of the certificate authority. I don’t think we should trust the agencies blindly. This is of course similar to the situation of the rating agencies (like discussed after the USA downgrade by S&P).

So are certificates useful? I agree with Martin Fowler’s article: CertificationCompetenceCorrelation. Bottom line: He hasn’t found a correlation between certification and competence, but it may have a economic value for the developer.

 

Working with ATG

ATG by delete08, on Flickr
ATG by delete08, on Flickr

Now I’m working with ATG for a couple of months I want to share my thoughts on the platform so far. Let me first introduce ATG. ATG is an ecommerce platform. It promises to deliver out of the box functionality to create complex ecommerce websites. That’s all I want to say regarding the bullshit bingo. Today I’ll discus ATG as seen by a developer. There are many other perspectives to see if the software suits your needs.

In April this year I attended an ATG course containing three modules: “Foundations of ATG”, “Extending the ATG platform” and “ATG Personalization and scenario development”. As you can guess these are modules targeting a developer. There are lots of other courses for business users etc. Just as a reminder before working on ATG I used to be working on all kinds of JEE applications. Furthermore I developed some (test) projects in Ruby (on Rails) and used Google app engine to see the advantages of a cloud platform.

At first it was a shock to work with JSP files again. I was used to JSF / ZK and other component based GUI toolkits. JSP files seemed so old to me on certain moments. As a fact the whole platform feels a little bit out-dated. As an object-relational-mapper ATG basically uses a special kind of HashMap to represent the entities. If you are used to Hibernate/JPA or active record like technologies accessing entities properties with Strings feels not ideal. Maybe I just need to get used to it. The repositories are mapped to the actual database through XML.


ATG uses property files for dependency injection. Unlike Spring these are not in a XML format but just key-value pairs. This makes the property files much more compact. One disadvantage is that (just like Spring/hibernate etc.) it can result in a config hell. I’m not sure anymore if configuration over code is a good mantra. But I’ll save that discussion for my review of the pragprog book.

ATG uses Servlet beans (a.k.a. droplets) to couple the JSP files to the other Java Components. Servlet beans normal servlets but there is an ATG tag handler that lets you access them directly in your JSP.

Let me give an example of using a servlet bean:

<dsp:droplet name="dropletName">
    <dsp:param name="someInputParameter" value="${param}"/>
    <dsp:oparam name="someOutputname">
        <p> some ${someOutput}  </p>
    </dsp:oparam>
</dsp:droplet>

A java class handling this droplet extends some base class containing a service method and may look like:

...
public class SomeServletbean extends DynamoServlet {

private SomeComponentType someComponent;

public void service(DynamoHttpServletRequest pRequest
        , DynamoHttpServletResponse pResponse) throws
        IOException, ServletException {
  String input = pRequest.getParameter("someInputParameter")
  String output =  someComponent.process(input);
  pRequest.setParameter("someOutput", output);
  pRequest.serviceLocalParameter(someOutputname, pRequest, pResponse);
}

getter/setter someComponent
...
}

Furthermore we need a config file (named dropletName.properties) to map the servlet bean to a class. This config file is also used for dependency injection (someComponent).

$class=com.mycompany.SomeServletbean
$scope=global
someComponent=/path/to/configfile/of/component

ATG provides several out of the box servlet beans and components for commonly used operations.  For most (java) web developers this pattern is pretty familiar. One possible problem of these droplets is that some people may link up many of them. This results in pretty long JSP files with a lot of logic contained in them. But as Uncle Ben told us:

With great power comes great responsibility

So how do I feel about ATG? It is just another java development platform. It has its quirks and feels outdated sometimes, but any platform has its issues. ATG is just an implementation of ideas also used in JEE.

pro:
– Default functionality available

cons:
– Tends to lead to lots of logic in JSP files.
– Repositories are Hashmaps