Josh Long, Richard Warburton and myself were having an interesting conversation on twitter about standardisation early today, specifically related to the Java Community Process (JCP), which is the mechanism for developing standard technical specifications for Java technology. Josh asked a question that I often get asked “what does JCP standardisation offer?” (I’m paraphrasing here slightly). This is a totally fair question, and I thought it deserved a little more explanation than I could craft on Twitter.

Innovation and Standardisation; Ying and Yang

The key thing to remember about the JCP process is that it is not about innovation. Quite the opposite in fact. For a standard to be created there must have an initial requirement or problem, significant innovation creating solutions, ideally some competing ideas and implementations, plenty of evaluation and discussion, and ultimately an agreed approach on how to meet the requirement. This process takes time, and it is only at the second from final point the JCP can start creating standards. This is the biggest misunderstanding I encounter when running JSR hack days around the world, particularly with junior developers, as they think the JCP is some mystical think tank who crank out the latest and greatest innovative frameworks (I appreciate calling EJB ‘latest and greatest’ is very ironic :-) ).

It’s also worth mentioning at this point that the work of the JCP is now undertaken in the open (I do appreciate the fact that it didn’t used to be, but JSR-348 has made great progress to abolish the ‘behind closed door’ work). This openness provides a platform that allows anyone who wants to get involved to be able to contribute opinions and ideas to the process, and if a standard will cause problems (or is evolving in a problematic fashion) then the community can rise up and publicly duke this out with the spec leads (no Duke pun intended!)

Now on the flip side to this there exists organisations like Spring.io/Pivotal who are all about innovation, and are constantly pushing the boundaries of what a language or framework can do. Personally I love this. I have an entrepreneurial background, and I thrive on innovation and playing with the latest tech and bleeding-edge frameworks as do many of the companies I work with. The Spring framework really does excel here, and this is why I made the transition to coding in Spring back when the framework was at version 1.X and I was really struggling with building J2EE applications. However, as a consultant I appreciate that not all my clients (or the industry in general) think like this, or desire this level of innovation or disruption.

Many companies are inherently risk adverse (sometimes with good reason) and they want to ensure any investment in technology or training their people in a specific technology offers a long-term return on investment (ROI). Such organisation also often desire portability of application/code, and although the practical implementation on the Java platform of this philosophy may not have been perfect in the past, I’ve personally moved several large(ish)-scale Java EE applications across differing application servers with minimal effort. In my mind this is where standardisation can offer enormous benefits, particularly if the standardisation work is undertaken out in the open. On a related note, last year within the London Java Community (LJC) we undertook a community survey of our members, and many Java developers were in favour of standards such as those offered by the JCP (check out the result here http://londonjavacommunity.wordpress.com/2013/09/16/the-java-community-process-survey/)

Horses for Courses…

I strongly believe that innovation and standardisation are far from mutually exclusive, and in fact are very much mutually beneficial (perhaps to the level where one cannot exist without the other, but this is just my opinion). Without innovation we wouldn’t be the embracing the benefits offered by the latest incantation of Service Oriented Architecture (SOA), currently being labelled as ‘microservices’, lead by the likes of Spring Boot, Dropwizard and Ratpack in the Java space. I am very much enjoying working in this space, and the fact that I don’t have to follow any kind of specification results in some very agile, flexible and effective applications.

However, you don’t have to look too far to see the problems that an absence of standardisation can surface. Earlier in the year Facebook announced that it was attempting to create a specification for PHP, as none had existed up until this point, and this made it difficult to decide what the ‘correct’ behaviour of any particular PHP runtime should be. Recently the AngularJS team announced a new version of their framework, and suggested that there will most likely be no clear migration path between the current 1.X and new 2.X versions. This will surely stifle innovation and hamper maintenance of code within companies who have invested significant resources into version Angular JS 1.X (not to mention the problem of dealing with thousands of lines of code that are currently running in production). There are a couple of other related examples that spring to mind, but I won’t mention them as I hope readers will follow my intentions. On a related topic, I’m also very interested to see what will happen with the .NET platform now that Microsoft have open sourced the underlying code with an MIT/Apache2 licence…

Summary

So in summary, I think there is most definitely a place for innovation and standardisation, and I believe both are very useful. This is why I choose to publicly evangelise the Spring platform (and write stacks of code in Spring Boot), and at the same also support the great efforts of the JCP and the OpenJDK which help to drive the future of a standards-based Java platform.

I would be keen to hear other’s thoughts, and so please feel free to comment below :-)

