Archive for September, 2007|Monthly archive page

JAOO 2007, Day 5

The last day was a tutorial from Eric Evans who explained a lot of his ideas behind Domain Driven Design and showed some very interesting tutorial because allthough he is a very slow speaker, what he says is very precise and pointed. DDD can bridge the gap between requirements or stories to well though tasks and design models. Successful modeling needs extensive interaction between development and domain expert. His talk, the tutorial and the book, which I have read a year ago, make now more sense to me because the patterns discussed were not the whole thing, at least as important is to understand the domain in a common language, an ubiquities language for all participants.
We tried to catch the right bus, and after a long drive we were at the airport. The first thing was that we were not able to check our baggage through to Vienna because of security reasons. This worked on our arrival, so why not now!? Second interesting thing was, our flight had one our delay, so we missed the second one to Vienna. So now I’m sitting in the airport and write this blog … waiting for the first flight at 06:55.
PreperationsMaster at workNot our flight, damned!OpenSpace extended with Eric Evans on Aarhus airportWaiting for help …Finally CopenhagnNight on airport

UPDATE: Finally we are back in Vienna!
Our planeFinally back in Vienna!

JAOO 2007, Day 4

Today I participated in Robert C. Martin‘s Class for Test Driven Development. Required was at least a notebook this was easy to satisfy, my Sony Vaio TZ has it’s first long running task to do. Robert C. Martin is one of the most active people who advocate TDD and he is a great presenter. The content of the course is relatively simple: he provides some FITnesse test cases and the first JUnit test cases including some unimplemented base classes for a simple text adventure game (the thing the older one of us remember playing on the first IBM PCs). The first challenge of most people was to get it up and running on Eclipse because he only provided project files for IntelliJ. After this, he explains some of the basic practices of TDD and he and the audience begane to program. Everyone was very disciplined, so writing a JUnit test, implement the functionality and run also the FITnesse tests was no problem at all. So everyone implemented the stories bit for bit, re-factored the code after the tests successfully run. After 4 hours of the tutorial duration everyone has a basic game running, navigating correctly in a arbitrary maze and the code definitely looks better than normally. FITnesse is sometimes a bit cumbersome, but it works very well and is based on a really simple interface language. The main disadvantage is that someone has to write the business case use cases and this should definitely not be the developer. So for using FITnesse, you have to convince some tester, manager or QA guy to write down what he wants as acceptance test.
Some other tips:

  • If you have private functions you want to test, move them to a class there they can be public. Mostly they are in the wrong place
  • Clean up and re-factor your code every time a new test runs successfully
  • Use comments in code sparingly because it smells of bad programming if the code is not clear to follow
  • Keep functions and tests as small as possible
  • Try to find useful names for functions and tests
  • If you work with modern IDEs, learn their shortcuts for using the advanced refactoring capabilities.
  • Design your project first, but be aware that tests change the code and the structure of the intended design because they actively use the functionality!
  • Sometimes break the rules if you must, but be aware of them and make it no habit

cimg0517.JPGcimg0519.JPGcimg0520.JPG

JAOO 2007, Day 3

The first talk was held by Wayne Fenton from eBay who told how the tackle the chellange of skaling eBay. What was interesting is, that the have to deploy their features constantly, at least every 2 weeks. The deployments have not only to be deployable but also to be undeployable without hassle! Their critical data is hosted by Oracle, not so critical things are based on MySQL. The split their data according to the functionality of the application, use Sun Solaris in a virtualization environment and Tibco as Event Bus for monitoring. LDAP is used for configuration and deployment. Very interesting talk.
Robert S. Hanmer talks about fault tolerance and emphasis how important the distinction between error, failure and mitigation of the failure is. He currently writes on a book about this. Because he comes from a Telco and Joe Amstrong (Erlang) was also in the audience there was a lifely discussion what the write granularity for mitigation is (the process itself according to Joe). The have a product up and running with the reliability of 9 nines! 99,9999999 availability, and they can proof it (it is a Ericcson Telco switch).
Kevlin Henney talks about the different nations of performance and basically shows that it is a feature which is cross cutting through the whole system and should influence design, architecture and implementation but depends on the context of the application. Great presentation as ever.
Rebecca Wirfs-Brock talks about her experience as long time architecture reviewer and it was interesting to hear that the best thing you can do is to behave like Columbo: ask questions which seems to be silly and try to get contact to all people that really matter there.
The panel afterwards includes besides Kevlin, Wayne, Rebecca, Klaus Marquadt also part time Joseph Yoder and Markus Völter (he wants a architecture language of some kind to express the intentions) and some others of the audience and goes very lively about the theme if architecture really matters. The important point is, if architects can not implement their models, at least a prototype, architecture has no value for itself. Architecture matters but it is a intrinsic feature and the metaphor that it is something which is inhibited by the developers and kept clean (given by Rebecca) is a good explanation why you should care. Interesting was the question of documentation because one out of the audience brought up the question that the best thing maybe is to make a movie from the architecture representation, not longer as 15 minutes and store the movie. The quoted Jeff Sutherland for this idea and practices it in his company. Fascinating idea I have to admit.

