On the 7th of May, we had our first NLGUG Groovy an Grails meetup. In one word: it was great!
Normally, when I organize something (be it a motorcycling event, going to the movies, or anything else), of all the people who said ‘yes’, 30% will show up (that is, if I’m lucky). Since 12 people expressed that they would attend the first meetup, I expected a group no bigger than 5 people to show up. You can imagine my surprise when out of 12 people, 18 showed up! That’s 150% more than you might have expected, and 500% more than I expected!
The event was kindly hosted by Lunatech Research BV, a small company in Rotterdam, who wanted to impress us with their office and hospitality. That succeeded greatly in that! The office was great, and the snacks where snacks++ ! Really well done, again: thanks for hosting the event!
The plan was to have 2 small sessions (of around 50 minutes each), drink some beer, get to know each other a little, etc. I think it worked out pretty well. We started with a introduction round, and it became apparent quite quickly that not a lot of people really (that is: in production) something with Groovy and Grails. Out of 18 people, only 2 people had real life experience with Grails. While I certainly hope this will increase, this is a really nice baseline. There were quite some members who had something in the pipeline, but nothing to concrete yet.
After our round of introduction, I had a small talk about how Flex, Grails and JMS could be combined into a small chat application. I thought it was a nice application, but due to time constraints, my presentation could have been better… Well, hopefully I’ll have some more preparation time next time!
The second presentation, which was presented by Michel Vollebregt, was great! The presentation described how to use Groovy DSLs, and was a great combination of combining Java + Groovy to create a very readable (at least: from a user perspective) language to calculate savings over the years. A really nice presentation with live coding, which deserves a lot of extra credits, IMO.
All in all, I think the whole evening was great. I’ve met a lot of new people who were all equally enthousiastic about G&G, and I heard a lot of great feedback about the evening. I think it was a big succes, and I’m looking forward to our next meetup in a month or two, which will be hosted by VX company this time. Great work guys!!!Read Full Post | Make a Comment ( None so far )
At the moment, I’m busy reviving the Dutch Groovy and Grails User Group. The goal is to meet other local Groovy and Grails developers to talk about code, architecture, and lots of innovation. Both beginners and pros are ofcourse welcome!
I’ve already planned the first event, at (probably) May the 1st, which is viewable here
This evening will be an opportunity for software developers to meet people with different experience levels with the language and the framework. It will also be a good way to identify how to help your and other companies by using Grails. The program isn’t carved in stone yet, but if you have some suggestion, let me know!
Furthermore, I’ve setup an Linkedin group, to get an indication of the interest in Groovy and Grails in the Netherlands. You can join that group here.
So I hope you can help me make this a great succes, and let the Dutch GG community have a voice in the Netherlands!
I’m really dedicated to make this work, but I need your help! It would therefor be great if you could all join, so we can organize some interesting session.Read Full Post | Make a Comment ( None so far )
I had better hopes for day two of QCon. With a DSL track, and Agile, things couldn’t get wrong here, now could they? Yes, ehhm,…well…
Okay, day two, which is still in progress, is quite a disappointment. Again. I don’t know, maybe it’s me or something (it probably is), but the things I heard today were all centered around the ‘open door’ theme: I already knew them, or they so obvious, it was hard to miss, and the presentation didn’t add much to that knowledge!
The presentations I’ve visited were the following:
Cultures Where Agile Emerges, by Pollyanna Pixton
In contrary to the above: this one was great. It was excellent! It was a really good start of the day, and it provided a lot of insights in great leadership and excellent teamwork. Pollyanna gave an inspiring talk with a lot of new and refreshing information! When I left the session, I felt truly inspired about the things told, like the decision making process of teams (I liked the quote that manager who knew less, usually decided more (this is a bit taken out of context, but it means that the higher you are in an organisation, the harder it gets to keep track of all the things going on around you. Having people who know those details make the decisions is therefore a logical result, which is the approach Pollyanna proposed. But, to be able to do that, trust is necessary). Well, a lot was told, and I left the presentation happy. I think there wasn’t a single yellow (nor red) note in the basket, so I guess I’m pretty safe to call this one of the best received sessions of the show!
The Joys and Pains of Long-lived Codebases
I’m always interested in long lived codebases. When you work with a team on a codebase, different opinions, ideas, techniques get into the codebase over the years, and you have to manage this complexity. This presentation was about the pittfalls, and how to overcome them, and even though it was in .Net, it should prove to be useful, right?
Well, instead of a batch or webbased application with tens of interfaces, deployment descriptors, developed by distributed teams, we got a presentation about Structuremap, an IoC container developed by a single programmer. Not necessary bad, but this didn’t really match my expectations. Furthermore, the talk proposed some solutions which aren’t bad (at all!), but which I/we already do, like internalizing testdata (since XML or SQL in tests are hard to maintain). Not a bad talk, it just didn’t match my expectations.
Groovy DSL’s, by Scott Davis
I like Scott Davis. I’m a real big fan of his Grails series at IBM, and I love the way he explains. Not during this talk though! The promise was a presentation about Groovy DSL’s. 20 minutes of the talk was spent on explaining what a DSL was (come on, this was the 3rd or 4th presentation in the DSL track!), after that, a introduction to Groovy (argh!!! If you don’t know Groovy, you’re not in that session!), a way to use Groovy in shell scripts (a DSL? Come on!), and after that, finally, a DSL….about time calculations!! NOT AGAIN! After that, I left the session. If the description of this sessions was something like: ‘An explaination what DSL’s are, an introduction to Groovy and using Groovy in the shell’, it would have matched my expectations (not that I wouldn have visited the presentation then..). But this was totally different from the description. A big disappointment.
After this, I went to another talk, about Agile in the Enterprise, but this wasn’t Agile in the Enterprise, this was a bullet point presentation about implementing Lean. I don’t want to write anything about that. Like before: not a superbad presentation, but not what I expected, nor what was written down in the description of the session. A waste of my time.
What I discovered during most talks is that a lot of the talks were not bad in itself, but just didn’t match my expectation. A lot of the sessions were at a beginners level, and didn’t match the description is the programme at all! I would say: fix that, and remove the beginners level sessions. My epxerience is that most programmers attending the sessions have at least 5 years of programming experience, and are also (a little) experienced in the subject of the session. If you’re a presenter, and you’re unsure what kind of audience you have in front of you, simply ask! If no-one is a beginner, then skip the intro. Easy as that, right?
Well, let’s see if the next and final day of QCon 2008 will bring some more indepth sessions. I certainly hope so!Read Full Post | Make a Comment ( None so far )
At the moment, I’m visiting QCon 2008 in San Francisco, to learn more about effective design, Agile processes and DSL’s. Today, on day one, the two first topics were touched: effective design and Agile processes.
Too jump to conclusions: day one was a bit of a disappointment. Unfortunately, I wasn’t the only one who felt that way. The quality of each session could be expressed by dropping a colored note in a basket at the end of each session. The colors were green, yellow, red, which respectivly meant great!, okay, and not good. I’ll use this convention in my blog entry.
I’ve visited the following sessions:
How to Build Any Team any Time, by Christopher Avery
Really nice presentation about aspects of normal work, like teamwork, responsibility and blame. A nice and simple exercise to get the audience a bit loose, and some nice insights in the way power works. Also some great book tips, for example: “The faces of power”, by Kenneth Boulding. A well deserved green card, but unfortunately the best presentation I saw during the day.
Qualities of great code, by Marcel Molina Jr
What can I say about this session? At the start of the session, the room was full. Halfway, at least a quarter of the attendees had left, and at the end, more than half of the attendees had left the presentation. This was also reflected in the rating of the session: more red than yellow, and I saw no green.
I was such a shame this presentation was so bad received, since the topic is Great/Clean code is interesting enough to write a whole series of books about. It was therefor a bit of a disappointment that during the complete presentation, not a single piece of code was shown, and most things that were discussed were ‘Ruby is so great, but tell me audience, how can a programming language be even better’. The audience was surprised. At least I was. Sorry Marcel, I think you can do a whole lot better than this!
Responsive Design, by Kent Beck
I felt a bit disappointed by this one. Sorry Kent, but I expected way more than this, but I’m sorry for putting a red note in the basket. It really wasn’t that bad, it’s just that I expected much more of it. My idea was that most things told were an open door. Stepping stones, drilling down to the simplest solution: that’s the thing I try to do (almost?) all of the time! My mind doesn’t work when trying to solve a million piece puzzle, but I have no problem with connecting 2 pieces of puzzle a million times. So I totally agree with you on your approach, but I guess I expected something else here. But I like the idea of keeping track of all design choices which you’d have done differently. I might try it out!
10 Ways to improve your Code, by Neal Ford
Another one which disappointed me a bit. The outline of the presentation described that “Everything in this talk may not be new to you, but I guarantee that you’ll see some things that will make you reevaluate the way you think about your code.”. Well, Neal started with tip 1: extract method, to create readable code, prevent duplication and let the code be the documentation. Well, I already knew that one and apply it almost everywhere. Another tip: Use Findbugs. Hmm, well, isn’t that standard? Another tip: don’t use Singletons. I thought we stopped using that since 2001? I can’t make any remarks about the other 5 tips, since we left after that, but I encountered this list which has the rest of the tips. They look more interesting than the first 5 tips, but like I started this paragraph: I expected more!
So, like said before: day one was a bit of a disappointment. The conference itself is great and all, but unfortunately I choose the wrong subjects. Well, I hope tomorrow will be much better. DSL’s, here we come!Read Full Post | Make a Comment ( 1 so far )