Then I would like to thank for the fun competition James set up, it was really a learning experience and in retrospect I would maybe have put even more effort in the learning parts throughout the exercise. This, and my ability to concentrate may also have been impaired because of the time of day (after 6 pm after long conference day) and that I was still jet-lagged. But enough whining now, here is the story and my learnings that hopefully will help me make better decisions in the future.

First out, I was going to enter the competition myself, but then I got to know Jay and Sandra and we formed Happy purples (even written in purple on the registration flip chart). It felt quite good to be a team instead of working solo on this. Especially since we had the Miagi-do all-star team on the table next to us, and they were plenty.The start of the competition could have been better. While we knew we were already crippled with having two computers in a team of three (with two iPads as complement), we thought we would be ok since we were told we would get a web-link to the software to test. Here was a first set-back when we realized that it was a Windows application to test on our two macs and iPads. Dual-booted Win XP worked for one of the laptops while my own Parallells Win 7 instance had not been running for a while and did not really want to cooperate.

It is important to set the stage in a group before starting solving a problem like this competition. I think our group would have benefited from at least some structure in our work, and I think during the heat of action we underestimated these needs. It is especially important to have some kinds of statement of work when being a group of more than two people. This was shown over and over in all activities we performed, yet we did not cope with it at all, i guess because of the stress and not realizing the need for it in the short term of the competition. We even observed the structured way the Miagi-do team set up their SBTM on flip charts.

About the worst bug report award

The two bugs mentioned by James are of course questionable. The tooltip inconsistency was actually filed with an assumption of consistency, but later we got to know from the developer that those type of bugs were not important. So, getting feedback on bugs from developer did actually change the type of bugs we filed later on, we improved. But it was still not possible to edit or delete already filed bugs.
On the "slow download of application under test"-bug, it is related to a discussion I had with Michael Bolton on my blog a while back. I would consider it a testability issue to not get the application delivered in a timely fashion. Especially if we were going to get more deliveries of it during the competition time frame. In retrospect, it might seem more rational NOT to make a bug report on this, but only include it in our final test report, as it delayed our testing quite a bit.

This post was also posted on my personal blog.

Jeannette Wing, CMU, Frontiers in Research and Education in Computing

Jeanette said that there has been a paradigm shift.

Not just about computing's metal tools (transistors and wires), but also our mental tools (abstraction and methods)

Is this really a new paradigm shift? Maybe for the National Science Foundation (NSF), certainly not for anyone that has been working with software the last ten years.

The limits of Moore's Law forces the NSF to focus on programming languages and abstractions.

Three drivers of computing research, Society, Science, Technology.

Encouraged research areas:

• Data Intensive Computing
• Cloud Computing

• Map-Reduce

• Cyber-Physical Systems (computational core that interacts with the physical world)

• Smart vehicles
• Smart Flyers

• Smart Devices

• Network Science and Engineering

• Understand the complexity of large scale networks
  • Software Engineering for the Next Internet

• Trustworthy Computing

• Socially Intelligent Computing

• Humans are still much better at image recognition

• Programs where the human is a port of the program.

• IT and Sustainability (Energy, Environment, Climate)

• Computer Science and Economics

• AdSense

• eBay

• Computer Science and Biology

Agile development: Overcoming a short-term focus in implementing best practices, Karthik Dinakar

In the project they concluded on the following good practices.

• Good version control
• Coding guidelines
• Build automation
• Unit testing framework
• Automatic sanity tests
• Accurate task estimations
• Effective pre-spring planning
• Solid design discussions
• Involve QA and Operations
• Effective post-sprint-reviews

They also thought that it is difficult to implement best practices under way.

They had many problems:

• Integration was not in the plan
• Sprint backlog changing all the time.
• Long sprint meetings

Management did not allow them to implement the changes that they needed and the reason was "It's Agile!"

All in all, their problems seemed to be the usual, they had no idea of what it meant to do Scrum in the first place. Don't people read books anymore?