The final conference panel was held by Martin Fowler and includes Eric Meijer, Eric Evans, Eric Dörnenburg and Diana Larsen. The basic question was what was the most interesting thing for all of them, but the discussion was very dynamic including the audience about the question why JavaScript sucks and why DSLs, if context specific, are very useful. Diana was sadly a bit misplaced.

eBay is integratingSomeone was to late for track hostingNo failures at this talkHenley fascinating as everTelling war stories about architecture reviewPanel with the right architectureFinally, the evil empire and the rebels

JAOO 2007, Day 2

Day two starts with a keynote from Eric Meijer where he talks a bit what are his expectations of LINQ: relieve the developer from complicated tasks such as data access and concurrent algorithms. Was a nice talk but nothing new (but he showed the demo of 3D animation in DHTML).
The next talk from Jean Bezivin about model transformation. Was a bit boring in the first half because of the explanation how the OMG MOF meta-metamodel works. The second half was about the Eclipse Model Discovery project which was definitely more interesting.
Eric Evans talked about Strategic Design after lunch. His conclusion was that you have to find out the core model of the domain and focus your whole work primarily on this part. You should get rid of the supporting or generic domain models by buying COTS solutions our outsource the development. To find the core model is context depended and it is mostly not known by the management or the business. You as architect are responsible to work it out.
Klaus Marquardt was on the stage a second time and talks who you can identify complexity inside projects, what you can do no to get more as necessary and how bad are most metrics for measurement (especially senseless KPIs).
Joseph Yoder presents how he models most of his complex domain models with the Adaptive Object Model Pattern. This was especially interesting because I used the pattern in the no so far past and currently for some highly flexible models.
At last we visited the talk of Jimmy Nilson where he shows how he intends currently to use LINQ for Domain Driven Design. Nothing new here but the guy from Microsoft who developed the SQL implementation has told us something about the design decisions and trade offs of his team.
Eric filling the stageSlow progress in Model to Model transformationsEric Evans at giving good adviceKlaus Marquadt speaking slowly and 40 pages to goJoseph Yoder explaining his favorite patternsLINQ and DDD

JAOO 2007, Day 1

The JAOO 2007 conference days started and the first key note was held by Robert C. Martin about the craft and profession of developing software. He emphasis that software developers have commit themselves to the ethics of avoiding bad code. Complete agreement with that but I think the reality is that most developers produce absolutely bad code and there is no awareness of ethics as is for most people their whole life.
The first interesting talk was given by Charles Simonyi who presents the first real world application of his Intentional Software Workbench. This was the first time I’ve seen a workable peace of his pet project and I’ve to say I by it. You can build a DSL including the domain specific notation, in this case a Excel-like interface, and let generate the supporting code. Looks promising.
The next talk was given by Klaus Marquardt who is project manager by the medical device company Dräger where they build with agile practices a complete, clinical certified complex system. His final point was getting the right people into the project an emphasis a global view of the project for all developers and stackholders. Interestingly, they made the first retrospective 2 years after the project has finished…
After this, Lex Spoon gives a talk about Scala and he demonstrated in a very short example how Scala manage it to combine functional and object oriented features. Scala is really the first language which is capable to implement new language and type class features purly with libraries. Because it is based on Java, there is no problem to use it in real projects.
Gilad Bracha presented a way how to build a executable grammer with the help of Smalltalk and allthough this was a bit esoteric, the reason why this can be interesting is, that you can extend the grammar with the power of Smalltalk (via inheritance and mixins) without the need to rebuild the parser/lexer combination. There is a parser combinator in Scala, Sparsec, so I will take an additional look at it.
The last talk was from Andreas Zeller talked about Beautiful Debugging, the same topic as he has written in the book Beautiful Code. Interestingly is his current reasearch which shows that neither experience nor language features or unit tests can effectively prevent bugs.
The end key note was Charles Simoniy’s presentation of his flight to the IIS and this was really fascinating. I think every one in the room envies him for this!
Converence Party was not so much a party this year, somehow it was not much energy left, so I decided to leave early and write to the blog (at least we met Roy Osherove, ISerialize, who was disappointed because of the evening program …)

