Monthly Archives: September 2007

JAOO 2007 – Wednesday

The third and last day at the JAOO conference was the best in regards of the sessions I attended. My day session schedule looked like this:

I have written an abstract of the session “Applying Craftsmanship” by Pete McBreen in a separate blog post, because it deserved it. It made me think (which is a good thing 🙂 ). Read it here.

JAOO 2007 conference summary
I enjoyed the JAOO conference, but was a bit disappointed with the technical level. Again, maybe my expectations were too high? But then again, I will consider coming back next year. That has absolutely nothing to do with the fact that I won an Apple iPod at an IBM contest. 🙂

Below is a picture of the price I won in the IBM contest.

My winnings

JAOO session “Applying Craftsmanship” abstract

The session “Applying Craftsmanship” at the JAOO conference by Pete McBreen was by no means technical but made me think. The stuff he talked about is, in my opinion, common sense. Below is an abstract of what I got out of the session. I wanted to share it with you and wrote it down so that I don’t forget about it in 6 months time.

  • Currently the norm for gaining the title as senior developer is only 5 years of experience. Does that make sense? Can you really gain enough knowledge in such a short time? What is the next step in the career path for technical for a developer? Architect or project manager? Not all developers make good architects, as the skill required differs. Almost no developers make good project managers. What is often seen is the organization ends up with a lousy project manager and loosing their prime developer.
  • Why have two teams – one to develop the solution and another to maintain it. It does not make any sense, as the initial developers are the best source of knowledge of implementation details. Give the initial developer’s incentives to build the best possible solution by having them maintain the code base afterwards.
  • Developers fresh out of college or university should learn from the more experienced developers (senior developers?). The best way to learn is by looking at others code or paring up with a more experienced developer. Pete McBreen favored having the newbies help maintain existing code. That makes sense in my ears, as they then get exposed to others (hopefully) high quality code, while paring up with the experienced developers.
  • Another issue he addressed was the current trend of discarding existing code and redeveloping the same functionality over and over again. He made a point out of continuously improving the software quality, so the need to discard the existing code would be pointless. The goal is not solely to continuously refactor, but to improve the user experience – functionality wise.
  • This ties very well to the last point of shifting the developers’ focus to the system functionality that improves the users’ experience. The users are paying for our salaries so of cause we should focus on their needs. This requires that developers talk to users and understand their needs, because developers are not domain experts and do not have any clue of the users needs.

Pete McBreen has written a book about the subject called “Software Craftsmanship: The New Imperative“. I haven’t read it, so I can’t tell you if it is any good. Maybe I should read it…

JAOO 2007 – Tuesday

The day at JAOO was better than yesterday, but still not great. Maybe my expectations are too high?
Today’s JAOO conference of the honorable mentionable:

  • “Painless Persistence with Castle ActiveRecord” by Oren Eini and Hamilton Verissimo – which was a tutorial of Castle ActiveRecord. The session was fairly good – I learned some new stuff but knew most of it in advance. I like the idear of minimizing the complexity of data access logic, but I do not fancy the solution where the domain model objects are bound by attributes. I prefer the XML based solution found in for example nHibernate. It is a lot more tedious work, but the solution benefits of separation of concerns.
  • “C# 3.0 under the hood” by Mads Torgersen – this session was a good recap of something I read a while ago. I can’t recall the source, sorry. The session wasn’t as much under the hood as the title states, but still Mads delivered a compelling walkthrough of the construct of LINQ (Language Integrated Queries).
  • “Using LINQ to SQL to Access Relational Data” by Luca Bolognese – I was delighted to see that Microsoft has taken concepts from nHibernate and adopted them as their own. There are many similarities between nHibernate and LINQ to SQL, but I need to dig further into the subject to see if I should make the switch from nHibernate to full blown LINQ, with all it entitles. Alternatively I could just use the LINQ for nHibernate when it is released in version 1 in 3-6 months.

My last day at JAOO is tomorrow. Let us see what tomorrow brings. 🙂

JAOO 2007 – Monday

JAOO 2007 entrance

The keynote by Robert C. Martin “Craftsmanship and Ethics” was all about agile processes and development. You couldn’t really ague the test are not good and the developers should have the best tools available. It was one of those talks where everybody nods and goes their separate ways and continues doing what they have always done. Good talk though.

Afterwards I went to a session by Pramod Sadalage where he talked about evolutionary database design with database refactoring. Pramod Sadalage is a co-author of the Martin Fowler series Database Refactoring book which I have on my to-read-list-but-have-not-have-found-the-time.
He tragically failed to deliver a point about database refactoring until then end of the session where most had lost interest. He kept on talking about continues integration and ANT script – this is all fine, but I expected some thoughts and ideas of how to do database refactoring without loosing business value and precious development time. Give me some pointers, tools or patterns!
I certainly need to reevaluate if the database refactoring book should stay on my list.

After lunch I went to a session about the functional programming language Erlang by the inventor Joe Armstrong. He is a great speaker and was able to keep most attendee’s at the tip of their toes, due to implicit knowledge of current hardware architectures in the talk. He confidently delivered his views of how concurrent development should be done – not the Java, C++ or C# way, but as a simple construct of the programming language. Concurrency in Erlang is based on message parsing instead of share memory.

The rest of the day failed miserably for me. None of the talk I went to was enlightening, made me think or inspired new ideas. I went to “Testing Database Access Code Programmatically” by Roy Osherove, “Information cards and .Net – Cardspace” by René Løhde and “An Introduction to Spring.Net” by Mark Pollack.
Most (in truth all) of my colleagues was better at choosing sessions and they especially talk positively about the session “Beautiful Debugging” by Andreas Zeller.

The rest of the day I served Miracle beer from our very own Miracle Brewery at the JAOO conference party. Apparently developers like Miracle beer, because all 400 liters were consumed.

I am looking forward to tomorrow and hope that I am better at choosing the right/high-class sessions.

Geek Train to JAOO

I am on my way to the JAOO conference in Aarhus, Denmark with a colleague. We booked a late train and ended up on a geek train!
Addicted as we are, we logged on the Internet via our mobil phones and noticed that we were not the only ones with Bluetooth enabled laptops/mobil phones!
This was what we say.

Bluetooth

That is pretty amazing as Bluetooth is a personal network and the range is about 10 meters.