Are systems Green? Panel with Steve Easterbrook et al

• A Google query has a Carbon footprint.
• We don't know what it is.
• It may actually be less than the energy it uses since it may permit the person posing the query to save a lot of energy.
• The term Green is just marketing bullshit.
• It is not measurable at all.
• Carbon Emissions are permanent.
• It won't go away even if we stop burning any carbon today.
• The goal of emissions are ZERO, anything else is not sustainable.

There is a book called Green IT for Dummies

• What can we as a computing industry do.
• Analyze the problem.
• Make a list of what we need and can do.
• Create a wiki.

If you are going to read an article for more than three minutes, YOU SHOULD PRINT IT OUT! Believe it or not, but check your facts.

Architecture in an Agile World, Panel with Steven Fraser et al

Randy Miller: We allow the customers to make changes, but we don't tell them what the cost will be. If we have no architecture the cost will be high. The people behind the agile manifesto were all good at architecture and that is why the importance of architecture was not emphasized in the manifest.

Bill Opdyke: Some people seem to see a difference between architects and agilists. But most people that are good don't have the this problem. Architects can learn from agilists that change is not that hard. Agilists can learn from architects that architecture matters. There is a middle ground.

Ethan Hadar: We need a stable vision of what the architecture should be while delivering solutions iteratively. Show me the architecture road map of your product, because it will be integrated with another program in nine months. Accountability and responsibility for the architecture is important.

Dennis Mancl: You need to plan architecture early, or you will have to do it later on and then it will be harder.

Audience: How does an architect work in an agile team?

Randy Miller: From an agile team, you're all part of the team. There are no distinctions. The architect is in the team to make sure that

The architecture in the system is the point in time in which you have to step back and think about how everything interacts.

Ethan Hadar: The architect is the person, who needs to interact with the testers and operations to explain how and why the system is the way it is.

Dennis Mancl: The architect is responsible to the stake holders and he is responsible to know the problem domain.

Irit Hadar: The architect's role is to take a step back and say when it is time to review the architecture.

Audience: The architecture is what you get, regardless of what you do.

An interesting discussion, that could not find a consensus to if there is a need for a single architect or not.

Agile Anthropology and Alexander's Architecture, Jenny Quillien, Dave West, Pam Rostal

Do we need to pay any interest of to Christopher Alexanders' new book The Nature of Order?

The software community has always taken interest in Alexanders' books, but we take interest in the wrong things. We have only understood some rules, we have not grasped the deeper part of it, because we don't understand the culture of architecture.

In a pattern language, we looked at patterns, but we dismissed the QWAN. We missed the holistic point-of-view. Everything is part of the system, people, organizations. He is writing about things that are multi-dimensional and multi-faceted, not things that are simple and exact.

The Nature of Order contains the same multi-faceted ideas and if we look at it with the same eyes, we will miss the point again.

Alexander looked at centers and centers affect other centers. And there is no right or wrong, there are only degrees.

In Alexanders' world there is only one system, the Universe. Everything is connected!

Writing Code for Other People, Tom Mullen

Chunking and Memory

• The mind groups memory into chunks. Most chunks are stored in long-term memory. Out conscious is in long-term memory.

Short-time memory can only hold about four relations. Short-time memory is also short This gives us a time-limit when traversing code.

Meyers' open-closed principle is an echo of the mind's way to learn things.

If the code is a reflection of our brains, then most brains contain spaghetti.

Analogies

Analogies is the mapping between one thing to another.

Conclusion

Our brains are not good a processing more than four chunks at the time. This implies that we should write methods with less than four lines. Classes with less than four methods, modules with less than four classes, and applications with less than four modules.

BDD in Java with easyb (John Ferguson Smart)

