J and I and Me

JAX Preview

2013-04-08T11:14:00.000+02:00

This year's JAX will see some interesting sessions that I would like to highlight:

The New School Enterprise IT Day will show how new technologies and business challenges will change the Enterprise IT. I am quite happy that this has been added to the JAX schedule - because I believe there will a huge shift in this area in the next few years.
The Cloud Computing Day will show the latest and greatest in the Cloud. Several topics - such as the different Java PaaS alternatives but also IaaS will be explained in detail.
I have done several Code Retreats at adesso AG and always found them to be a great experience for all involved. Therefore I am pleases that I can do a Code Retreat at JAX this year.
And of course the Advanced Spring Powerworkshop will take place - it is a unique opportunity to dive deeper into the framework.

Some of my colleagues are also presenting. For example Alexander Frommelt will talk about IT landscapes and also about Portals and whether Portlet are really a good fit for them. Halil-Cem Gürsoy will talk about Google App Engine. So I am really looking forward to the event - and would be glad to meet you there!

Common Misconceptions: The Waterfall Model

2012-05-08T09:42:00.000+02:00

I think the Waterfall Model is the result of a big misunderstanding, probably one of the worst in out industry.
Look at Royce's original paper (PDF can be found here. You will notice that the paper starts with the separation of different activities such as analysis and coding. To me that sound like an attempt to actually define basic software engineering activities instead of just unstructured hacking. The paper goes on and discusses more different phases that a project might go through. It shows a figure pretty much like the Waterfall model we are used to. No surprises so far.
But then the fun starts: The third figure already shows that the steps are not necessarily performed in order. The text says:
... as each step progresses and the design is further detailed, there is an iteration with the preceding and succeeding steps but rarely with the more remote steps in the sequence.
Let me repeat: The original Waterfall paper says that you might need to go back to previous steps, even remote ones. It even uses the term "iteration".
It goes on and discusses that once you run in production you might learn that your system does not perform well enough. That leads to major problems - and you will probably go back to the analysis. You might call it an iterative approach - even though it is probably not voluntarily.
Even better: The paper suggests:
If the computer program in question is being developed for the first time, arrange matters so that the version finally delivered to the customer for operational deployment is actually the second version in so far as critical design / operations areas are concerned.
So essentially you should do at least two iterations - the first version will not get it right. Another hint at an iterative process.
And the paper even suggests to involve the customer - probably one of the most important points in Agile practices.
Of course the paper includes sections that are quite different from the Agile school - such as the focus on documentation. But it is from 1970 - and the author is specialized in systems for spacecrafts. Those still rely a lot on documentation even today because of the extreme risks those systems have.
However, the bottom line is that the original Waterfall paper does not advocate what is now considered the Waterfall Model. It does not require going through the steps in order and it even mentions that the first release will not be a good solutions. Quite contrarily: It talks about iterations - very limited of course but it hints the direction Agile and iterative processes took later on.
I am still confused how the industry was able to misunderstand this paper. I wonder how much damage it did. Even today people still talk about Waterfall. I think everyone working with software processes should read this paper. I also suggest to use the term "Misunderstood Waterfall Model" when discussing a model that suggest going through the steps in a strict order. Because that model is just a misunderstanding, it is not what Royce described.
Oh, and next time someone talks about the Waterfall Model - don't forget to ask him or her whether he has read the original paper about it...

Some Possible Enhancements for Java and Java EE

2012-04-17T14:56:00.000+02:00

The recent discusssion about Java EE and Spring made me think. Actually I find it odd to fight over the programming model used to develop Java applications. Neither Java EE nor Spring will go away - the market shares of both are just too large. At the end everyone involved in the discussion is trying to sell a platform i.e. an application or web server. That product must offer good support for both programming models - and all the others like Scala, Groovy etc. IMHO the programming models have a lot in common now. Spring also covers advanced challenges like Social Media, NoSQL etc - see my older blog post Spring vs. Java EE and Why I Don't Care. So it is not in the field of programming models where innovation is laking. Instead we should focus on improving the platform. So what is it that would really make Java a better platform? Here are some ideas:

