His talk, along with the slides, will be available online soon (at least for Devoxx participants), but I generally prefer to note down the key points that really stick to my mind. Moreover, for such cases, I prefer not to take any written notes during the talk, but rather listen to it carefully. I think whatever I remember after some time is really what is important for me (otherwise my brain wouldn’t spend precious energy to create enough connections and excite a lot of nerve cells to encode it, would it? ;-))
So here comes my brain dump (all inaccuracies and factual errors are solely my responsibility):
* Highly effective teams share a common goal. A single, common goal. (Many of the participants admitted that their teams do not have such a clear, single goal, at least to the best of their knowledge).
* Effective teams have a good communication structure because software development involves a lot of human communication. Linus Torvalds once simple rejected a very sophisticated piece of code because the developer worked alone in his room for 6 months and then just dumped this blob of source code, expecting it to be accepted because it was good code. This did not happen.
* Great teams have Trust & Respect. Members of the team do not try to earn respect and trust. This is assumed by default. You are presumed innocent until proven stupid (e.g. you made the similar error three or four times, then you can’t access production and your commit rights might be revoked). Most of the participants admitted that they don’t have access to production servers.
* Highly effective teams automate whatever they can. DevOps is more than a buzzword, just like Test-Driven Development is. You should not force it down people’s throats but showing that they make a good difference with small and gentle examples is a great starter. Do not forget that changing established culture might take some time.
* Highly effective teams have a common culture. And no, the company motto is not enough. Also the ping-pong table downstairs or some other perks, luxurious items do not define this culture because they are at the surface, thus superficial. It is about really sharing very similar values.
* Leaders of highly effective teams are servants. A good leader hires the people who are smarter than her at specific technologies and domains, and then she gets the f#@!$ out of their way. So that things get done.
* Leaders of great teams are servants. They serve to ease the pain of developers when it comes to manual and bureaucratic tasks, some even fill in the timesheets so that developers can focus on their task of creating the automation.
* Highly effective teams have an open & structured debate culture. They prefer hard facts and evidence over intuition (and no “I’ve been in the industry, doing Java for 15 years” is not very helpful as an argument, sorry, but feel free to elaborate).
* Effective teams use the matrix method when they need to quickly decide for a new technology with a lot of alternatives: Write down the most important criteria, give weight to them, add them up, pick up the top two results (e.g. top 2 frameworks), then create 2 similar prototypes using those top 2 choices, and try to implement the most challenging aspects of your project. At the end of a few days, or even hours, you’ll have a very strong case and evidence to declare the winner. (Note: This was also described in the author’s “The Well-Grounded Java Developer” book).
* Dear managers, if you are forcing most of your team members to attend to meetings that last close to 2 hours, then you suck. That’s not what effective teams do. (Note: Most of the audience could empathize with that.)