John started out by arguing that TDD is not about testing, it's about writing better code. That is, it's about making your code more maintainable, flexible, reliable and simple. TDD is forces the programmer to think about how to test the class before actually writing the class. BDD, on the other hand, helps to determine what to test and to write more focused code, by starting with the behavior. Instead of thinking that you're testing your class, you should think that you're validating your requirements!

easyb is a BDD testing framework for Java, written in Groovy (hence providing full access to all Java API's). It ensures that tests become clearer and easier to both write and read! It helps the developer to focus on the requirements only. A competitor to easyb is JBehave, which is an extension to JUnit. However, according to John, JBehave is more cumbersome than easyb.

easyb makes use of stories, much like the story cards in the Agile world. In a story, a narrative approach is used to describe a precise requirement. In easyb, a story could look like this:

 
scenario “Make initial deposit onto a new account”, {
	given “a new account”
	when “an initial deposit is made”
	then “the balance should be equal to the amount deposited”
}
 

This scenario is quite clear and readable, isn't it!? Furthermore, it's self-documenting - a very appreciated feature =) And the syntax is so trivial that even a non-technical stakeholder would have no problem understanding it. The developer can then reuse the given scenario (pseudo) code and implement the test case, like this:

 
import com.mycompany.bankonline.domain.Account
 
scenario “Make initial deposit onto a new account”, {
	given “a new account”, {
		account = new Account()
	}
	when “an initial deposit is made”, {
		initialAmount = 100
		account.makeDeposit(initialAmount)
	}
	then “the balance should be equal to the amount deposited”, {
		account.balance.shouldBe initialAmount
	}
}
 

The shouldBe call is an intuitive and readable way to verify that the requirement holds. Another way to verify the outcomes is to use the ensure syntax. Example:

 
ensure(account.balance > 0)
 

or

 
ensure(account) {
	has([balance:100])
}
 

easyb could be extended to use DBUnit (and further plugins for Grails and Excel are on the way). On the IDE support, the only good option is IntelliJ IDEA. It really comes down to the Groovy support, and Eclipse and NetBeans doesn't shine here. In those cases, you're better off running the tests in Maven or Ant, which both are well supported. In the upcoming version, easyb will have full support for Continuous Integration (CI), enabling automatic test execution in a CI-server such as Hudson.

Furthermore, easyb comes with a web application - Easiness (cmp. Fitnesse) - where stakeholders can create stories in plain text. The developers can then go ahead and implement the stories defined by the stakeholders. This is an important features, that further improves the cooperation between the customer and the provider. It really seems like a quite nice little framework! If you agree, have a look at it at http://easyb.org/.

From Concurrent to Parallel – Library-based parallelism in JDK 7 (Brian Goetz)

Brian is an expert in the concurrency area, but he's not a good presenter! He speaks faster than I can read, and his slides are so packed with info that he doesn't have time to say the half of it. That put aside, in this very interesting session Brian presented some really cool concurrency features to be included in JDK 7.

As you probably know, JDK 5 introduced a set of very useful classes for course-grained parallelism. JDK 7 will introduce a framework for fine-grained parallelism - the "fork-join" framework.

We have now reach a point in time when Moore's laws isn't valid anymore. The new reality is not faster CPUs but more CPUs. To adapt to these changes, programmers have to change the way they think about parallelism. The unit of work (UoW) that represents a task to be solved must be split into even smaller parts to be able to keep all hardware busy. Nowadays, it isn't enough to for ex. spawn a new thread for each service call in a server, the UoW must be split up even further.

Examples of finer-grained parallelism is searching, sorting and filtering a data set. Such a task is preferably solved by dividing it into sub-problems and combining the sub-results at the end. We could use the course-grained concurrency tools (for ex. Executor + Future) introduced in JDK 5 to solve this problem. However, with multiple CPUs available, these tools doesn't perform optimally. For ex., the shared work queue in the Executor becomes a bottle neck when the number of threads/CPUs increases. Furthermore, these tools provide no form of load balancing, i.e. if one thread finishes before the others, it is never reused.

