[Insert clever play on the name Io]

And so goes the second week and the second language on our seven week trip. Compared to the first week in Ruby, I struggled a lot more with Io. It's a language with very simple rules which, for me, made the edge cases all that more confusing. I also was a bit preoccupied with other, unrelated issues and so I skimped on a lot of the examples. Thankfully, Alberto did a lot of that work and wrote about it in a series of excellent posts. If you want to know more about Io, you should really read those.

As such, I'm going to keep it short with my own observations. As an abstract, Io is a prototype based OO language where everything is either an object or a message passed to it.

• I was unable to build Io in Windows and I don't know what I would've done if I hadn't found some forum posting with a link to pre-built binaries. 
• I particularly liked the way conditionals were also just messages, apparently just extending the base boolean types
• Yet I don't really understand message precedence and how something like self sum / self size works. self size obviously gets evaluated before being passed to the divide operator, which I didn't expect
• getSlot('foo') code print will print a method definition, similar to Javascript's foo.toString() (where 'foo' is a method/function)
• sadly, that is not usable for the language constructs as they are written in C
• Io has a pretty solid concept of coroutines, actors and futures, much unlike Javascript. Quickly writing some parallel code might indeed be one of the languages strong points

It seems the book deliberately started with Ruby to ease me in and then started to get a bit more challenging with Io to progress to Prolog, which I guess will be quite a bit different from what I'm used to. 

I'm again grateful for our study group. Our little skype conference showed that I wasn't the only one struggling with Io and I'm not sure I would've gotten much out of this chapter if it wasn't for other people's blog posts further explaining things. This isn't really a failure of the book as much as I just wasn't able to commit the time to really dig into the examples.

And now it's on to Prolog, which should get interesting, as I haven't worked with logic languages before. This time, installation is easy, as there is a package in cygwin that provides the 'pl' executable. (And, once again, let me recommend also getting mintty.)

First language done; inspiration had

Continuing on through Seven Languages in Seven Weeks I've finished the chapter on Ruby. I'll quickly list a few more things I've noticed and then do a little initial retrospective.

• I was a bit confused with how method definitions apply to classes v. instances and how module inclusions and extending classes work into that
• Interestingly, I feel reminded of similar troubles I had with understanding Javascript prototypes, functions and new. 
• obj.freeze appears to be a way to dynamically declare variables final. I suppose that could be useful
• you can always pass blocks to functions even without having declared them as arguments
• there is what I'd call reverse varargs that lets you explode arrays to match method arguments using the same notation as varargs, which I quite like. def foo(one, two, *rest) …
  foo(*[1,2], 3, 4, …)
• Having things like .methods on all objects to do reflection for debugging/getting to know the language is really helpful
• if I had worked through this before and added a bit of rspec knowledge I might have been able to contribute a lot more on the occasions I paired on Ruby at code retreats

Code is here. 

So now a little bit about the learning experience. I'm greatly enjoying this so far and I think it comes down to three things.

The book

The book is great for getting you started in a language. As I mentioned on twitter I left with more questions than answers. But I now have a vague idea of where to look to find those answers. It's a really great achievement to pique the interest to go into the details of a language and to not make you feel completely lost doing so. I'm already looking forward to learning about Io.

The group

I'm also really enjoying our little virtual study group. People share their questions, answers or just share their fun in the learning. There's a lot of interesting blog posts already (aggregated here) and also quite a bit of activity on the github network for the project. I find this both liberating and motivating. It's safe ground for exposing your ignorance and at the same time I feel challenged not to slack off and actually keep working on it and do things like writing blog posts. 

The technology

And I love the technology that enables this and the fact that there are people that care enough to take part in this. We live in amazing times! Programming is fun and being able to share that with others makes it even more fun. I love that it's so easy to organize this on twitter more or less on a whim (at least my taking part was on a whim). I love that to get started reading I only needed a few clicks on pragprog (even if the kindle version has its little issues). I love that github lets me see how others solved the problems given in the book, both reassuring me that I did something right or helping me along to find better solutions. And then of course it's great to be able to just download and try out all these languages.

Seven Languages In Seven Weeks

I'm stuck trying to put my thoughts on estimation, conferences and switching jobs into writing. So many unfinished drafts, oh my!