Conference registrationRobert C. Martin demonstrating somethingIntentional SoftwareIntentional SoftwareStandards for medical devicesScalaParser combinators in SmalltalkBeautiful ThinkingEvening meal

JAOO 2007, Day 0

Arrival in Aarhus for the JAOO 2007! With a friend I’m the whole week up in Denmark and we will listen to the presentation in the following 3 days and afterwards attend some of the tutorials, in my case the tutorial of Robert C. Martin about Test Driven Development and Eric Evans on Domain Driven Design. The flight was without problems although the Quick check in at Vienna Airport was not so quick at all because the terminal was unable to print the tickets (no problem, you can simply open the box and see what was left inside the printer …), finally we had to check in in the traditional way. At the arrival in Aarhus we run into Rajeev Dayal from Google who gives a talk about GWT 1.4 on JAOO. We are staying in the same hotel, as seems most of the attendees, which is, to say it nice, a bit old fashioned. But it is certainly enough for the week. We were out for lunch and had a interesting discussion how they develop GWT, about language design, C# and Java and about Rich Internet Clients. Tomorrow the conference will start and it will be a challenge to decide which speaker should be heard.

Long way to the gate Sometimes the only way in is not so obviousSettled inThe conference hallThe preferred danish transportation

High Scalability

Found recently a interesting site concerning highly scalable web architectures, High Scalability. If you go through the realized architectures you see nearly never ASP or JEE (but at least some Java). Most C/C++, MySQL and Memcached besides various script languages seemed to be in favor.

Beautiful Code: Quaere

If you are on the Java Side of Life you are certainly very jealous on the C# world because with the coming of LINQ you have a very nice and useful framework to resolve query tasks on any thinkable object structure (or XML, SQL, Amazon, whatever). Because Java is based on byte code and not on a flexible intermediate language as it is the case for the CLR, there will no big change in the near future for supporting new language features (but hopefully the generics will be repaired …). I personally think with the availability of JRuby we will see some cool extensions but at least for LINQ there is a new interesting project from Anders Norås: Quaere
This is a very nice project of an DSL with the API copied from LINQ and the use of ANTLR 3 to realize the same feeling and functionality. The projected is in it´s first steps, so there are some obstacles and not all is working as expected, but it is a nice peace of code and really worth reading. Hopefully it will mature …

Maybe Java will never have comparable structures as the expression tree which is the backbone of LINQ but maybe more elegant and useful APIs based on DSLs and JRuby will surface.

UPDATE: The new Quaere Home could be found at Codehaus.

Why motivation is more important than skills

Software development projects are always a challenge especially so if they are realized very fast and with the help of agile practices. By far the most important skills inside the team is the motivation to take the bait and the willingness for taking responsibility of his own work. Technical skills are necessary but by far less important. Skills are always teachable and every technical skill can be learned by everyone if he really wants it. But if you are not believing that you can successfully finish your work or it does not matter what you do, the project is nearly lost. Software projects are always a very uncertain territory and you have to change your path very often. For not getting lost it is essential that you know what your target is and you really want to reach it.

Currently I’ve the problem that my team has skilled and experienced members but the motivation to finish the project or to throw in more than the minimal acceptable amount of work. The project is already on a critical path but no one cares. The reason is in this case that trust in the success and the usefulness of the project was lost shortly after the start of the project (or never existed). The company management changed the path sometimes, feature creep is happening and there is definitely not much trust and expectation that the result will be finished in time and is valuable. So there a lot of external consultants, internal company struggles for influence and some unmotivated teams. So how could this problem solved? In my opinion only in that way that you have accept the current situation, appeal to the professional pride of the team members and try to finish all with less than the real existing amount of capabilities. After the finish line, full stop and rethink the whole eco system because it makes certainly no sense to go one step further.

This is the first time that I have the situation that the environment to realize a software project is so poisoned that the willingness to finish a project is nearly zero. I heard such stories from bog development shops as they could be found in large companies for internal software but it was new for me that you can paralyze also small teams completely. For the future I know now that the only way to solve the dilemma is to react on the first singes inside the team and fight back internal or external attacks on the moral. The last possible solution is to stop the project as soon as possible because otherwise it will become a tour de force

Transactional Memory Garbage Collection

I#ve found a interesting paper published at OOPSLA 2007 by Dan Grossman where he points to the similar patterns in the concept of Transactional Memory and Garbage Collection. The paper is not only well written by itself it is also a good source for finding more resources for both concepts. I also think that his claims are right: Transactional Memory will never need hardware support (as was similar claimed in the beginning for GC), that TM will need more time as expected to become mainstream and that it will not make concurrency programming much easier (but it will certainly help to prevent us from visiting the most silly traps again and again …)