The divide-and-conquer algorithm could also be applied to solve the problem. This great advantage of this approach is that it's independent of the number of CPUs used! Using plain threads for this approach is too expensive though, since thread creation costs way too much. However, the fork-join-operation in JDK 7 solves problems like these using the divide-and-conquer algorithm in a much more effective way! Internally, it uses an slim thread pool to overcome the cost of thread creation. Furthermore, no data-copying penalty exist since the data set (for ex. an array) is not divided/copied during the solution. Instead, the indexes within the data structure is used to define each data subset. Another advantage is that the code doesn't know how many CPUs it executes on, hence it's portable!

While the Executor (JDK 5) should be used for tasks consisting of both IO and computing, the fork-join-operation (JDK 7) should be used for highly compute-intensive tasks. Examples of such tasks are matrix operations, numerical integrations and game playing. The JDK 7 class to be used for these kind of problems is ParallelArray. It's a utility class that greatly simplifies the work of solving a task in parallel. You can think of it as an in-memory database for data sets. Typical usage is:

 
ParallelLongArray pa = ParallelLongArray.createUsingHandoff(array, forkJoinPool);
long max = pa.max();
 

The ParallelArray class provides operations for:

• Filtering (nestable)
• Mapping
• Replacement
• Aggregation (max, count, sum, ...)
• Application (one action performed for each selected element)

To compare, the ParallelArray class acts much like the Map-Produce concept introduced by Google but it works in a different domain (local system instead of in a distributed system).

The only downside really is that JDK 7 isn't scheduled until mid 2010, meaning we'll have to wait quite some time before we can actually use these new concurrency features. But from the looks of it ... it may be worth the wait!

The SpringSource DM Server (Joris Kuipers)

The reasons why SpringSource decided to develop a new application server were many. Today, modularity is important and developers spend much time on achieving it in their applications (layering, separation of concerns, etc.). However, when the application is deployed, all modularity is lost - the deployable unit is one huge, monolithic WAR file. That means that sharing code (let alone services) between applications become hard if not impossible. In order to perform the smallest update on the application, whole WAR file have to be redeployed. Furthermore, the servers themselves lack modularity; they come prepackaged with a lot of modules but there's no way to configure that your application only make use of a couple of them. Hence, they are all left in there, consuming unnecessary CPU cycles and memory.

The DM (Dynamic Modules) server was developed to tackle these issues of non-modularity. In order to achieve true modularity, is has been built on top of OSGi (namely the Equinox container). Since OSGi can be quite hard sometimes, the DM server conceal the complexity of OSGi in the same way as the Spring framework does with for ex. Remoting or JMX.

In order to be able to use a third-party library from within the DM server (and from any other OSGi containers), the standard JAR library needs to be extended with OSGi-specific meta data - the OSGi manifest. SpringSource has therefore created the Enterprise Bundle Repository, where they have started to upload and publish OSGi-ified Java EE libraries. If you're using Maven or Ivy, the bundle repository can easily be configured as a remote (or local) repository.

The DM server also introduces a couple of new OSGi import constructs, enabling ease of development. One example is the "Import-library" that can be useful if you want to make use of a framework (for ex. Spring) but don't want to waste your time having to specify every single Import-package (for example Spring-Remoting) within the framework (as you normally would have had to do). This doesn't affect performance improvement since (thanks to OSGi) none of the pre-installed bundles are loaded before they are actually used! Furthermore, with the DM server it's now possible to remove the library bloat of monolithic Java EE WARs. Instead of building the external libraries into your WAR, you can instead declare them as dependencies in the OSGi manifest headers. The server will then convert these into plain "Import-package" constructs during deployment. That way, the size of the built/deployed WAR can be reduced significantly!