So instead I'm now trying to write the odd post about my experience working through Seven Languages In Seven Weeks.

aimee daniells had the great idea to start an online study group for said book (not gonna type that title again, nu-uh). And since it helps distracting me from worrying about finding a new place to live within the next 3 weeks I gladly took the opportunity to join. (Sidenote: if you're looking for a flatmate in Hamburg please do get in touch.)

The book is very interesting to me because I don't know all that much about any of the languages but have been meaning to take a closer look at Clojure, Ruby and Erlang for some time. It's nice to have something concrete that gets me doing that.

The first language is Ruby. I've worked through days 1 and 2 now and here's a quick summary of what I took away from it.

Ruby has a lot of syntactic sugar. Enough to almost certainly give you diabetes. Parts of me (the old, elitist parts) feel somewhat uncomfortable with that. Other parts of me (the ones trying to get work done in Java) just feel jealous.

There were some more notes I took that I'll just list here without trying to add context (or sense)

• The kindle version of the book doesn't wrap the code examples correctly with larger text sizes. That's pretty annoying. Does no one test these things?
• When googling for the api docs one should be careful that one reads the docs for the correct version of ruby one is using. I spent 10 minutes wondering why str.match(regexp) { block } never executed the block until I figured out that that feature just didn't exist
• String and exec expansion seem to behave pretty much like in bash. Single quote string get left alone, double quote strings get processed and backticks execute native programs. (I hope I'm not misremembering my bash there)
• if and while have counterparts in unless and until. Sugar++
• Sugar++ would not actually work. Sugar += 1 does, however. And I think I like why that is the case
• Numeric zero and empty strings evaluate to true, which i find pretty disgusting
• Running in a windows shell I successfully ran into encoding issues for Umlauts. Probably Windows' fault. I hate character encoding
• Cygwin can install ruby and Umlauts look ok there. Calling the windows ruby executables from inside cygwin, which I tried first, had some really weird issues
• On that note: mintty still rocks
• Enumerable has all the nice sugar you can only get via Google's guava in Java. And with blocks it's a lot better readable
• And you can mix all that into your own classes, with just a bit of duck typing. Very nice
• All that duck typing really makes me long for some grapes
• If I understand it correctly, Hashes can lazily evaluate values from keys which reminded me of the guava MapMaker. Also very nice. 
• Hash.invert seems almost too sugary but could be useful
• Same goes for String.next. Instant tooth decay!
• A File API with permissions and methods to create symlinks? I never dared dream of that (although, wasn't there something in that regard in the works with Java, too? About time anyway)
• IO.readlines/foreach is really handy. Convenient enough to never look at perl again. 
• The automatic closing of files when using blocks is also nice. Kinda like using() in C#, implicitly. (Wasn't there also something like that coming to Java? I can't remember all the things that may or may not go into the language)
• I felt pretty clever doing Array.new(16) {|x| x+1} until I saw (1..16).to_a

Code is here.

All good fun so far.

Ignoring long-term planning and estimating

I got on the agile bandwagon fairly late considering people are now celebrating the 10-year anniversary of the agile manifesto. But it's been a good 2 years now and I feel like it's a good time to sum up some of my experiences. And I'll start by writing something about estimating that's recently been on my mind a lot.

I get the impression that a large part of what people use to sell Scrum to managers is the ability to get better estimates and more reliable long-term planning. That tracking velocity and assigning storypoints to your features somehow enables you to determine what exactly you can release half a year from now. I don't think that's entirely honest. You still have no way to reliably predict accidental complexity; and team fluctuation, shifting priorities and delays in external processes that you depend on will still leave you guessing when you'll have that big new release ready.

The constant feedback obviously helps to at least be able to react to some of these obstacles. A looming deadline works wonders to get stakeholders to prioritize the features they want implemented. But I think all of this is looking at agile development from an old-fashioned angle, that is likely to be more frustrating than necessary.

Those big releases and big new major versions of your products just don't make all that much sense if you're not actually burning your software to disks to be put onto shelves. If you have a new little feature that will help your customers have a better experience using your product why wait to release it? If that feature actually doesn't help your customers, why wait to find out about it?

If you're a long-term agilante (agilista? agilero?), that is probably pretty obvious. But personally, I don't think I really grasped the power of that until recently. Really taking the idea of short iterations with incremental changes to its conclusion is not something I've seen much of in the time I've been developing software. You may read about some of the big poster-child internet companies working that way and increasingly, little start-ups seem to have a lot of success with it. But once companies get to a certain size they seem surprisingly eager to hold back on actually releasing their software.


And, with that said, I have decided that I do not care about estimating any more. I do care about the people on the team, I care about splitting items up into fine-grained tasks [edit: 'features' is probably the better word]. I might even care about tracking time spent on tasks to get feedback on whether we've become stuck on something. I care and take pride in the quality of the code we deliver. I care about people using that software and the feedback they can give. I don't care about dates in the future that may as well be arbitrary.

I conveniently ignore any kind of marketing needs or grand c0mpany strategy. Because, really, why shouldn't I? If we can consistently release new features in a short timeframe and the quality is good, why shouldn't the company strategy adapt to this rather than the other way around?

This idea is fairly fresh in my mind and I'm really looking forward to seeing what it develops into. I'm pretty sure I've missed a few things. And I'm curious what other people think about this...

Edit:
And to aptly prove the motto of this blog, Naresh Jain wrote about this two ears ago. Well worth reading.

Code Retreat - was ist das?

Edit: es hat sich viel getan. Code Retreats finden mittlerweile ziemlich häufig statt. Auf der Seite der Softwerkskammer findet man mehr dazu. Die Veranstaltungen sind immer kostenlos und es lohnt sich auf jeden Fall, mal teil zu nehmen.


Vor kurzem habe ich an einem Code Retreat teilgenommen (Leo gibt für "retreat" u.a. Klausurtagung, was das ganze einigermaßen trifft) und war davon sehr angetan. Ich plane gerade, selbst einen solchen Event zu organisieren und im Zuge dessen lohnt es sich einmal ein paar erklärende Worte auf deutsch zu schreiben.

Ich bediene mich dabei sehr ausgiebig bei dem was Corey Haines und andere schon zu diesem Thema geschrieben haben. Am Ende dieses Artikels verweise ich auch noch auf einige weiterführende englische Seiten.

Was ist das Problem?

Im normalen Arbeitsalltag wird kaum Zeit darauf verwendet, seine Fähigkeiten zu verbessern. Man nimmt vielleicht hier und da an Schulungen teil oder arbeitet sich gegebenenfalls in neue Frameworks ein. Aber wir arbeiten nicht gezielt daran unsere Arbeitsweisen zu verbessern oder unser bestehendes Know-How zu vertiefen.

Und wenn wir dann unter Zeitdruck stehen, fallen wir zurück auf die Techniken, die wir beherrschen, auch wenn wir wissen, dass es bessere Möglichkeiten gibt. Das klassische Beispiel hier sind Software-Tests. Es ist nahe liegend, dass ein Projekt mit hoher Testabdeckung mehr Sicherheit beim hinzufügen von Änderungen bringt. Damit aber sowohl die eigentliche Testabdeckung, als auch das Durchführen von Änderungen mit einem vertretbaren Aufwand erreicht werden können, braucht es einiges an Erfahrung und Übung. Und wenn man diese Erfahrung nicht hat und der nächste wichtige Termin naht, ist es dann doch einfacher, die Tests zu ignorieren und direkt drauf los zu programmieren.

Einige Leute bringen an dieser Stelle auch gerne den Vergleich zu Musikern. Genau wie diese ihre Fingerübungen machen, kann man auch als Entwickler sein Können trainieren. Statt dessen geben wir aber jeden Tag ein Konzert. Das hat natürlich auch seinen Wert und man wird auch nicht vermeiden können sich hier und da zu verbessern. Man kann sich wahrscheinlich auch eine ganze Weile diesem Trott hingeben. Aber irgendwann nimmt einem die Eintönigkeit dann doch die Freude an der Arbeit.

An dieser Stelle kann man auch gleich einen Strich ziehen. Wer mit seinem Können zufrieden ist und sich damit wohlfühlt, sollte wohl nicht weiter lesen. Zufriedenheit ist schwer genug zu erreichen. Lernen sollte freiwillig und aus eigenem Interesse passieren.

Was kann man tun?

Wenn man sich bewusst die Zeit nimmt, gibt es eine Menge Dinge die man tun kann. Eine gute Möglichkeit, die vor kurzem in der GOOS-Mailingliste erwähnt wurde ist, sich gelegentlich einfach mal eine halbe Stunde Zeit zu nehmen, bestehenden Code zu verbessern. Dies sollten wirklich nur kleine Änderungen sein und man sollte sich an seine Zeitvorgabe halten. Ist man nach dieser Zeit nicht mit dem Ergebnis zufrieden, verwirft man seine Änderungen. Da dies ja primär als Weiterbildung zu sehen ist, sollte man gar nicht davon ausgehen wirklich Code zu committen. Und wenn dann doch eine Verbesserung dabei heraus kommt, umso besser!

Mehr und mehr finden sich auch Code Katas im Netz. Hier werden überschaubare Aufgabenstellungen wieder und wieder gelöst, um in ähnlichen Alltagssituationen praktisch reflexartig darauf reagieren zu können. Diese sind sowohl ein guter Weg selber zu üben, als auch interessant anzuschauen. Es gibt eine ganze Reihe von Leuten, die freundlicherweise ihre Lösungen im Netz bereit stellen, zum Teil auch als Screencasts. (http://codingkata.org/ http://www.katacasts.com/ http://codersdojo.org [Link aus dem Kommentar hinzugefügt]) Gerade für Einblicke in neue Programmiersprachen sind konkrete, bekannte Beispiele sehr hilfreich.

Überhaupt ist natürlich die Zusammenarbeit mit anderen wahrscheinlich die beste Möglichkeit, neue Dinge zu lernen.

Darüber hinaus gibt es natürlich auch noch andere Dinge. Unter anderem halt Code Retreats, sonst würde ich ja nicht diesen Artikel schreiben.

Was sind jetzt also Code Retreats?

Code Retreats folgen einigen relativ einfachen Regeln:

• Aufgabenstellung ist Conways Spiel des Lebens
• Mittels pair-programming und, nach Möglichkeit, test-getrieben, versucht man das Spiel zu implementieren
• Das macht man für 45 Minuten. Danach wirft man den geschriebenen Code weg. Keine Backups, kein committen in ein Repository. Einfach nur löschen
• Man nimmt sich ein paar Minuten Zeit, um in der Gruppe darüber zu reden, was man gelernt hat
• Man fängt wieder von vorne an (6-7 mal)

Da es eigentlich nicht möglich ist, innerhalb von 45 Minuten fertig zu werden, braucht man gar nicht erst zu versuchen, Abkürzungen zu nehmen und kann sich nur darauf konzentrieren, "perfekten" Code zu schreiben. Es macht auch nichts, für einen Durchlauf eine komplett neue Herangehensweise auszuprobieren (z.B. keine else-Blöcke, keine primitives, nur Funktionen/keine Objekte, keine Methoden mit mehr als zwei Zeilen, ...). Egal was man probiert, man riskiert im Durchschnitt nur 22,5 Minuten.

Es geht ganz klar nicht darum, die Aufgabenstellung zu lösen, sondern auszuprobieren, wie man anders an die Aufgabenstellung heran gehen kann. Insbesondere eignet sich das Format auch gerade dazu test-getriebenes Entwickeln zu üben.

Für mich war außerdem auch sehr interessant zu sehen, dass der entstandene Code nur einen Teil des Produkts der 45 Minuten ausmachte. Das entstandene Wissen über die konkrete Problemstellung brachte jeden neuen Durchgang deutlich näher an das Ziel als den Vorherigen.

Weiterführendes

• http://coderetreat.com/how-it-works.html Eine kurze Beschreibung des Ablaufs eines Code Retreats
• http://programmingtour.blogspot.com/2011/01/on-goals-of-coderetreat.html Ein etwas weiterführender Beitrag zu den Zielen. Enthält auch ein Video mit der Einleitung, die Corey Haines zu Beginn eines Code Retreats vorträgt
• http://www.infoq.com/presentations/Software-Craftsmanship-Beyond-The-Hype Die Präsentation von der QCon 2010, durch die ich auf das Thema gekommen bin
• http://vanryswyckjan.blogspot.com/2010/11/code-retreat-ghent.html ein Erfahrungsbericht
• http://financialagile.com/reflections/8-software/38-coreys-code-retreat und noch einer

Remember back then?

...back in 2010? That was a nice year. I have to say I'm pretty happy with how it turned out. There were some setbacks, first and foremost the departure of two colleagues whose knowledge and support I valued very highly, who left for new cities and new challenges. But such is life. But I learned a lot this year and got to make a lot of interesting experiences and meet a lot of interesting people.

It was a long year and this will be a long post. It will be self-indulgent and most likely only for my own benefit. So there.

First off, I finally took the time to finish reading Domain Driven Design, or "the great blue book in the sky" as I heard someone (probably Neil Robbins) call it. It was very timely as we were just in the process of redoing a fairly large part of our application. It gave me the confidence to split up the refactoring along the life cycle of our main entity, transforming it along the way. That way we were able to concentrate on the first step in the life cycle without having to change everything down the line, too.

Said refactoring was also the first time I remember of deliberately doing "refactoring toward deeper insight". The experience of taking what we had learned about the domain in the previous year and applying that to our domain model was surprisingly rewarding. The end result was a lot simpler and closer to how people actually worked. It gave us the opportunity to introduce new functionality that would otherwise have been extremely cumbersome to implement.

The whole process was not without its flaws though. We underestimated the amount of code we had to change, even with the reduced scope. Especially the front-end proved that good UI design is very hard and time-consuming. In hindsight we probably should have spent more time on considering how the changes might have been divided further into smaller, releasable pieces. In the end we were left with a long time between deployments and suffered all the communication issues that missing regular feedback loops can give you. It was still a good learning experience and it showed me how much I appreciated our previous, shorter deployment iterations.

In march I went to QCon, which I wrote about before. The inspiration I got turned out to have a fairly lasting effect. To get back to the kind of enthusiasm I had when I started out and to be able to really consciously enjoy coding again is something I am extremely grateful for. This wasn't necessarily all due to QCon but it encouraged me to be more introspective about how I work. In particular it had me putting more effort into getting better at TDD. At some point the whole "using tests to drive out the design" bit finally clicked and it made me a happier person.

There is still a lot left to improve though. Most of our bug-fixing work is now purely front-end stuff, ironing out layouting issues and Javascript behaviour across different browsers. But we're getting there. Writing jasmine tests is something I'll hopefully get better at and which integrates well enough into our builds. My colleague Benjamin put an amazing amount of work into getting a useful Selenium tool-set and tests for us. The environment for these is sadly still somewhat brittle but hopefully that will get better with Selenium 2.

We've made a lot of progress in automation anyway. Our test-environment gets automatically redeployed by Teamcity now. These are still very tiny baby-steps towards continuous delivery that conveniently ignore some of the larger issues like schema evolution and the need to switch to a DVCS but at least I think it's stumbling in the right direction.

I was also happy I got to help in making collaboration with our designers on different teams a little easier. Working on a bunch of projects in parallel while trying to consolidate on a consistent look & feel is something that has taken even more effort than I expected. And since look & feel is usually the most immediately apparent contact point for stakeholders, it is always under scrutiny. I underestimated that, too, even though I really should know better. All the more reason to push for further front-end test automation.

Later in the year our team worked on a new project and decided to base it on JSF 2, mostly so we could get the know-how. The other teams were already using it and it seemed reasonable to look for common ground there. I did learn a lot, but I didn't get much done. Having no one on the team with any prior experience meant we had to go through all the little beginners mistakes you get when you stumble into some new technology. Some of those early issues just rubbed me the wrong way which made me get increasingly frustrated. And I'm afraid my growing resentment probably didn't help the mood of the team.

This did bring up a few interesting questions about the effectiveness of aiming for a heterogeneous development environment. Questions which I don't really have answers for but still could ramble on about for hours. So I should probably put that in another post some day.

In November I was lucky enough to take part in a Code Retreat. Having been intrigued by that ever since I saw Corey Haines talk about it at QCon, I jumped at the chance to try it out. This, too, is worthy of its own post and so I won't go into details here. Suffice it to say that I liked it a lot and plan to organize a code retreat in Düsseldorf, to show it to more people.

(As an aside, I just stumbled over a google result for a code retreat in Wroclaw which brought a smile to my face. I always enjoyed my time there, when I visited there for another company, back in another time. And I always had a very high opinion of the people and their programming skills there. So, I guess this fits quite well.)

After Code Retreat Ghent came Google Developer Day Munich. It was nice to meet my now ex-colleague Sebastian again. And same as in Ghent, I was glad for the opportunity to chit-chat with other people in our profession. It never hurts putting things in perspective and hearing what others are passionate about. And of course, rambling about things I'm passionate about. (Something I find myself doing more of these days, I think. But maybe it was just the free beer provided by Google.)

The effort Google puts into these events was impressive and I really liked how non-partisan the speakers were. They openly acknowledged the existence of competitors (foremost Apple) without looking to discredit or awkwardly ignore their work.

I wasn't looking for anything in particular since my work currently targets neither HTML 5-capable browsers nor mobile phones, but at the end of the day I felt more sad about that fact. I wasn't aware how exciting some of the HTML 5 stuff is and I'm really looking forward to that becoming the norm and what people will be able to do with it.

Well, that about does it for two-oh-one-oh. Remaining, then, is the goals I've set myself for 2011 (I'm not yet convinced of spelling it 20!!).

• Organize a code retreat, possibly making it a recurring event
• Look for more of these opportunities to learn from others
• Subversion is a nightmare to merge stuff with and I'm eager to switch to git but it would mean having to get used to a different workflow for everyone in the team. Maybe I'll start with a git kata.
• Follow through on all the "I should really write a blog post about that"
• Write more posts in german. 
• Read GOOS, finish reading REST in Practice, glance over Continuous Delivery.
• Try to solve more problems event-driven

Hmm... last and possibly least I just realized that I also started writing on this blog (and on twitter) this year. I guess I'll keep that up.

Javascript TDD with jasmine and maven

Edit[04/2011]: Since I seem to get the odd google hit on this it is worth pointing out that Justin Searls has since updated the plugin to include a lot more useful configuration options and also made it available in the maven central repo. So you can just use it straight away by following the instructions.

Edit[05/2011]: and now there is also this awesome site where you can try out jasmine and even do it in coffee script - all in your browser. Happy pandas all around!

As the amount of javascript in our project has grown quite considerably, it was time to get rid of this black spot in our test coverage. And since I'm getting more and more used to test-drive the code I'm writing, it was especially annoying to have to regress to trial-and-erring for the javascript part of our code.

I was overwhelmed by the choice of testing frameworks but eventually settled on jasmine, as that seems to be the most widely supported one with a reasonable syntax.

As all testing that is not automated might as well not exist it was important that it was possible to integrate it into our Teamcity setup. Thankfully, seraching for jasmine and maven quickly pointed me to jasmine-maven-plugin.

This plugin builds a html test runner that includes all javascript files in your project and then gets accessed with htmlunit and can run during the maven test phase, requiring no changes to our Teamcity build configuration.

Since we have a bunch of library and legacy javascript code that takes offence to being included directly I needed a way to filter which files actually got included in the test. There was some slightly out-of-date fork on github that included changes to configure inclusion and exclusion patterns which I was able to adapt to the current version (Which is available here).

The nice thing here is that all files are still copied to the target directory and the exclusions only affect what files get loaded in the test runner which proved useful soon enough.

I wasn't really happy just expecting all files to be loaded in the tests since that is not likely how it would happen in the deployed code. I am hoping to have the test specs define what other files are required by a specific functionality. Since all files get copied it is easy enough just loading them from inside the tests. I'm not quite happy with that yet as globals don't get reset between different jasmine Specs but it should be easy enough to add that functionality at some point.

Another nice feature of the maven plugin is the inclusion of other javascript artifacts. This way you can deploy libraries like jquery to your local maven repository and have them automatically included in your test runner.

So, with that said, this is what I currently have in our maven configuration:



Most of the options are explained very well in the main jasmine-maven-plugin README. I've only changed the plugin version to our own locally deployed version and made use of the new include option. This will only include files named *_spec.js in the test runner. The specs will then load additional files themselves.