Ever since the invention of Java EE roles like the Application Assember were defined. I never saw a project that followed this workflow. Nowadays there is just an automated process that results in an EAR or even a complete setup including an application server. It is time to face this reality and get rid of these role descriptions. The deployment process is not done that way. Java needs to step away from it.
Nowadays application server are seldom used to host more than one application. So maybe that offers some possibilities to improve the deployment processes and also the features. If there is just one application on a server anyway the strict isolation between applications Java EE offers does not make that much sense any more.
It would be good to focus more on deployment during the development process. Applications are much more often deployed into testing or development environments than into production. I am wondering how many CPU and I/O cycles are wasted compressing WARs and JARs and then EARs during a build process - and immediately decompressing them on the web or application server so testing can start. Can't the Java EE standard do something about this? Obviously there are exploded WARs and EARs - but they are not used as often as they should be. Obviously there are tools like JRebel and Play - but what if the complete tool chain including IDEs, build tools, servers etc would support a standard here? What if all of those parties could collaborate to make this work flawlessly? I think we would see quite a boost in developer productivity.
Often I see applications modularized in several WARs. These modules need to talk to each other. However, there is no easy way to do this. Usually they end up using Web Services or another HTTP based protocol. Compared to a local method call this adds the overhead of HTTP, sockets and marshalling / demarshalling. A possible solution would be OSGi - but that technology is quite complex. The reason to me seems to be the problems around shared class loading. Classes that might represent parameters or return values can be shared between modules. JBoss includes a solution based on JMX that did not support shared classes - so modules need to have the correct classes available. This is the same as for Web Services or the other HTTP protocols. But there is no standard apart from JMX - which is very low level. Can't we have some communication between WARs that in the standard? Maybe based on JMX? Or at least best practices around it?
Concurrency in languages like Erlang is very different from what we are used to in Java. There are actors that work on a serial list of messages. Concurrency is achieved by multiple actors working in parallel - while the actors themselves are just working serially. This approach is also used by the Scala library Akka on the JVM. In Erlang this approach leads to lots of actors - far more than the number of threads that can be supported on the JVM. If the JVM wants to stay relevant for this model we need proper support for it.
Actors in Erlang and in Google Dart - they are called Isolates have separated heaps. Those heaps can be independently GC'd - so while one actors spends time doing GC the other can continue to work on messages. By design you end up with less stop-the-world-GC. Maybe we could have a similar concept in Java? This is an extension of the previous suggestion but there might be other options as well. For example each WAR file could have a separate heap.

Those are just some - possibly crazy - ideas. My intention is to focus on making the Java platform better for all of us. And I believe for that the discussion around the future of Java must focus more on the JVM and the infrastructure like web or application server than on programming models. There is quite some innovation in the area of the programming models anyway. For example there are lots and lots of Open Source projects - frameworks and complete languages. But for infrastructure standards are needed - so any server and environment can work with the solution. So that is what the standardization process should focus on. What do you think? I am looking forward to your comments!

Testing: Again

2012-04-02T16:26:00.001+02:00

As you have probably noticed, the last blog posting Testing Considered Harmful was actually a April Fool's Joke. I believe Test Driven Development is one of the most important innovations in the last years. I have been infected ever since Kent Beck explained JUnit to me. Here are some things adesso does to make TDD a reality:

We did an internal Code Retreat
We are sponsoring the Legacy Code Retreat in Berlin.
Also adesso Mobile Solutions does internal Katas.

The list could go on. So please program - and drive - safely! If you were caught by the April Fool's Joke: I hope you don't mind. If you do: I apologize.

Testing Considered Harmful

2012-04-01T13:04:00.000+02:00

Unit testing started with JUnit - and was infectious. As you can see in JUnit Test Infected: Programmers Love Writing Tests that was the intention from the very beginning. And so the infection spread.

Nowadays almost all programmers do extensive Unit Tests. And therefore we see problems arising. Instead of thinking about a problem and building a reliable solution developers now just write a test and code away. At one point they get a green bar and consider the job done. But can you build proper software that way? Dijkstra stated in 1972: "If you want more effective programmers, you will discover that they should not waste their time debugging, they should not introduce the bugs to start with." - see Wikiquote. I think the same holds true for testing. So instead of the ever famous code-test-refactor cycle we could use more of the Feynman Way of Solving Problems. If you really think about the solution first you will find you won't need a test. Instead you will actually write correct code from the beginning. You won't need to rely on tests. They cannot show the absence of bugs anyway - as Dijkstra mentioned. In the end you will end up with cleaner code and less code - as there are no tests to be written.