In the DM server, one can of course deploy plain OSGi bundles but also WARs, EARs etc. Typical scenarios for deploying a plain OSGi bundle are stand-alone libraries, global services and small stand-alone applications. However, being able to deploy a bundle is not enough in most cases ... A normal application normally consist of multiple bundles, which becomes hard to un/deploy since there is no single deployable unit. Furthermore, with multiple bundles you don't get a common log file or a notion of an application scope. To tackle this issue, the DM server adds the notion of an application by introducing the PAR (Platform Archive) format. It's basically a JAR with a number of 'Application-*' manifest headers. You can think of it as an EAR in Java EE. PARs are versioned and the versions apply to all of their bundles. This mean that one can deploy a PAR twice with different versions but with the same bundles, without conflicts.

The DM server comes in several versions. Of course there's the community version, using a GPL and SpringSource license. Then there's the commercial license where full support from SpringSource is included. On the extension side, better Maven support will soon be released so that the dependencies can be specified in a single place (not like now when you have to duplicate them in the pom and in the manifest). There's a Eclipse-plugin available that enables re/deployments from within the IDE.

These are some of the features in the DM server. There are plenty or more cool ones, read all about them here. There, you'll also find a lot of sample applications that can get you going! With the DM server, SpringSource feel that they are filling the (up until now) empty space of server side OSGi and states that "The DM server is the healthy new way to run your apps!". I must say it looks very promising! Why don't you go ahead and try it out!? I know I will!

If you appreciated these posts, you will definitely enjoy next years conference! Pick up your calendar and reserve December 2009 for a great week at Devoxx!

Guy Steele pointed out that what is good practice for sequential programming might be very bad practice for parallel programming. For example in parallel algorithms you want to limit synchronization and avoid communication between parallel computations and therefore it is ok to use more memory and more CPU cycles to avoid this. Erik Meijer tried to brainwash us all to use Haskell, and succeeded in some ways as people started talking about monads and IO all evening.

Gregor Hohpe talked about what Google is doing to create extremely scalable systems. He talked about a new definition of ACID in cloud computing. Associative (the order the operations are combined is not important), Commutative (order of execution is not important), Idempotent (when an operation is executed multiple is has the same result every time) and Distributed. He also recommended Pat Helland's excellent paper on near infinity scalability.

Another cool presentation was Michele Lanza's code visualization tools based on ideas around iconic memory, ie that you should be able to immediately understand and see what is going on. Check out CodeCity and X-Ray.

The Conference

During the last three years, Øredev has grown from a promising initiative to one of
the biggest IT-conferences in Scandinavia. During this year’s event, over 800 visitors
attended more than 100 events. To handle the increasing crowd, the conference was
held at a new location, MalmöMässan, which offered bigger and better conference
halls and more space for the show floor.
The location also offered a lack of heating in some rooms, which in the Swedish
November weather translates into cold conference halls. People kept chugging cof-
fee to keep warm, and everybody wished Oracle would hand out blankets instead
of bottle chillers.
As many as nine parallel tracks were available this year. Back from last year were:
Java, .NET, Methods & Tools, etc. In addition to these, Øredev 2007 offered several
new tracks such as Architecture, Case Studies and more. Especially refreshing were
the User Experience sessions, an important yet often overlooked topic.
Further indicating the growing status of the conference was the number of no-
table speakers that participated this year. The list included big names such as Andy
Hunt, Joel Spolsky, Kevlin Henney, James Coplien, Dan North, and Dr. Jeff Suth-
erland.
At the exhibition floor 26 companies were fighting for the visitors attention. The
innovation in terms of advertising varied ranging from plain old booths with posters
and free pens to elaborate coding competitions with iPods to win.
In spite of being an IT conference, there was only one robot on the show floor,
the SMErobot from Lund. Completely implemented in Java the robot was solving
sudoku and carving in wood taking it’s instructions from a piece of Anoto paper. As
a request for new functionality we would like to see the robot performing massage.
Should not be too hard to implement, considering that the platform is Java based.

The keynotes

