Top Ten Tips for Hackathon Organizers

Want to organize a Hackathon? Great idea! A Hackathon is an amazing opportunity to collect new ideas, learn new stuff and get to know interesting people. Here, I'd like to share with you my personal experince from past Hackathons.

1. Have a goal
Communicate the objectives and goals you want the participants to achieve clearly and without room of interpretation. Tell them your criteria to judge if the the goal has been reached. That will enable the participants to think in the right direction and it will help you to easily find the winning team. Whether its to try out your API or to construct some fascinating algorithm - write it down and stick to it. BTW, also tell them about the prices as well :-)

2. Know the technology
You really have to be knowledgeable about your technology. And: you must be able to explain it to the participants. Tell them which technology to use, how to use it and what bugs and issues are known. They don't have to try it all out for themselves - that will only lead to frustration - and time is short. You really have to know your ropes concerning APIs, protocols, data models and frameworks. Be prepared to answer questions, so better think before, which might come up.

3. Built a protoype
There is nothing better to prepare for a Hackathon as to do everything you expect from the participants yourself in advance. Of course, you might not be as fast as they're gonna be, and you might not have a UI so pretty - but hack some code and try it all out, because only then will you really understand the relevant challenges with the technology. An then, if your prototype is ready, bring it and use it for reference.

4. Keep it simple
Time is running twice as fast as normal at a Hackathon. Or maybe even faster. So, nobody will find it amusing to read through handbooks to understand you challenge. So, keep it straight and simple. Remember, people are there to have fun and hack away freely. If possible only make them use ONE API not many, and only ONE protocol or data format. Use JSON and REST, instead of XML and SOAP. If possible leave out authentication. And avoid any extra overhead like having them deploy every hour or having them use a unknown tool.

5. Write documentation with sample code
You should write documentation for everything you want the participants to use, that will keep them from asking you everytime, The documentation should be proof-read to be as error-free as possible. It really has to be, so stay focused to keep if correct. And insert code snippets into the documentation which can be copy-pasted into their code and which should run out-of-the-box. Beware, some programs have problems with copying to the clipboard, like some acrobat versions, which distort the characters.

6. Bring all the stuff
You should not turn up there empty-handied, but rather carry a real large bag. You should bring a lot of marketing material, like banners, stand-up figures, mugs, T-shirts, stickers and everything a developer might love. Also bring all technology you might depend on, like projectors, adapters, notebooks and presentation software. If you need your laptop with the old VGA output, bringt the corresponding adapter.

7. Plan time before and after the event
Your technology and all relevant documentation should be up and running latest one week before the show. The participants just need some time to prepare themselves. And then, after the event let it all stay up and running for at least a week as well, because thedevelopers like to show off and tell their friends and collegues about it.

8. Dont show up there in a suit
And a tie is no good either. But bring a sleeping bag.

9. Collect the results
Be prepared to gather everything they produced at the event. You will need some time for that and better before the final presentation. So there should be dedicated people going around to collect all stuff. Perhaps you need a repository for that. And if you cannot get the code or the running system, then let them provide at least screenshots and/or movies - and their contact data.

10. Know your data
I experienced, that most teams show up at the Hackathon with a firm idea of what to build already in mind. And for this idea, they might need a certain dataset. So, if you cannot tell them how your data is structured and what the limits are, they won't have a good time. Be prepared to alter the dat if necessary or even to import extra data at the event.

Devoxx vs. JavaZone

Every now and then I get queried which of the Java and Web conferences in Europe I would recommend. Often, the most sensible answer seems to be: “the one closest to you”.

Nevertheless, since I visited JavaZone in Oslo in September 2014, I think it may be time to make a thorough comparison after all.

But which are the criteria? The number of rock star speakers? The volume of soft drinks available for free? Alas, I came up with the following criteria:

Variety of topics

This is especially important because most people visit conference in order to peak over their horizons or to deep-dive into certain areas. As a minimum, conferences should cover the topics architecture, mobile, methods, coding and research, while all might bear different names or might be slit up into several sub-categories.

Quality of talks

