andthennothing.net

I just returned from a two-day developers’ conference called Øredev where I had a great time.

The keynote by Eric Evans about Domain-Driven Design, or DDD for the abbreviationists, was great! He’s a great speaker and presented an interesting topic. I’ve heard about DDD before, but I don’t think I grokked it entirely back then. However, listening to the guy who came up with the concept is often a sure way to understand what it’s all about. I attended a longer workshop today as well which provided a deeper understanding. DDD is, to me, about creating and working with a model of the domain. The model is at the heart of the development and should reflect the domain as well as the software design. Another important aspect is the usage of a ubiquitous language, that the same language is used by the domain experts, the developers, and the code.

The critical complexity of most software projects is in understanding the business domain itself.
Does this technology help me focus on the domain?
Does it distract me?

Erik Dörnenburg talked about Dependency Injection and Inversion of Control and it was a good overview of the subject. And it’s always refreshing to see an IDE during a presentation. Erik used the Spring framework, and since I attended Rod Johnson’s presentation/workshop half a year ago I learned few new things, but it was interesting.

Peter Tallungs talked about a missing architect role. Where architecture in house building, and seemingly in the software industry in the beginning, is/was about user needs, requirements, and user interface it has become an engineering role in the software industry. Perhaps we need to have a role that more closely corresponds to an architect than the current “software architect”.

Rickard Öberg’s talk about AOP was the same as the one he gave at Expo-C. Fortuately, he’s an entertaining and interesting to listen to so I didn’t mind. One thing I think he stressed more this time was defining pointcuts using annotations, which seemed like the way of defining pointcuts. I remember liking using annotations the most the last time, but I don’t remember it presented as the way.

The other workshop (in addition to the DDD workshop) I attended was the XP Game. It’s a game I’ve heard mentioned quite many times during the last years in various agile settings. It was a great fun and good way to get a taste of the planning process of XP.

All in all, it was a great conference, with great topics, speakers and organisation. Hopefully I’m able to return next year (it’s planned to be an annual event).

After two days in Copenhagen, at reboot7, I feel booted (as in the reboot is done, not as in being kicked by a boot). Extremly interesting conference, indeed.

<random-stuff>It was very well managed and all the practical stuff ran smoothly. All presentations were very well performed, and most were really interesting as well. Laptops were popular, Macs in majority. I think it was great to be able to take notes, google for more info about what was said on stage, check out the IRC (which was hilarious at times), reading live blogging about the conference (e.g. Erik’s), and do some random stuff if the session was boring (but that rarely happened). It seems to me that the Mac popularity has influenced the presentations since there were no standard PowerPoint slides with a title and five bullet points. Great fun to meet some folks from the Swedish blogosphere like Peter, Erik, and Henrik. </random-stuff>

flickr is a good way to replay the event.

I will blog about some of the sessions later on when I’ve digested it somewhat more.

Exciting stuff!

Last week I attended Expo-C, this week it’s reboot7 in Copenhagen.

reboot is the european meetup for the practical visionaries who are building tomorrow one little step at a time, using new models for creation and organizationin—in a world where the only entry barrier is passion.
reboot is two days in june filled with inspiration, perspective, good conversations and interesting people.

I’m not an avid conference goer, and this is the first one with a blogging/internet touch so it’ll be interesting.

Things have been a bit hectic the past weeks so I haven’t had the time to really get into the mood before, but Nicole Simon podcast has thankfully taking care of that. Now I’m really looking forward to go there. Both days are packed with sessions and interesting topics. There are many well-known speakers, from the States, from all over Europe, and even one from Sweden: Peter Lindberg of Tesugen (who is the one I blame as the main reason for this blog to exist).

There is a lot of practical stuff I need to figure out. I’ll be sleeping in Malmö so I’ll be going back and forth over the night, hope that works out. And I don’t really know how to get to the venue, but there are some information on the reboot site, so that shouldn’t be too much of a problem.

Just a little more than a day left…

This week I attended Expo-C, “a 3-day Software Architecture Conference” of which I went on two days. Software architecture is a dangerous word since it might imply so many things, from “oh so boring” to “a hoot” on the interest scale. Fortunately, this conference managed to place itself closer to “a hoot” than to “oh so boring”.