Being a keynote speaker is always special. There are high expectations of both vi-
sions and entertainment. Being recognized in the business, you would better have a
good presentation up your sleeve. Although some of this years speeches contained
more wittiness than visions, there were three enjoyable keynotes to listen to.

Andy Hunt: How hard can it be?

Andy Hunt is well known as one of the 17 founders of the Agile Alliance and the
co-founder of the Pragmatic bookshelf.
During his opening keynote, Hunt asked the audience the infamous question
“How hard can it be?”. He answered the question himself by stating that there are
two different types of complexity, namely essential complexity and accidental com-
plexity. Essential complexity is the complexity required to do a job. It is something
that we all have to live with, some things are hard to achieve by nature. Accidental
complexity or unnecessary complexity on the other hand is something that is arti-
ficial. It should and can be prevented if it is recognized accordingly. There are many
possible reasons for accidental complexity; prejudices or ignorance, stress or lack of
motivation or even just bad luck. Regardless reason, the recipe to avoid accidental
complexity is always the same: rely on reliable things, make a purposeful plan and
stick to it.

Dan North: No Best Practices: Methodology for thinkers

Dan North is a renowned speaker from other conferences like JAOO, Agile and
OOPSLA in topics like learning theory and behaviour-driven design. The keynote
North gave at Øredev showed he has a rightful reputation.
As the title indicates, the main mantra in North’s presentation was that there is
no such thing as best practices. As he presented this theory the feeling was similar to

the scene in Dead Poet’s Society where the teacher asks his students to rip out the
first chapter of their text books.
As a basis for his claim, North explained the Dreyfus Model of Skill Acquisi-
tion. The Dreyfus Model is in itself an interesting topic and describes five different
stages in learning: Novice, Advanced Beginner, Competent, Proficient and Expert.
The novice is the stage of an absolute beginner who relies on rules and guidance to
be able to function whereas the Expert works based off intuition and knowledge at
the subconscious level that has been gathered through many years of work. The in-
teresting part is that the efficiency of people at the expert level is severely reduced if
they are bounded by the safe environments such as a “best practice” that the novice
needs. Best practices are in other words obstructing the people who are the best, the
experts, from doing their job effectively.

Joel Spolsky: Developing Great Software

Joel Spolsky has reached his biggest audience through his website joelonsoftware.
com. He is the founder of Fog Creek Software and has created FogBugz, a popular
project management system.
Ten seconds into his seminar, Spolsky immediately showed that he belongs to the
rare selection of people that knows how to make a powerpoint presentation that is
more than just a bunch of slides. As Spolsky brought up a huge picture of Victoria
Beckham on the first page, you knew that you were in for a treat. The topic of the
speech was the importance of good looking software.
Spolsky argued that no matter how good your software is, you will not reach
mass market unless it looks good. He illustrated this through various comparisons
of popular products. Particularly entertaining was the part where he brought up a
Windows XP simulation created entirely within the powerpoint presentation. One
could argue whether that was a good example to bring up in the context of his
speech. Windows is a product that doesn’t necessarily look good compared to one
of its main competitors (OS X), yet has a vastly larger market share. Nevertheless,
the display was impressive and produced lots of laughs from the audience as Spolsky
struggled with various pop-ups and failures in his powerpoint-driven “Windows”.
Even though his presentation clearly was more about entertainment than anything
else, he managed to state an important point: software needs to look good to suc-
ceed!

Sharing knowledge