Disclaimer: I am a member of the OpenJDK Adoption group, and also contribute to the excellent work undertaken within the JCP via the London Java Community JCP committee. However, in contrast 90% of the Java code I write when consulting is currently Spring-based (specifically Spring boot of late), and I publicly evangelise the superb innovation undertaken by the Spring framework team.

I’m currently at JavaOne and have just finished presenting the latest iteration of my “Cloud Developer’s DHARMA” talk, which was great fun. As promised, here are the slides:

 

 

The abstract for this talk is included here (just for the search engine’s benefit :-) )

“Building Java applications for the IaaS cloud is easy, right? “Sure, no problem. Just lift and shift,” all the cloud vendors shout in unison. However, the reality of building and deploying cloud applications can often be different. This session introduces lessons learned from the trenches during several years of designing and implementing cloud-based Java applications, which we have codified into our Cloud Developer’s “DHARMA” rules: Documented (just enough); Highly cohesive/loosely coupled (all the way down); Automated from code commit to cloud; Resource-aware; Monitored thoroughly; and Antifragile. “
 

If you have any questions then please do get in touch!

I recently started a new Spring Boot project and was configuring my initial MockMvc Integration tests, and although I could happily static import jsonPath (via import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath) I was getting the following Exception when running what I thought should be a passing test:



java.lang.NoClassDefFoundError: com/jayway/jsonpath/InvalidPathException
 at org.springframework.test.web.servlet.result.JsonPathResultMatchers.<init>(JsonPathResultMatchers.java:43)
 at org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath(MockMvcResultMatchers.java:196)


It turns out that I was missing a dependency for the jsonPath library… I’m not sure why this isn’t included with the Spring Boot libraries, as most other things are?

Anyway, the fix was to simply add this to my pom:


<dependency>
     <groupId>com.jayway.jsonpath</groupId>
    <artifactId>json-path</artifactId>
    <scope>test</scope>
 </dependency>

 

Problem solved!

I was once again privileged to present at the London Java Community (LJC) “Straight from the LJC” series of talks at Skillsmatter last night, and my chosen topic this time was “Professional Software Development: Thinking Fast and Slow”. In a nutshell, I attempted to relate the great content about human decision-making from the book “Thinking Fast and Slow” to the decisions we make in our day-to-day work as software developers. Enjoy!

 

 

Here is the talk abstract:

“In the international bestseller ‘Thinking, Fast and Slow’, Daniel Kahneman explains how we as human beings think and reason, and perhaps surprisingly how our thought processes are often fundamentally flawed and biased. This talk briefly explores the ideas presented in the book in the context of professional software development. As software developers we all like to think that we are highly logical, and make only rational choices, but after reading the book I’m not so sure. Here I’ll share my thinking on thinking.”

Thanks to the LJC, Recworks and OpenCredo in supporting my speaking efforts! As usual, if you have any questions, then please do get in touch!

I was fortunate enough to be invited to sit on this year’s Devoxx UK Program Committee, and this was an awesome experience. Not only did I get to meet (and interact with) some very talented people on the committee, but I also got a peek into how the talk submission review process works. I’m sure this will be invaluable for other conferences I submit proposals to!

I wanted to quickly share my learnings, and also highlight the key things to remember when submitting a talk to a conference CFP:

  • Please don’t just submit a one-liner for an abstract. Unless you are really well-known with an excellent track record then it’s hard to judge the proposal (and even if you are wellknown, then it’s still difficult for us!)
  • Please don’t try and hide a thinly-cloaked sales-pitch as a conference talk. Even the most inexperinced of us sitting on the committe had been to enough conferences to spot this
  • Do include your previous speaking experience (including links to videos and slides), and also any references. This makes the committee’s job of verifying you are a good speaker easier. I do appreciate that not everyone will be an experienced conference presenter, but even a link to a user group talk session you gave can be helpful.
  • Submit to the correct track. If in doubt, then send an email to the organisers asking their opinion
  • Make sure you submit your talk with the correct session type – BOFs are considered and schduled seperately (and sometimes at a differnet meeting than main conference sessions)