Rickard Öberg’s presentation of Aspect oriented programming, AOP, was truly interesting. I can only find one reference to AOP back in 2002 on this blog, so I think it’s safe to say that this was my basic opinion of AOP before the conference: nice ideas, but complex and will it work in larger projects? I have looked at AOP once in a while but never fully grokked it, and never used it for anything larger than testing that it works. And languages like Ruby and Python have made more impression on me.

Rickard’s presentation opened up my eyes for that AOP is really interesting. But then again, anyone who put this quote on the fourth slide has my full attention: “Inheritence sucks as a means of reuse”. That is a statement I can wholeheartedly agree with. The standard AOP example, the trace example, is nice and that kind of AOP (advice in AOP-lingo) is probably very useful (transaction management, caching, security and so forth are other similar functionality). But introductions, that is methods and data introduced to an object or class, is what really got me thinking. Rickard’s product, a slick CMS called SiteVision, used AOP (a home-brewn version) religiously, and it seemed to be a successful approach.

Another thing that Rickard stressed was tool support, and I do agree that tool support is crucial for the success of AOP. Back in 2002 AJDT was new, but now it seems to be a mature product, and it have some nice visualization features (I’ve just tried to create a simple aspect so far, due to lack of time).

The other main attraction of the conference for me was Rod Johnson who had one presentation during Tuesday, and a full-day tutorial of Spring during Wednesday. Web development frameworks is something that has interested me for quite a while, for some peculiar reason. I have only done two web projects, an e-learning system in PHP and a community in Java, and those were done during my university studies. Nowadays, my main interest, which I share with many in the blogosphere (at least the parts I follow), is in Ruby on Rails.

The conference was quite directed towards mainly Java/J2EE and somewhat towards .NET. I’ve been out of the Javaverse for a while so it was due time to get reintroduced. J2EE seems quite overcomplex and painful so I understand where the need for lightweight frameworks, such as Spring, spring from (bad pun intended). There is a lot of great ideas in Spring and it put a lot of emphasis on testability, to be non-invasive and to promote good design. The main tool to achieve this is, from my viewpoint, IoC/DI.

Inversion of Control (IoC), or Hollywood Principle (“Don’t call us we’ll call you”), is a pattern to loosen the coupling in a system. Instead of objects creating all the objects it needs, setters and constructor arguments are used to give an object the objects it needs. And (don’t know if it’s required or just recommended by the pattern) interfaces are used in preference of classes in order to further reduce the coupling. I think this is great in terms of testability: all external dependencies of an object is possible to configure/mock so you can test objects in isolation. Another great gain is that highly coupled designs become evident—classes with many external dependencies are easy to hide if the only way to notice the dependencies is to look at the source.

Dependency Injection (DI) is a technique to manage all the dependencies that IoC makes apparent. E.g. Spring figures out, aided by XML configuration and introspection, which objects that needs to be created for a certian class, create those objects and uses constructors and setters in order to inject the dependencies. Pretty neat to see Rod’s demonstrations of Spring and IoC/DI.

Singelton begone!

Spring also has its own support for AOP (working in a similar way as Rickard’s using dynamic proxies), and Rod pointed out that it’s a good idea to unit test classes without aspects since you want to test classes in isolation. Let’s say you have a security aspect, then it probably needs some setup in order to run, and that seems like a lot of work for a unit test and many thing that might go wrong and interfere with the tests, it’s more of integration test issue. That’s no problem in Spring since objects are just POJOs (plain old java objects), aspects are added by the Spring container so when you don’t use the Spring container you have no aspects. But how do you do that in e.g. AspectJ where the aspects become part of the bytecode? There is an infant project called aUnit, but that seems to just unit test aspects themselves in isolation. Or do you just use a different, non-AOP aware, compiler? Does anyone out there have any suggestions?

There were also a lot of other things in Spring that were very appealing. More metadata and code than Ruby on Rails, but if I’ll do anything server related in Java, I will certainly look at Spring.

One thing that I thought of while listening to all the interesting stuff about AOP, IoC/DI was how this would translate into the Ruby/Python world. The concepts apply even there, but the programming languages are more hackable than Java, thus it ought to be eaiser to achieve. There are probably many different approaches in the Ruby/Python world that I will have to look into.

Great conference! Would gladly come back if they manage to get as good, or even better, speakers!