Besides the keynotes the real knowledge sharing was made in the around 80 semi-
nars and in the exhibition hall.
Following the Java track we witnessed the official launch of the Qi4J framework,
introducing Composite Oriented programming, redefining the way we use OOP
today. The new concepts that Qi4J bring are not obvious, even to somebody with
extensive Java experience. We are hoping that Qi4J for dummies will turn up in our
local book store soon.
We also got a first glimpse of Java FX Script, the new GUI framework from
SUN. It has been developed to provide an alternative to the clunky looking Swing
interfaces. Although not yet mature, it is meant to compete with technologies like
Flash and Silverlight.
Another interesting seminar was delivered by Neo Technology, showing us a new
and faster way to store data. Briefly, they have implemented a database using a net-
base, i.e. networks in Java rather than database tables. During the presentation, they
performed a simulated Facebook relation search outclassing a traditional database
by the magnitude of a million.
Identifying some of the trends using Java as a platform rather than as a language is
becoming big. More lightweight languages and scripts such as JRuby on Rails make
use of the Java platform. Domain Driven Design and Web 2.0 (still) were other buz-
zwords that floated around in the lecture halls. As always at Øredev there was a big
focus on open source. The business is changing more towards using and developing
open source frameworks incorporating community thinking into their development
process. There were several seminars that both presented new functionality within
existing frameworks and showed smart ways of using existing technologies. One
example was the demonstration of the new batch framework in Spring.
Sitting in on some of the test and project management seminars a couple of key-
words emerged over and over again, namely “agile” and “test driven”. Even though
most people know that these methods increase productivity and quality of the code,
a quick audience survey showed that there are still few development teams that
actually have incorporated these into their processes. Apparently, it is still tricky to
convince your boss that agile development actually does bring huge winnings.

Evening activities

After a full day of new knowledge, inspiring lectures and networking the stage was
taken by the UK stand-up comedian Shazia Mirza. Mirza is a highly acclaimed co-
median and a columnist for the New Statesman. She was recently profiled on CBS
‘60 minutes and has performed all over Europe and USA. Mirza put on a great show
not being the least shy or politically correct, even though she was, as she put it, “the
only Asian woman amongst 600 computer nerds”.
Some great laughs later it was back to business with late evening “Birds Of Feath-
ers” (BOFs), making full flown eagles out of the feathers of knowledge we had been
given during the conference. Some of us joined Owen Taylor at Gigaspaces, making
a complete Gigaspace storage run on our laptops. We were given a chance to try
out this new technology together with one of it’s creators, enabling us to bring the
installation back home for further experiments and tests. We got (and still have) a
good possibility to look under the hood of the magic this product brings, at least that
is promised by Taylor.
For the people that had enough of birds and feathers there was more entertain-
ment from our own band Rockway.

Workshops

There were many that sought a hands-on experience with the material that was
presented during Øredev, and all participants were given a chance to follow up the
lectures with a variety of workshops. The most popular one was the full Scrum certi-
fication course held by Dr Jeff Sutherland, one of the main creators and preachers of
the Scrum methodology. Another popular workshop was a full day of Qi4J training
allowing programmers to try out the newly launched framework. Andy Hunt also
followed up his lecture on refactoring wetware, i.e. the human mind, with a three
hour workshops, allowing the participants to try out some of the concepts that will
increase productivity and make more efficient use of our brain cells. Hunt presented
a bunch of mind tricks that would have come very handy earlier in the conference.

Finally

The yearly Øredev conference is a source of inspiration to an increasing amount of
people. As an employee in the IT sector it is a great opportunity to get access to all
the knowledge presented at the conference, get hands-on with new technologies
and share the visions of some of the biggest names in the business. We tend to spend
more and more time behind our screens, teaching ourselves new tools, technologies
and reinventing the wheel. With Øredev there is a possibility to meet like-minded
people, share experiences and last but not least, to network. Adding new contacts on
your favorite social website is an important goal as any.
Besides the large amount of participants attending there is an increasing number
of exhibitors from all over the world. Be sure to sign up for next year, because the
conference will keep on growing, not only in the number of participants, but also
in importance. There is no better way to keep up to speed with the ever changing
market. Hopefully, the heat will be switched on in all seminar rooms by then.
Until next Øredev...

Stefan Li, Jakob Klamra, Mattias Severson

Originally published in JayView.