Of course, the presentations must have content and meaning and they must be given in an inspirational manner as well. These are high expectations, and not many can live up to them. Especially talks, which center around products or have a high marketing potential, tend to be boring and to be of low quality.

Choice & Availability

If you have picked up your favourite talk and you can’t see it, because the room is crammed, that’s bad. It’s even worse if there is no sensible alternative, because not enough parallel tracks are available.

Community feeling

You also visit a conference in order to meet other developers and to talk to fellow architects. This is enhanced if the conference introduces a feeling of community into all its visitors. This can be achieved via events which include all or many visitors, by special after-dinner events, by talks which address all of the community and so forth.

Organisation & Infrastructure

You need to find your way to the conference, you have to know the program, must find the correct room and you need a working wi-fi. Especially the last issue is always a source of trouble, but it’s getting more and more important every year.

Venue & after-conference program

If you want to enjoy your conference, you need good lighting, cosy seating, and a venue which makes you want more of it. And in the night you need some distraction from all the hard-brained conference stuff, in order to be fit again next day.

Food & beverages

Everyone who ever organized a party knows: food is the one single most important thing. Thre is a saying “full belly does not easily study”, but that’s even more true for an empty stomach.

For a comparison, I gave each of the conference between 0 and 5 points for each of the criteria. The result looks like this this:

Criterion	Devoxx	JavaZone
Variety of topics	4	3
Quality of talks	4	4
Choice & Availability	4	2
Community feeling	5	4
Organisation & Infrastructure	5	5
Venue & after-conference program	4	4
Food & beverages	2	5

Let me explain, how I came up with the numbers:

Variety of topics: Devoxx is in lead, because it covers nearly any topic one can think of. JavaZone is only shortly behind since the program also is very versatile.

Quality of talks: The quality is above average for both conferences. Due to the sheer amount of sessions, there are in absolute numbers more mediocre talks at Devoxx, but this does not lead to a full point more for JavaZone.

Choice & Availability: Devoxx is clearly better here because all of its talks are in English (JavaZone has Norwegian talks still). Furthermore, the conference is longer (3 vs. 2 days) and contains more parallel sessions. So, you’re in for some hard decisions at Devoxx. Nevertheless, Devoxx does not earn the full score, because it is so over crowded, that you cannot see all the talks you want.

Community feeling: JavaZone is a true community conference. The same is true for Devoxx, which is a little bit ahead, because there are Keynotes (not at JavaZone) and opening and closing talks which appeal to the whole of the visitors.

Organisation & Infrastructure: This is excellent at both conferences and also includes the awesome websites and the (mostly) working wi-fi.

Venue & after-conference program: Devoxx can gather further points here because it offers an evening program at two days. But this is reduced by the venue being too much outside of the city center.

Food & beverages: Food is traditionally poor at Devoxx and excellent at JavaZone.  Devoxx has 2 points, because of its Belgium Fries night.

Which one of the conferences to prefer? It depends on which one is closest…

Devoxx 2013 - The coming of lambda

It’s November 2013 and it’s conference time again. The European Java and Web Community gathered in Antwerp for the annual DEVOXX conference, which always means days tightly packed with information. My head is still spinning but I’d like to highlight a few things which are noteworthy this year. But first, a picture from the first keynote session, showing live-DJ-ing with software scripting:

No single hype

This year, there was no unique theme standing out. The hypes of the years past, Mobile, Cloud, NoSQL, BigData, are now regarded as standard. There were still presentations about those topics, but they are “normal” now. This of course is a good thing, although great emotions and extraordinary news are missing.

Java 8 expected with Lambdas and support for parallel execution

There were a lot of talks on Java 8 and on the new features available with Lambdas and functional / declarative programming.  They especially seem to enhance code readability which is important because “reading code is more important than writing code” (Brian Goetz). The most prominent example is the replacement of the infamous anonymous inner classes through lamdbas. This can be seen in the following code sample:

public class MyListener {