On a related topic, Richard Warburton and I presented a ‘How to get your talk accepted at Devoxx UK’ presentation earlier in the year – I’ve included the slides below, as this includes much the same advice as above, but in a nicer format :-)

 

 

At this point I have to say thanks again to the steering committee of Devoxx UK for inviting me to participate, especially Mark Hazel, Ellie May, Stephan Janssen and James McGivern – you guys rock!

If you have any questions about my learnings or the slides above then please feel free to get in touch!

Ok, so the review of this excellent conference is probably about a month overdue, but time just seems to have flown by! Anyway here it goes…

Life on the Program Committee

I was fortunate enough this year to be invited to sit on the program committee and review submissions (thanks Mark et al!). I’ll create a separate post about this experience later, but I wanted to start this review by mentioning that the number of submissions for Devoxx UK was very high, and the quality was outstanding.

According to my fellow Program Committee members, the job of picking which talks to include in the conference gets more difficult each year! As many committee members mentioned, we could have easily picked talks to fill an entire week of conference, but the difficult thing was that Devoxx UK was only running for 2 days!

The Conference Itself

The conference began in style with a live beatbox session from the UK Champion ‘Reeps One‘. Check out some of his stuff on youtube, but this guy needs to be seen live to get the full experience!

After a great introduction to the conference from the steering committee (Mark Hazell, Ellie May, Stephan Janssen, Dan Hardiker, James McGivern) Dan North opened up the with the keynote “Deliberate advice from an accidental career”. I enjoy most of Dan’s stuff, due largely to his story-telling skills and the fact that I can relate to most of the experiences he talks about, and this presentation was no exception. The key takeaways can be summarised in the photo below, but if you get chance to watch the complete presentation then I strongly recommend you take the opportunity :-)
2014-06-12 10.17.57

Notes on good sessions

The first official session of the day for me was Andrew Harmel-Law’s “The 5 whys: Counter Intuitive Solutions to (all too common) Problems”, which was a great discussion of key problems in relation to the DevOps movement. The central theme to the talk related to a book on Japanese farming, and how the concepts could be mapped onto continuous delivery and DevOps, and as a fan of Eastern philosophy I enjoyed this metaphor very much :-)

During the next two sessions I was dropping in and out of talks, and also catching up with other presenters and friends who I hadn’t seen in a while. Talks that looked interesting were Graham Allan’s “How switching to Scala made me less productive, and why that matters less than I thought” and Dick Wall’s “What have Monads ever done for us?”

The final conference session of the day that I attended was John Smart’s “It’s testing Jim, but not as we know it”. This session was a personal highlight of the conference for me, and the discussion of BDD really hit home to the projects I have recently been working on. John also has a MEAP book ‘BDD In Action’ which I can highly recommend.

In the evening Mani Sarkar, Richard Warburton, Martijn Verburg and myself presented an OpenJDK BOF session, which was well received, and generated plenty of great questions. If you want more information (or want to get hacking yourself) then please pop along to Mani’s excellent ‘Getting Started with OpenJDK document’

Roll on to Friday…

Friday began with Simon Brown’s “Software Architecture and the Balance with Agility”, which was another personal conference highlight. As part of my program committee role I had invited Simon to Devoxx UK, as not only am I a big fan of his work, but I also think the topic of architecture is often neglected in developer conferences. Simon didn’t disappoint, and key takeways for me included; developing software in an agile way doesn’t guarantee that the resulting software architecture is agile; a good architecture enables agility; there could be a sweet spot (architecturally speaking) somewhere between a monolithic architecture and SOA (but no-one want to hear this?); sketches can be maps – the key thing is creating a shared vision. Simon has a great website www.codingthearchitecture.com and also a book entitled “Software architecture for Developers”, both of which I can recommend. I definitely am a strong believer that all developers should be aware of architecture (and also that all architects should code!)