This principle can be applied to other areas as well. I think one reason why there are so many car accidents are the very effective brakes cars have now. If we had less effective brakes people would think about possible problems beforehand, drive more carefully - and we would have less accidents.

Dangerous Code Example in EJB 3.1 Spec

2012-02-06T16:33:00.000+01:00

I am currently working on a training concerning Java EE Best Practices. For that reason I am reading through quite some material about Java EE and EJB. However, looking at the EJB 3.1 spec I realized that the code examples are an example of rather bad coding practice. As an example here is the original code from EJB 3.1 Spec p. 348. It is supposed to show how UserTransactions can be used: @Stateless @TransactionManagement(BEAN) public class MySessionBean implements MySession { @Resource javax.transaction.UserTransaction ut; @Resource javax.sql.DataSource database1; @Resource javax.sql.DataSource database2; public void someMethod(...) { java.sql.Connection con1; java.sql.Connection con2; java.sql.Statement stmt1; java.sql.Statement stmt2; // obtain con1 object and set it up for transactions con1 = database1.getConnection(); stmt1 = con1.createStatement(); // obtain con2 object and set it up for transactions con2 = database2.getConnection(); stmt2 = con2.createStatement(); // // Now do a transaction that involves con1 and con2. // // start the transaction ut.begin(); // Do some updates to both con1 and con2. The container // automatically enlists con1 and con2 with the transaction. stmt1.executeQuery(...); stmt1.executeUpdate(...); stmt2.executeQuery(...); stmt2.executeUpdate(...); stmt1.executeUpdate(...); stmt2.executeUpdate(...); // commit the transaction ut.commit(); // release connections stmt1.close(); stmt2.close(); con1.close(); con2.close(); } ... } What is wrong with this code? Well, first of all it does not compile. Quite honestly I wouldn't really care too much about that - an example is fine as long as the important point is still brought across. But in this case it does matter as we will see later on. So here is what the method should read like: public void someMethod() throws SQLException, NotSupportedException, SystemException, SecurityException, IllegalStateException, RollbackException, HeuristicMixedException, HeuristicRollbackException { In the original example any code concerning Exceptions has been left out. So what happens if an Exceptions is thrown? No close() is ever called and therefore none of the resources are ever cleaned up. Let's fix this: @Stateless @TransactionManagement(TransactionManagementType.BEAN) public class MySessionBean { @Resource javax.transaction.UserTransaction ut; @Resource javax.sql.DataSource database1; @Resource javax.sql.DataSource database2; public void someMethod() throws SQLException, NotSupportedException, SystemException, SecurityException, IllegalStateException, RollbackException, HeuristicMixedException, HeuristicRollbackException { java.sql.Connection con1 = null; java.sql.Connection con2 = null; java.sql.Statement stmt1 = null; java.sql.Statement stmt2 = null; try { con1 = database1.getConnection(); stmt1 = con1.createStatement(); con2 = database2.getConnection(); stmt2 = con2.createStatement(); ut.begin(); stmt1.executeUpdate(""); stmt2.executeQuery(""); stmt2.executeUpdate(""); stmt1.executeUpdate(""); stmt2.executeUpdate(""); ut.commit(); } finally { if (stmt2 != null) try { stmt2.close(); } catch (SQLException ex) { } if (con2 != null) try { con2.close(); } catch (SQLException ex) { } if (stmt1 != null) try { stmt1.close(); } catch (SQLException ex) { } if (con1 != null) try { con1.close(); } catch (SQLException ex) { } } } } This is the infamous try-catch-finally-try-catch block. The null checks actually avoid calling close() on objects that have not been created - as the creation might already have failed and and exception might have been thrown. As the close() operation might throw an exception this also needs to be handled. IMHO it is OK to swallow the exception - there is not really anything that can be done as the resources are already being closed. Using Spring's JdbcTemplate would have avoided the problem as the resource handling is done by the template then. I would strongly recommend it in code like this. It can be used independently from the other parts of Spring - e.g. Dependency Injection can still be done by Java EE. See http://static.springsource.org/spring/docs/3.1.x/spring-framework-reference/html/jdbc.html#jdbc-core for details. Now there is another thing that is still not OK - actually the most important point. The UserTransaction is never committed nor rolled back if an exception occurs. Let's fix this, too: @Stateless @TransactionManagement(TransactionManagementType.BEAN) public class MySessionBean { @Resource javax.transaction.UserTransaction ut; @Resource javax.sql.DataSource database1; @Resource javax.sql.DataSource database2; public void someMethod() throws Exception { java.sql.Connection con1 = null; java.sql.Connection con2 = null; java.sql.Statement stmt1 = null; java.sql.Statement stmt2 = null; try { con1 = database1.getConnection(); stmt1 = con1.createStatement(); con2 = database2.getConnection(); stmt2 = con2.createStatement(); ut.begin(); stmt1.executeUpdate(""); stmt2.executeQuery(""); stmt2.executeUpdate(""); stmt1.executeUpdate(""); stmt2.executeUpdate(""); } catch (Exception ex) { ut.setRollbackOnly(); throw ex; } finally { ut.commit(); if (stmt2 != null) try { stmt2.close(); } catch (SQLException ex) { } if (con2 != null) try { con2.close(); } catch (SQLException ex) { } if (stmt1 != null) try { stmt1.close(); } catch (SQLException ex) { } if (con1 != null) try { con1.close(); } catch (SQLException ex) { } } } } So when a problem occurs the transaction will now be marked as rollback only and ultimately rolled back. If there is no exception it will be committed. I hope I made no further mistakes in the code - let me know otherwise. In Spring resource handling is done for you by the Templates and therefore I might be doing something wrong here. Using that approach would also have made the code a lot less complex. So why this blog post? Bad resource handling and transaction handling is far too common. I have done a lot of reviews and usually Enterprise Java applications fail to do a good job in this regard. This is dangerous, because

The whole point of transactions is to provide safety if something goes wrong. If you do not commit nor roll back the transaction it will be left in an undefined state and all kinds of things might happen. This is compromising the safety of transactions. So the transactions become more or less useless. You might as well just not use them at all.
Not closing connections and statements will eventually lead to resource leaks e.g. connection pools running out of connections. This will at one point make the system fail.
These problems are hard to detect - they will only surface if exceptions are thrown. So finding and eliminating the problem is complex. You should rather get it right from the start.

Sadly the EJB spec seem to do resource handling constantly wrong. The EJB spec is not the only document that does resource and transaction handling wrong. Quite the contrary: I have a read a lot of tutorial and other documents that get this entirely wrong. However, IMHO at least the example in the spec for using the UserTransaction should show how to use it in a bullet proof manner. This document is read by many developers and other authors. Bad practices in such a document might end up in a lot of code and other publications.

Random Thought about Google Dart

2011-11-08T09:31:00.000+01:00

Here are some thoughts about Google Dart and its possible usages. They are just wild ideas, I have no information whether they will actually be implemented or whether they are shared by anyone at Google:

Compiling Dart into JavaScript is a good idea. It means Dart is immediately usable on any platform. There is no other way to quickly get it out to so many developers. Users are not quickly to switch to new browser - think about IE6.
I originally expected that a Plug In and VM for Dart on Chrome would be released quickly. Now I think that would have been a bad idea. Chrome would have had a good support for Dart while the rest of the browsers would have been left in the cold. They would probably not use the Google VM - remember that they also have their own JavaScript VMs. It is also unlikely that they would create their own Dart VM. So the current approach create a level playing field and makes it more likely for Dart to succeed.
I think the Dart VM might be an option for Android - maybe not in the near term but probably in the long run. Also it might be enough for Google to have an alternative VM. It just means it has a stronger position if a deal with Oracle must be closed.
Dart is a good fit for Google App Engine (GAE). Isolates have just one thread - that is also what Google App Engine enforces. That has the advantage that GAE can restart isolates. Isolates can be snapshotted and migrated to other VMs - which is great if you want to react to different load by offloading work from a machine. Isolates can only communicate via ports - that allows you to minimize dependencies to the outside. Again that is great if you want to restart or migrate Isolates. It might also be a way around the limitation that GAE won't allow you to open sockets. Java without Multithreading and without the possibility to open sockets is hard and no fun - and that is why I believe Java on GAE ist not that great. This changes dramatically if you use Dart.

So we will see where this is headed. Remember the first days of Java: It was seemingly all about Applets. Now it is all about the server. Technologies might succeed in other areas than originally planned. If you are new to Dart - here is a presentation about Dart:

Google Dart

View more presentations from Eberhard Wolff

Spring and Scala

2011-11-01T11:14:00.002+01:00

Scala is an interesting language that appeals to a lot of Java developers as it is statically typed - just like Java. However, Scala focuses on concurrent processing. The choice of frameworks for typically bread and butter issues that you see in Enterprise applications is rather limited. For that reason it makes sense to look at Spring as a very mature and established Java Enterprise technology and whether it can be used with Scala. So here is a presentation and some sample code:

Scala and Spring

View more presentations from Eberhard Wolff

https://github.com/ewolff/scala-spring

adesso Now On slideshare

2011-09-26T11:26:00.000+02:00

My employer adesso AG is now on slideshare: http://www.slideshare.net/adessoAG/ . Most of the presentations are in German. There are quite a few already and of course there are more to come. I thought I would show three presentations here on the blog. The most popular so far is about security and JSF (German):

OWASP Top 10 : Scanning JSF

View more presentations from adessoAG

Then there is this one about memory and performance analysis in Java - something I think every Java developer should understand (German) :

Mist gemessen? Java Performance und Memory Analyse

View more presentations from adessoAG

And this one about Requirements Engineering (German) :

Eine kleine praktische Philosophie über das Requirements Engineering

View more presentations from adessoAG

PS: Of course there is still my personal slideshare account with English presentations at http://www.slideshare.net/ewolff/

Cloud PowerWorkshop at WJAX

2011-09-08T10:30:00.000+02:00

This year at WJAX me and my colleagues Halil-Cem Gürsoy, Andreas Hartmann and Stephan Müller from adesso will present the Cloud Power Workshop for the first time. It will cover everything you need to know to implement application with Java for the Cloud. We will cover Google App Engine (GAE). It pioneered the PaaS Cloud approach and is quite broadly used nowadays. At the same time GAE has some limitations that you need to know about to successfully build application on the platform - in particular if you use Java. Then Cloud Foundry will be shown - it provides a very interesting approach to PaaS - because it supports relational databases and Tomcat which is quite a familiar platform for most Java developers. To develop Cloud applications successful you need to use novel architectures. We will cover principles like BASE and the CAP theorem. And we will show how to implement Cloud system with good scalability using RabbitMQ and a NoSQL database. Also Map/Reduce using Apache Hadoop will be demoed. Of course there will be lot of live coding and material to take away so you can try it at home. Take a look at the official announcement (German) - looking forward to see you there!

Keynoting ECSA 2011

2011-08-04T18:57:00.000+02:00

I feel honored to keynote with the subject "What Does it Really Mean to be an Architect?" the 5th European Conference on Software Architecture (ECSA 2011) in Essen, Germany. The conference takes place from 13-16 September 2011 to discuss the latest research and experiences in software architecture.

The range of topics includes service and component architectures, quality attributes of software architectures, product line architectures, management of architectural decisions, and enterprise architecture. Workshops on traceability and dependencies in software architecture, as well as software architecture variability, provide further opportunities for in-depth discussion.

Each day, keynote speakers from academic and industrial backgrounds will discuss perspectives on current trends and challenges in software architecture. The other keynotes are:

Interactive Ubiquitous Computing Systems (Albrecht Schmidt, University of Stuttgart)
Software Analysis as a Service (Harald Gall, University of Zurich)
Enterprise Architecture (Jörg Koletzki, E.ON IT GmbH)
Software Performance Engineering in Dynamic Environments (Raffela Mirandola, Politecnico di Milano)
Balancing Long-Term Research with Industrial Applicability (Magnus Larsson, ABB Corporate Research)

The detailed program and registration information can be found at http://www.ecsa2011.org - register online before August 14th to take advantage of the early registration rates!

Slides "Cloud Architecture" Online Seacon 2011

2011-06-30T14:15:00.000+02:00

The slides for the talk "Cloud Architecture" from Seacon 2011 are online:

Architectures For The Cloud

View more presentations from Eberhard Wolff

You can also download them.

Slides and Pictures from Amazon Event

2011-05-27T16:41:00.000+02:00

Here are the slides from the Amazon event at JUG BB sponsored by adesso:

And here are some pictures:

Amazon CTO Dr. Werner Vogels

Attila Narin and Carlos Conde of AWS with me

adesso sponsored talk by Amazon CTO Werner Vogels at JUG Berlin Brandenburg

2011-05-24T10:00:00.000+02:00

On May 17th adesso AG sponsored an Amazon event at Java User Group Berlin Brandenburg. Today, Amazon is more than an online book store. Since 2006 Amazon.com, through Amazon Web Services LLC, has been offering developer customers access to in-the-cloud infrastructure services based on Amazon's own back-end technology platform.

After an introduction by me Werner Vogels, CTO of Amazon, gave the first talk of the evening.

He introduced the audience to the original Amazon IT system. Realizing that Amazon’s growth potential was limited due to the way the system was built, Amazon changed the system’s architecture drastically. Even the organizational structure was changed, forming teams that would each be responsible for one specified business service unit- including the development of the service as well as its operation.

However, even after the reorganization the engineers spent 70% of their time on scaling the infrastructure and only 30% on creating the new business logic. So the next step was to create a platform that would eliminate this burden and at the same time wouldn’t restrict the engineers. This was one of the starting points of Amazon Web Services (AWS) e.g. for virtual computers (EC2) and storage (S3).

Later on, services like SimpleDB - a very scalable data store - were developed. The current numbers for the services are very impressive: S3 currently stores 339 billion objects and every day Amazon adds the equivalent amount of server capacity to AWS that was once used to run all of Amazon in the year 2000 – when it was a $2.76 billion USD enterprise.

Next to talk was Attila Narin, Senior Manager at the Solutions Architecture of AWS. He gave an interesting presentation on the architectural principles for applications in the Cloud.

Our third guest speaker, Carlos Conde, showed the employment of Amazon Elastic Beanstalk which is an impressively easy to use infrastructure for Java applications.

With well over 150 participants the event was well received and gave a good insight into AWS and its Cloud services. The guest speaker’s talks emphasized the importance of Cloud services being the infrastructure of the next generation Dr. Werner Vogels gave an entertaining look behind the scenes of Amazon, its infrastructure and its Cloud offerings.

Thanks to all involved for making this possible!

adesso Sponsored JUG BB Event with Werner Vogels (CTO Amazon)

2011-05-06T10:12:00.002+02:00

adesso will be sponsoring an event of the Java User Group Berlin Brandenburg with Werner Vogels, CTO of Amazon. I had the pleasure to listen to Werner's talk back at JAOO 2006 (see my (German) blog post about the event. It was remarkable: Werner was the first to introduce me to the CAP theorem, now a well known foundation for distributed systems, and an approach that we now call DevOps.

During the event we will learn about Amazon Web Services, Architecture for the Cloud and AWS Beanstalk, the Amazon Java PaaS solution. If you are interested you can find more details at the adesso event page and registration form.

Seating is very limited - make sure to sign up ASAP. Looking forward to see you there!

Slides from JAX 2011

2011-05-05T13:02:00.000+02:00

My talks for JAX 2011 are done, so here are the slides:

Spring in the Cloud:

http://www.slideshare.net/ewolff/spring-in-the-cloud

Spring in the Cloud

View more presentations from Eberhard Wolff

Cloud PaaS with Java:

http://www.slideshare.net/ewolff/cloud-paas-mit-java

Cloud PaaS with Java

View more presentations from Eberhard Wolff

Future of Messaging: RabbitMQ and AMQP:

http://www.slideshare.net/ewolff/the-future-of-messaging-rabbitmq-and-amqp

The Future of Messaging: RabbitMQ and AMQP

View more presentations from Eberhard Wolff

10 Typical Enterprise Java Problems

2011-04-29T11:56:00.000+02:00

This presentation shows 10 typical problems that I encountered during quite a few code reviews. I got mixed responses concerning this subject: During WJAX, JAX and also online at jaxenter the feedback was very positive. I did a similar talk at JAOO. There it seemed that the audience was already well aware of the problems or had already solved them. Not sure what the conclusion of that should be.

Nevertheless here are the slides:

10 Typical Problems in Enterprise Java Applications

View more presentations from Eberhard Wolff

And
here is a video of the presentation in German.

The presentation is somewhat dated but I decided to upload it anyway. I think these problems are actually still far too common.

All You Need to Know About Cloud Foundry

2011-04-19T09:43:00.000+02:00

The last few days quite I have done quite some work on VMware's new PaaS offering Cloud Foundry. It is quite interesting because it means that VMware is entering the Public Cloud market. Also the code is Open Source so you can install it on your local machine or on other infrastructure. RightScale has already demoed Cloud Foundry on Amazon EC2 - you can find more information about Cloud Foundry here.

If you are generally interested in Cloud Foundry here are the things I have created:

Interview with Adrian Colyer, CTO SpringSource is here
English article is here
German article is here

Enjoy and make sure to visit cloudfoundry.org for the code and cloudfoundry.com for an account to the Public PaaS.

JAXLondon The Future of Messaging: RabbitMQ and AMQP Slides Online

2011-04-14T10:22:00.001+02:00

The slides for my talk "The Future of Messaging: RabbitMQ and AMQP" is now online at slideshare.

The Future of Messaging: RabbitMQ and AMQP

View more presentations from Eberhard Wolff

Slides from BED Conference Talk about Java Cloud online

2011-04-11T11:22:00.001+02:00

BED conference in Berlin was quite enjoyable - thanks to all the speaker and attendees for making it such a success!

You can find the slides for the Java Cloud talk online at slideshare or they should also appear here:

Cloudy in Indonesia: Java and Cloud

View more presentations from Eberhard Wolff

JAX London

2011-03-30T14:14:00.000+02:00

From April 11th to 13th the JAX will go to London. The last years it has been a pleasure to take part in the JAX in Mainz and WJAX in Munich.

I will do a talk about Spring Roo and one about AMQP / RabbitMQ, see my Speaker Profile. Also I will take part in the panel for the Spring Day which I had the honor to organiz. The program for the Spring Day is also online. Adrian Colyer will give a keynote about "Enterprise Applications in 2011: Challenges in Development and Deployment, and Spring's response.". Then Rossen Stoyanchev will talk about the new features in Spring 3.1. Then Russ Miles and Jonas Partner will talk about "Making sense of events: Strategies for Complex Event Stream Processing with Spring Integration and Pals" - sound very interesting! Another talk about a similar subject is "Spring Integration and Spring Batch in the Cloud" by Dave Syer. You should also read the interview with me about the Spring Day at JAX London.

See you there!

Berlin Expert Days

2011-03-29T09:42:00.000+02:00

Next week will see the Berlin Expert Days with the funky acronym BED. The conference takes place on Thursday, April 7th, and Friday, April 8th at the Freie Universität. It is intended to be a rather roots, low cost conference.

The program is online. I think there are quite a few nice session.

I will be doing two sessions, one about Java and Cloud and another one about Spring Roo. And I will also take part in the panel to have a nice discussion about Java with some other speakers and the attendees.

My colleague Kai Spichale will talk about the Apache Cassandra NoSQL database and Thomas Westphal - another fellow adesso colleague - will talk about Groovy and the CouchDB NoSQL database. And then Halil-Cem Gürsoy und Andreas Hartmann (both also from adesso) will talk about the currently most popular build tools - Ant, Maven, SBT and Gradle. And finally Andreas Hartmann and Stephan Müller (adesso) talk about security for JSF with the example of the OWASP attacks.

This is of course just adesso's part of the program - there are a lot of other great talks. So I am looking forward to meet you there - you can register here.

Article about CloudBees online (German)

2011-03-03T11:22:00.000+01:00

Just a short note: here is my German article about the CloudBees Java PaaS. Enjoy!

Dependency Injection Is More Than Wiring Components

2011-02-23T11:08:00.001+01:00

Dependency Injection is widely used nowadays. However, at least in the Java EE space this is narrowed down to "wiring components". I think configuring beans and injecting simple types is at least as important. The alternative is to read in configuration properties from files. Here is why I think DI is the much better approach for that:

Every project with a certain complexity has this problem. It needs to be adjusted to different users, use cases etc. A common problem should have a standardized solution
Reading in configuration files is not that easy. You have to handle exceptions if the file does not exist. You need to figure out what to do if a certain value is not set. You might want to have multiple files that can override configurations. I have to admit that I have seen projects in which the most complex code handled the configuration. Spring's XML configuration is already a powerful solution for this. And if you want to use properties files: The PropertyPlaceholderConfigurere allows to use those for configurations as well without writing any code. The PropertyPlaceholderConfigurere is very flexible - see its JavaDoc. But even if this is not enough: Using the BeanFactoryPostProcessor interface you can add your own configuration extensions.
As configuration is needed almost anywhere the class handling the configuration file becomes a dependency for a lot of classes. This is not a good design. Using DI the configuration will be injected and there is no such dependency.
Testing will also be hard if each class depends on the class handling the configuration. You will need a complete and correct configuration even for the smallest unit test. Otherwise the configuration cannot be read in. Changing the configuration for a specific test will either be impossible or the code for the configuration will become even more complex. Using the DI approach this is no problem as the configuration is injected and you can easily inject different values.

Of course this is not apparent during a short demo - but in real life DI for these kinds of applications it is a huge advantage.

Private or Public Cloud ?

2011-02-14T10:22:00.001+01:00

Currently Cloud is to a lot of people synonymous to "Public Cloud" i.e. some company provides virtual machines or a platform to deploy applications on. Examples are Amazon AWS/EC2, Rackspace, Terremark, Google AppEngine, force.com, vmforce etc. But an enterprise can also build its own Private Cloud. Companies like VMware offer all the infrastructure you need - and there are Open Source offering like Eucalyptus or OpenStack. Which route should you take?

Public Cloud Advantages

Getting started is very easy - basically a credit card is all you need.
Different service levels: While Public PaaS are quite common there is not really a lot of choice for private PaaS.
Almost unlimited ressources - you can easily add more servers and a lot of them if needed.
You would think that you have to ship data to the Public Cloud provider - actually using e.g. Amazon Virtual Private Cloud you can connect the Public Cloud to your local network using a VPN. I guess you can trust a computer in the Public Cloud at least as much as a (potentially compromised) computer in a DMZ
It is a logical next step after outsourcing operations or using hosting solution - it just provides more flexible.
Demanding SLAs are available for the services. For example multiple data centers for redundancy are hard to do by yourself and costly - but readily available in Public Clouds.

Private Cloud Advantages

You can provide exactly the kind of machines you need. A Public Cloud will only provide a pre defined set of configurations which might or might not offer what you need.
Legal regulations might make using public clouds impossible.
You might not want to ship your data into the cloud. But: Salesforce is making 2 billion dollar revenue - and the customer store all their customer contacts, order, revenue forecast etc in the Salesforce Cloud.
Compared to virtualized environment that are usually already in place a Private Cloud offers a self-service portal. So a user can create a new environment by himself. That means complex and unnecessary processes to approve new environments can be short cut and therefore productivity can increase. However, note that this is also the case for Public Clouds and it is a technological solution to an organizational problem.

Maybe the truth is in the middle: Only for high load you might want to offload work to the Public Cloud. But then you would need a common API for the Public and Private Cloud. Also the Public Cloud would need the same access to data as the Private Cloud - which is doable but might not be trivial. And you would still get different latency.

But: Cloud is in its core a business model. Instead of investing in infrastructure you just rent it - which drives down capital expenditure. This can only really be achieved in a Public Cloud because only then you don't own the infrastructure. Also a Private Cloud can only offer as many ressources as you have purchased.

More applications and data than you think might end in the Public Cloud. The most sensitive business data of quite a few companies are in Salesforce already. If important data cloud not be in the Cloud Salesforce would been doomed - but the reality is that they are very successful.

PS: I would like to hear your opinion. In particular if you are interested to give a talk about "How and why we built a Private Cloud successfully" I would like to hear from you!