  public static void main(String[] args) {

    JButton myAnonymousButton = new JButton("A Button");

    

    //actionlistener using anonymous class

    myAnonymousButton.addActionListener(new ActionListener() {

      public void actionPerformed(ActionEvent ae) {

        System.out.println("anon click!");

      }

    });

    

    //actionlistener using lambda expression   

    myAnonymousButton.addActionListener(e -> { System.out.println("a lambda click!");

    });

    JFrame frame = new JFrame("Functional Sample");

    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    frame.add(myAnonymousButton, BorderLayout.CENTER);

    frame.pack();

    frame.setVisible(true);

  }

}

Internally, the lambdas are implemented using invokedynamic which was introduced in Java 7. By doing so, the JVM can choose that implementation of the lambda which it sees fit. This is an advantage, since at programming time you don’t necessarily know the concrete circumstances of the runtime environment. On the other hand, the programmer loses control, because he only tells the JVM what to do but not how.

There is also a new stream library coming, which especially intends to simplify parallel programming. I’m not sure how much of a performance gain this can achieve, because it half of the code can be parallelized, the program can only run twice as fast.

Microsoft is Sponsor now           

The Devoxx organizers can be happy, because the “big four” are sponsors now: Google, Oracle, RedHat and Microsoft. Google dominated the talks, while, strangely enough, Microsoft did not show up in any of the presentations (although they had a booth). This is really a chance missed, especially since Windows 8 opened up to the Web and allowed for Windows Applications being written in JavaScript and HTML5.

More crowded, but…

Devoxx 2013 was even more crowded than the conferences of the last years. It was harder to get a seat for the important presentations and it was a pain to get something to eat. This all is ok, if the costs are low (which is true) and if the quality of the presentation content is high (which is not so true anymore). Actually, the quality of the slides was a catastrophy! I cannot remember another conference in the last years where “death by bullet point” was so imminent. Many presenters even read all their slides aloud and some did seem to be on the edge of sleeping (or at least trying to get their listeners to sleep). What’s more, good talks on methodology and architecture were missing, while many presenters focused on detailed features of various (sometimes not so important) frameworks. I also missed great keynote speakers. To wrap it up: quality at Devoxx seems to be on the decline. Maybe it’s because there are a lot of Devoxxes out there now (London, Paris, Kids …). Do they lose focus?

Highlights

Nevertheless, there were some very interesting and entertaining presentations: The session on Google Glass was absolutely packed and really lived up to the expectations. Another good one was Arun Gupta talking about web sockets. Also, Brian Goetz on details of the JVM and Ludovic Champenois on Google App Engine excelled. Next time, get us more of those, please.

Bots, brains and beer: looking back on Devoxx 2012

It’s barely one week since Devoxx and I already miss it. For the four of us, software architects and developers from Frankfurt, Germany, Devoxx started with Belgian beer (s. picture). And Belgian beer is definitively for my liking! Thus, the next morning woke me with a slight headache and big thirst.

Belgian Beer up close

 Alas, that did not matter, since the conference began with a dance performance, done by five NAO robots (s. picture). That hinted at a “sub-theme” of Devoxx 2012: robotics, which is great, because inter-disciplinary work can be very engaging and generate new ideas. After the robo dance Devoxx UK was announced: another split-off which will be held during March 2013 for the first time. Then the keynotes came.

Robo dance

The keynotes – we had better ones at Devoxx. The Oracle keynote was boring to the core and only consisted of marketing. This trend, which already started last year, materialized now and that’s not for the better of Devoxx. After the Oracle people went way too much over time and I nearly fell asleep, then came Neal Ford. Unfortunately, he was not as inspiring as in the last years. What was his central topic anyway? Although, he still had some interesting points to make, the inspiration which I so much long for in keynotes was missing.

The highlight of the first day way definitely Kirk Knoernschild and his talk “Architecture all the way down”. He says architecture is a way to cope with complexity but he also presents us the “architecture paradox”: everything we introduce in order to tackle complexity generates even more complexity. Thus, he asks, how can we overcome that? His central message is, that we have to care more about modularity. Taking apart the software into loosely coupled modules is the only way to reduce complexity and confine changes to certain areas of the system. He also states that we (software developers) think a lot about services and classes, but not enough about modules, which are “somewhere” in between. Moreover, Java does not provide us with sufficient tools for building true modules. I couldn’t agree more.