Next was an interesting talk ‘Groovy DevOps and the Cloud’, which touched on many of my favourite DevOps topics, but with a Groovy theme. I also couldn’t help noticing that a lot of the tools developed already existed in a non-groovy form, and so I wondered in some of this was vulnerable to the ‘not invented here’ argument, but the presenter did seem aware of this fact, and gave some great recommendations for resources and books at the end of the session

The third session of the day was my turn to present with Steve Poole “Moving to a DevOps mode: Easy, hard or just plain terrifying”. Here is an action-shot of Steve and I on stage…

14577280683_1bd3e6b977_z14370589518_8ac0759092_z

It’s safe to say that both Steve and I had a great time presenting, and the feedback and questions after the session were great. You can watch the recording of the session here (subscription required, but free to all who attended Devoxx UK). You can also find the slides in another blog post here

After our talk both Steve and I stayed in the same room to listen to the panel session “What does the Oracle/Google shenanigans mean to the Java Developer”. This talk was not only very funny (almost guaranteed when you create a panel containing Ted Neward with a lawyer…), but also quite pertinent, what with all of the interesting IP/patent issues constantly flying around.

The next session of the day “Modern web architecture” by Ted Neward was great. Ted has his own brand of ‘edu-tainment’, and this session lived-up to his usual billing. I’m not going to spoil his punchline, but I’ll simply say that watching the recording will be well worth your time!

I spent the remainder of the day in the Hackergarten, chatting to many people about OpenJDK and various JSRs (and also answering a few DevOps questions). I also managed to catch up with old friends in the hackergarten, and Anatole Tresch and I also planned our upcoming JSR-354 hackday which we ran at OpenCredo.

The conference was drawn to a close with an ensemble keynote, which was awesome. Martijn did a great job reviewing the conference content, Dick Wall shone an interesting light onto the technological present (including lots of details about wi-fi enabled dog Dotty!), and Arun and company covered (a hopefully very exciting) future, especially relating to the work everyone is doign in Devoxx for kids

The Saturday after-party

A few of us managed to continue the party into Saturday, with John Stevenson from Salesforce offering to run a Devoxx UK themed ‘Hack the Tower’ event. I had great fun here as well, and managed to get a few more people hacking on OpenJDK :-)

In Conclusion

The conference was awesome, and built upon last years success. Devoxx UK is still one of my favourite conferences in terms of atmosphere, and the ‘by developers, for developers’ mantra really does ring true. Everywhere I went I overheard interesting conversations, saw impromptu hacking, and people taking the time to connect with one another. The quality of speakers was also excellent, and the range of topics nicely balanced (although I may be biased here… :-) )

I would also like to say a big thanks to all of the organisers, the volunteers, the speakers and the attendees for making the conference so great. Thanks also to all the friends (both old and new) I managed to catch up with, and I’ll see you all at another conference soon (maybe JavaOne?)

On a final note, Devoxx UK has already been confirmed for 2015, and so please book space in your diaries for a 3 day extravaganza (yes 3 days, not 2) between 17th-20th June!

14553793591_ff1f8f8d43_z

 

 

I once again had the pleasure of presenting a lightning talk at the London Software Craftsmanship Community #LSCCtalks series. This time I presented a new talk I’m working on – “Crafting DevOps: Applying software craftsmanship to DevOps”.

The presentation (hopefully) does what it says on the tin, in that I talk about the ideas of applying software craftsmanship principles to DevOps . If the DevOps mantra of “Infrastructure as Code” is true (which I think it is), then I believe it makes sense to learn from the craftsmanship community – in particular TDD, BDD and continuous integration.

This is very much a work-in-progress talk, and I hope to develop it more over the coming weeks and months (please do send me your feedback!).

 

Thanks again to Sandro and Samir from the LSCC for inviting me to talk, and as usual, if you have any questions, then please do get in touch. In particular please do let me know if you would like to see more on this topic.

 

Follow

Get every new post delivered to your Inbox.