Day One closed with another instalment of great Belgian fries and some Belgian beer afterwards.

Next day began with the Google keynote by Tim Bray, which unfortunately, didn’t live up to my expectations either. Again, there was too much marketing and not enough message. Jerome Dochez made up for it, in his excellent talk about dependency injection. Above all, I recall one of his remarks on OSGi: “Do not use it, unless you have to add modules at runtime”. His warning about introducing unnecessary complexity with OSGi should be heard. The day went on with excellent talks on Vaadin 7, HTML5 Webapps, and JavaScript Unit Testing with Jasmine.

Thursday evening started with the James Bond Movie “Skyfall”, which was better than I expected. Afterwards everyone went to the nightclub “Noxx” which was book exclusively for Devoxx that night – and they served Belgian beer as well.

Friday started out with “Cloud Robotics”, went on with Daniel Kurka’s excellent presentation on “mgwt – GWT goes mobile” and closed with Adam Bien live coding Java EE. By the way, Mr. Bien was quite entertaining as always, but recommending developers to fake certain aspects of the software to please the architects should not be taken too seriously.

Where are you from?

Bottom line: Devoxx was an amazing experience once again, which I recommend to everybody who is interested in Java and web programming. That’s lots of energy and enthusiasm there in those 3.500 Devoxxians from all over the globe (s. picture of whiteboard), and you can feel it. The awesome twitter wall was put to good use again and the only thing I have to criticize concerning organisation is the catering: please give us some more and some better food, cake and lunch next year! Is it because of the diet that some people were missing? Matt Raible, for instance, or Joshua Bloch and Uncle Bob. Bring’em back! There are also some topics I’d like to hear about at Devoxx next time: Sencha, Liferay and Node.js for example. Come on guys: I’m looking forward to meeting you at Devoxx, Antwerp 2013.

The importance of Software Architecture in Agile projects

Last week I gave a presentation on agile project management. One of the talk's main points is, that software architecture and documentation are very important even in agile projects. That’s contrary to popular belief since many people seem to follow Dilbert’s paradigm “no planning and no documentation – just start hacking and complaining”.

My argument refers to the accumulation of technical and business related knowledge in the project. The project begins with a minimum of knowledge, and while the teams works, develops and releases it also gains new insights and new wisdom about their technical and their business domain. At the end of the project’s duration they end up with a maximum of knowledge. Conversely, the risk of making wrong decisions (based on false or deceivingly true knowledge) decreases with time (s. figure 1). That is the case with nearly every non-trivial software project.  

Unfortunately, in traditional software projects mostly all of the decisions are made in the early phases of the project, when knowledge still is insufficiently low (s. figure 1). That's why early decisions run a high risk of being wrong. Consequently, most of these projects are doomed to run into trouble. 

In agile projects on the other hand, decisions are distributed more evenly over the projects timeline. As the saying goes, they are deferred to the “latest responsibly possible moment”. Thus, we have decisions in all stages of the projects (s. figure 2). Early decisions need anticipation, since they always involve some guesswork about what e.g. the customer might expect or what the future market might look like. Later decisions need adaptation, because they can alter earlier decisions or even involve some remaking of the software.

Therefore, both methods – anticipation as well as adaptation – are needed to manage projects, and especially in agile projects. Both have to be in some balance (s. figure 3). But – and this is my main point – in order to enable the team to anticipate and to adapt, the project needs a solid base, which can be established only by correct documentation, sound software architecture and low technical debt.

E.g. software architecture is needed for both: anticipation and adaptation. If you anticipate some future demand (let’s say, lots of data) you may decide to include a bigger and more scalable database. This is a anticipating architecture decision. Likewise, if you have to adapt and must change something in the software, you’d desperately need a stable architecture, because if it’s not, your software might break through the change, or the change might not be possible at all. Thus, we can see that software architecture is at least as important in agile projects as in traditional, if not even more important. 

Android rules: Five exciting days at Devoxx 2011

Devoxx is one of the largest Java and Web conferences in Europe, held annually in Antwerp and organized by the Belgian Java User Group (BeJUG). From November 14th to 18th, I undertook the 400 miles voyage by car and dared to stay at infamous Belgian hotels to experience another exciting conference. And it was worth it all: the conference offered more than enough news and technology and software talk for everybody, enough to confirm the motto “Meet us in paradise”. Nearly 3.500 people attended, more than all the years before, and to my taste more than the venue can take. There was so much pushing and shoving during coffee and lunch break that time for small talk was short. To get a seat at the most interesting talks I had to arrive 30 minutes early. At this size the conference is comparable to Java One now and there will be a spin-off in Paris next year. All talks at Devoxx were recorded and will be published at parleys.com.

Image 1: Android Keynote by Tim Bray

Android, the UNIX-based operating system, was THE hot topic of the conference. Google developer advocate Tim Bray gave an excellent keynote on Android and thus prepared the stage for a plethora of presentations and workshops on the topic. With six parallel sessions every attendee was able to indulge himself in Android all day long. Version 4.0 of Android (codename: “Ice cream sandwich – no kidding) was just recently published. Android-creator Google, one of the main sponsors of Devoxx, in that release especially emphasizes usability and GUI-design. This really showed in the 3-hour-long workshop given by Bruno Oliveira by Google Brazil. Among other things he talked about the new GUI “fragments”, which are introduced in ice cream sandwich and which will be available to older releases via compatibility libraries.  I can also recommend the talks of Chet Haase, graphics and GUI programming specialist, who came from Adobe to Google. He presented many interesting details of the OpenGL interface of Android 4.0.

On the other hand, Oracle and Java still don’t seem to have found one another yet. Both keynotes of the Oracle employees Cameron Purdy (Java EE) and Henrik Ståhl (Java SE) were devoid of inspiration. They concentrated much on acquisition related stuff, which does not seem to make sense at a developer conference. Java 7 is out now and of course was covered by some talks. But nevertheless, drive and vision concerning Java seem to be lacking at Oracle. Interestingly, JSF was not addressed in any of the presentations, if not as a negative example. On contrast, the session on Java design faults and the childhood illnesses of the Java libraries held by Google chief Java programmer Joshua Bloch was really amazing.

One thing is pretty clear now: Flash and Flex are dead! Adobe announced to stop development of flash for mobile systems. HTM5 – the second hot topic of the conference – will do the rest. It’s clear that HTML5 is a game changer. RIAs and Web applications now get an even more powerful toolset on their hands, the consequences of which cannot be totally seen at the moment. I think, HTML5 and its syntax are less important on their own, but it will be crucial what JavaScript APIs and frameworks like ExtJS, jQuery and GWT make of it. A first glimpse of that could be seen in the awesome presentation of Matt Raible. He showed a mobile web application with HTML5 (and CoffeeScript and Play and Scale and…), which permanently polls the geolocation API of his iPhone and maps the way a runner or biker has traveled. As long as HTML5 is not fully standardized and not totally implemented in all browsers, PhoneGap can be an alternative. This means compiling the web application together with a special version of safari into some kind of native app, which can be distributed via app store (android market, respectively).

Spare time is short at Devoxx, but it was put to good use: it is good Devoxx tradition, to serve dinner with French fries and Belgian beer on Wednesday night. On Thursday, a movie is presented (“Tintin” this time) and afterwards a clubs opens for a special Devoxx party.

Devoxx is also a place, where you can watch the ups and downs of the hype cycle: “cloud computing” meanwhile is being regarded as a standard technique by the conference attendees. You just use it and expect systems and frameworks to be working in the cloud. Concerning the topic “NoSQL”, which was represented at the conference among others by MongoDB, the hype cycle has moved on and now also disadvantages are being recognized. For example, Chris Richardson profoundly addressed the question of valid criteria for deciding between different types of NoSQL and standard databases.

As with all events of this size there are always some downsides: the wireless LAN was offline most of the time, the new paperless registration with a glued paper wristband (!) was not really to my liking, the lunch was mediocre and the number of women at the conference is a pity (as was eloquently remarked at by Tim Brady in his keynote). Nevertheless, for all Java and web enthusiasts Devoxx remains a content-rich quality event – without true alternative.

Image 2: One of six rooms: Devoxx was crowded