CraftConf 2015 – Mind Successfully Blown…

So, I’m just heading back home after an awesome few days in Budapest, where I was attending the second edition of Craft Conference. I didn’t realise the conference was happening last year, but when my twitter stream was flooded was interesting looking #CraftConf tweets I had a look at the UStream live stream, and then I realised I was missing out! I managed to watch many of last year’s talks via UStream after the conference, and there was some great speakers and great content. As soon as this year’s Craft Conf was announced I bought a ticket, flights and hotel! Having completed the roller-coaster ride that was CraftConf 2015, I’m happy to say that I wasn’t disappointed…

The good…

A quick look down the list of speakers will give you an insight to the amount of tech rockstars that were in the building: Mary Poppendieck, Dan North, Jessica Kerr, Randy Shoup, Trisha Gee, Michael Nygard, Amber Case, Michael Feathers, Sandro Mancuso….need I go on? If you look back at the list, something may strike you as different compared to the majority of other tech conferences – many of the rockstars present are female.

Having first-hand experience of sitting on tech conference program committees myself, I know that it can be very difficult to organise and encourage talk submissions from a diverse group of speakers, of which gender diversity is just one part. I have to tip my hat to the CraftConf organisers for running a tech conference where 25% of the speakers were female, and the fact that they stated in the keynote that this isn’t enough should be applauded (kudos also to the organisers for offering ‘diversity tickets’ to attendees)

The vast majority of talks lived up the billing, and all four keynote sessions were phenomenal (and I don’t use this word lightly!). I left every keynote buzzing, and judging by the amount of chatter and questions from my fellow attendees, so did most other people. Don’t get me wrong, the keynotes weren’t all ‘ra ra – new tech’ or ‘developers, developers, developers’, they were genuinely thought-provoking and some of them boarder-line offensive (in a good ‘call to action’ kinda way). If you go to as many conferences as I do (including some of the bigger names), you’ll again realise how much effort must have gone into organising and planning this content – a big thanks once again to the organisers.

The ‘standard’ sessions running throughout the day were superb (with only a couple of misses detailed below), and the fact that talks were running from 9am to 7pm allowed me to definitely think I was getting value for my money. My general rule for tech conferences these days, is that if I enjoy over 50% of the talks I attend then I’m happy – CraftConf was in the 80-90% range, which is very rare (only the QCon series manages this usually).

During breaks, or when I did skip a talk session, there was always someone to talk to out in the sponsors area or one of the lounges. A tip of the hat again to many of the speakers, who constantly made themselves available and approachable when milling around the conference (and thanks in particular to Adrian Trenaman, Randy Shoup, Sandro Mancuso, Werner Schuster, Trisha Gee, Isra Kaos, Sven Peters, Simon Brown and James Lewis for some great chats).

I’ve listed some of my favourite talks below (in no particular order), and have included links to InfoQ summaries I have written where available (I will try and write more over the coming weeks).

• Complexity is Outside the Code – Dan North and Jessica Kerr
• Scaling Microservices at Gilt – Adrian Trenaman
• Coding Culture – Sven Peters
• Beyond Features – Dan North
• How to Save Innovation from Itself – Alf Rehn
• The New Software Development Game – Mary Poppendieck
• From Monolith to Microservices – Randy Shoup
• Implementing the Saga Pattern – Catie McCaffrey
• Software Architecture as Code – Simon Brown
• Great Engineering, Failed Product – Marty Cagan

There were also several talks I missed, due to InfoQ commitments or otherwise chatting to interesting people, and I’ll try to watch these back when they are released on UStream:

• The Ethical Developer – Grady Booch (heard great things about this talk throughout the conference!)
• DevOps for Everyone – Katherine Daniels (I follow Katherine on twitter, and she talks about some cool stuff)
• Automating the Modern Datacenter – Mitchel Hashimoto (who doesn’t know what Hashicorp do?)
• Consensus Systems for the Skeptical Architect – Camille Fournier (I again heard great things about this talk via twitter)

The logistics of the conference was also superb. I found the venue easily enough, registration was a breeze, and moving around the venue was straight-forward (after some initial hunting for the ‘tent’ room, which was actually a tent outside! 🙂 ) Lunches and breaks were well spaced apart and nicely timed, and the food and drink was also excellent (including getting fed for the entire day on the Thursday). The queues for the lunch sessions did get a bit disorganised, but after completing the Paris Marathon and nearly getting shoved to the ground several times when stopping for food and water breaks, I’m starting the think that queueing may be a distinctly-British thing… 😉

The (not so) bad…

I had a few minor grumbles, and to be honest these really were minor. A couple of the talks were too high-level or a bit disorganised, but I only left one early. I’m not going to name and shame people here, but if the conference organisers do ask for feedback then I’m happy be honest. What could help for next year is to indicate the intended audience ‘level’ for a talk, but even then I would expect quite deep content for each session at the conference that I believe CraftConf is trying to be.

I did have a couple of interesting chats with people who mentioned that CraftConf isn’t really a conference about software craftsmanship, and I do agree here – at least in terms of how we define mainstream ‘software craftsmanship’ in London and the USA i.e. focusing on clean code, TDD and outside-in development.

However, I strongly believe that CraftConf is a conference about the software development and delivery craftsmanship, and this is exactly what a generalising specialist like me wants. I care deeply about software development from idea inception through to development, delivery and ultimately validation (thinking about project management, leadership and stakeholder management along the way), and CraftConf hit all of these points nicely for me. The only reason I mention this fact, is that if you are a hardcore London or US-based software craftsman, then don’t come to this conference expecting the type of content you may be used to in typical craftsman events.

I’ve seen a couple of tweets and another blog (including the ever-informative Burning Monk) saying that there was a lack of deep-dive language and functional talks, but I think the conference was all the better for it. This is obviously a subjective opinion, and I enjoy learning about languages and functional as much as the next developer, but I tend to target specialist conferences around these subjects when I want to know more (for example, Scala eXchange or SpringOne 2GX).

For me, the balance of talks at CraftConf was superb, and there could be a danger of diluting the content (and the audience) if the organisers try to make the conference ‘all things to all people’. Just my two pence, but the organisers have run two amazing conferences already, and so I say listen to your heart, not necessarily the advice… (and I appreciate the irony of my advice in this context 🙂 )

And yeah, there was no ugly…

If you’ve read the above content, then you’ve probably figured that I think quite highly of CraftConf, and you would be right. I thoroughly enjoyed my time at the conference, and the combination of speakers, topics and attendees was fantastic. I’ll definitely attempt to head back next year, and this time I’ll keep an eye out for the CFP, as I would love to speak here as well.

The primary meme I took away from this year’s CraftConf is that software development is on the verge of breaking out of the traditional IT shackles, in much the same way computing infrastructure has broken-free and is rapidly evolving with the mainstream adoption of cloud. For anyone familiar with the diffusion of innovation graph, lean principled and business-focused software development is getting dangerously close to the late majority, and this really will shake up the industry (especially the traditional software development shops and developers). Alf Rehn’s and Marty Cagan’s keynotes were great example of this

I’m starting to think that the ‘full-stack’ developer of 2018 will not only have the skills that we expect now, but they will also be business savvy, and know enough statistics and data science to appropriately challenge slow moving executives as to what the expected return on investment will be from the latest (HiPPO) instructions from above… People may say this kind of thing happens now, and it does (and it famously has been in companies like Amazon for quite some time), but I believe this will soon happen in the majority of companies. Don’t forget, if you attended CraftConf or are reading this blog you are already part of a self-selecting audience who aspires to learn more and become better – and you’re in the minority within our industry…

The second meme that I picked up on was is that we are working in a golden age of tooling and process. With the emergence of technologies like cloud and containers, and practices like lean, BDD and TDD, there really is no excuse to be building bad software applications. It may take a bit more thought and design, as mentioned by Mary Poppendieck, Dan North and Jessica Kerr, but it is most definitely possible to build large complex systems that can be validated, tested and deployed with relative ease.

In summary, if you are looking for premium-level conference content at a frankly bargain price (with a fantastic location thrown into the mix), you can’t go wrong with CraftConf. I guarantee you’ll leave with more knowledge than when you arrived, and a whole-lot more questions…

Once again, many thanks to all of the organisers, volunteers and speakers – a great job by all concerned!

The Crafty Consultant’s Guide to… DevOps

On Thursday I once again had the pleasure of presenting at the London Java Community (LJC) meetup. This time I presented a new talk “The Craft Consultant’s Guide to… DevOps”. This builds on a DevOps parody talk I gave at last year’s LJC Unconference, and also combines some of my thoughts from my earlier “Chuck Norris doesn’t do DevOps, but Java developers might benefit” talk.

The goals of this talk was to provide a high-level overview of some of the key themes of DevOps, specifically from a tooling perspective. It’s worth stating at this point that in my opinion DevOps is more about methodology, process and culture more than it is tooling. However, for the intended audience of this presentation the focus on tooling provides a framework on which to build understanding for the non-technical issues. The slides can be found below:

The original abstract for the talk can be found in the next paragraph, and as usual, if you have any comments, thoughts or (constructive) criticism then please do get in touch!

“Come along and learn how the Crafty Consultant makes his money by consulting craftily in DevOps. We’ll see how silos can be broken down by introducing more independent and isolated team, how only idiots automate everything, and why monitoring only provides actionable insight that simply confuses your clients…

…and then we’ll look at the real world implementation of DevOps 🙂 The primary aims of this talk are to introduce the concepts behind the DevOps movement, and we’ll do this by debunking all of the Crafty Consultant’s advice. We’ll cover the drivers of breaking down silos (in business and in tech), the benefits of automation (especially with provisioning and configuring infrastructure), and the power that monitoring provides (particularly when deploying to the cloud, or implementing a microservice architecture).”

Details of the event can be found on meetup.com

Microservices Maturity: Dogma or Dogfooding? You Decide…

I’ve received some great feedback after posting my proposal for a microservice maturity/classification model last week, some positive, and some negative.

Some private communications suggested that I may be getting caught up in the marketing hype, and several emails suggested that the microservice architecture really is just classical SOA re-invented. Other emails balanced out these comments by suggesting that microservices present an opportunity to learn and iterate on the mistakes made in the original implementation of SOA, especially now that we are embracing concepts such as domain-driven design, and are applying more consideration to well-defined software architectures.

The only public response I’ve seen so far is by my fellow London-based microservice and Spring framework expert Russ Miles – you can read it on the Simplicity Itself blog. In the interest of full disclosure I do know Russ personally (and have sank a few beers in his company), but that’s not going to influence what I think could be a great discussion about my proposal.

Maturity – not all it’s cracked up to be…

The first comment made by Russ is that the approach of creating a maturity model could be dangerous. I think this is totally fair, and it crossed my mind several times when writing the initial post. So much so, that I added the word ‘classification’ to the title as an alternative to maturity.

If you look at other maturity models, such as the Richardson model for APIs or the Continuous Delivery model, then there is a clear sense of scale, from negative to positive. As Russ quite rightly points out, there is room for interpretation in my model that smaller is better, and I probably should have taken more care to make it clear that I don’t think this is necessarily the case.

In some cases a monolithic, but well-structured, architecture may be the best solution. Russ has also conjectured in a recent talk a Skillsmatter that starting out with building a monolith and then moving to a microservice architecture may be the fastest way to build software. It’s definitely difficult to prove this beyond anecdotal evidence, but my instincts (and experience) tell me this is probably true in certain cases, especially at the current point in time where we have little in the way of modelling or tooling support for building microservices.

In my opinion Russ is quite right to think about how this model could be used negatively, and although my initial intention was to give people a model that they could look at and point to where they think their software is, it could easily be abused. I would be keen to get more feedback on how the model could be shaped or evolved to make my intentions clearer.

Size – it’s what you do with it that counts (but size still matters)

Russ also mentioned that size is a dangerous metric, and I agree. Although lines of code (KLOC) is potentially an arbitrary metric, especially with the variety of languages and frameworks currently available, I still do believe that size is important. Not in the “if you’re application is over a 100 lines, then it’s not a microservice” kind of way (which, in fairness, could have been read from my model), but in the perspective of encapsulation, responsibility and comprehension.

After a bit more thought, a measure of architectural/code cohesion is probably a better metric for this concept. I definitely believe the microservice architecture is rooted in the principle of high cohesion (and loose coupling), but it has been argued by the likes of Simon Brown and Bob Martin that this can be achieved in a monolithic codebase without the need for the creation of separate ‘services’. The key here is modularisation or componentisation.

Accordingly, I do believe that microservices should be ‘small’ in size. For me, this was one of the failings in the original approach with SOA. The lack of skilled modelling and architectural guidance allowed services to morph into ‘all singing and dancing’ applications that offered low cohesion. Hard system boundaries (and potentially expensive coordination and communication) provided by microservices in combination with the notions of ‘bounded contexts’ from domain-driven design (DDD) should make it more obvious to developers when we are straying outside the remit of a component.

Bloated vendor tools that emerged from traditional SOA also allowed developers to ‘cheat’ by circumventing the loose coupling that patterns such as the service bus initially proposed, and monstrosities such as the heavyweight ESB were born. These days we are seeing tooling emerge that encourage reactive systems and event-driven architectures based on small components (such as the very interesting AWS Lambda). With services such as AWS Lambda a codebase size limit is enforced due to the nature of execution. It will be interesting to see what applications emerge from these frameworks.

Putting a size limit on a codebase may not be an exact science, but I believe an upper bound can at least be used as a trigger to discuss if a service is growing beyond it’s original remit (or if the architectural quality is degrading). A lot of agile and architectural techniques I teach clients are not hard-and-fast rules to determine which decisions should be made, but often act as a cue for the team (or organisation) to engage in conversation or a whiteboard session to check that we are still designing high-quality software that models the business correctly.

Dogma or dogfooding – you decide…

The final section of Russ’ post contains the strongest argument, in that dogma over thinking will only lead us down the wrong path “A maturity model can be used in place of thinking; I’d like to avoid that if we can”. Yeah, this sucks, but I agree.

The problem is that my academic background drives me towards the sharing of ideas and proposals among my peers, and I enjoy the ensuing discussion. We should always take care to make sure we are being pragmatic in these discussions (and not “solving the world’s problems at the dinner table”), but I’m still a supporter of pushing stuff out to the public for comment.

Russ also makes a great reference to Greg Young’s talk at muCon last year, which should be essential watching for anyone building microservices. Paraphrasing Greg massively, he suggested that a lot of the concepts behind microservices have already been done before, and that if we aren’t careful then we will re-invent the wheel (albeit more ‘micro’ than before 🙂 ).

Greg’s observations about the negative impact of dogmatic standardisation and overly-opinionated vendor tooling were also especially damning, and I couldn’t help but nod in agreement through a lot of his talk (on a side note, the whole muCon conference was awesome, and I would highly recommend attending the next iteration later this year! Massive kudos to Russ for kickstarting this conference).

I’m definitely going to take care to avoid being dogmatic (or inspiring dogma), but I’m still keen to share my thoughts on things like the maturity/classification model. It might turn out that this approach isn’t useful, but I’ve already been using a slightly less polished version of this model with tech friends over the last few months to help them understand where their software stack currently sits in relation to the ‘unicorn’ organisations such as Netflix and Amazon (what else are techies going to discuss over a few beers! :- ).

Something that I believe could emerge from this type of proposal (which may be more valuable) is some kind of model that shows organisations where their software sits on the big picture scale of innovation, architecture and delivery. Each level of the model should also clearly show the benefits and drawbacks, and provide guidance on why (if at all) organisations should move some of their software to the next level. We would also need to show how organisations should go about doing this, both from a pragmatic organisational and cultural perspective (Conway’s law in action), and also from a technical tooling and process perspective.

I’m currently reading Jez Humble’s new book ‘Lean Enterprise’, and this is providing some superb inspiration for approaching these tasks. I’m also dogfooding some of my new models and processes, and as soon as I have some useful insights I’ll make sure I share them.

In summary…

I really appreciate Russ taking the time to reply to my original post, and I’m definitely going to think more of several of the great points he’s made (and I’m sure I’ll also catch up with him for a beer after an upcoming London Microservices User Group meetup).

I will also take more care to make my intentions clearer, but I’m still keen to share my thoughts and inspire debate. I’m also keen to avoid dogma, and focus more on dogfooding the model, and here I’ll use some of Russ’ comments to attempt to refine the model.

As usual, if anyone has any comments or feedback then please do get in touch!

Thinking Fast and Slow with Software Development (Jfokus 2015)

I’ve just got back from my first Jfokus conference in Stockholm, Sweden, where I presented the latest version of my “Thinking Fast and Slow with Software Development”. The core concept of the presentation is based on Daniel Kahneman’s bestselling book, “Thinking Fast and Slow“, and I wanted to relate the discussion of decision making heuristics and bias contained in the book to software development.

I’ve included the slide deck below, and I believe the video of the presentation will eventually be available from Parleys

Jfokus 2015 "Thinking Fast and Slow with Software Development" from Daniel Bryant

Here is the original 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 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. Topics that will be discussed include; the ‘Availability Heuristic’, which can lead developers to choose the ‘latest and greatest’ technology without proper evaluation; ‘Optimistic Bias’ which can blind architects from the ‘unknown unknowns’ within a project; and more!

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

LJC Event “Chuck Norris doesn’t Do DevOps… but Java developers might benefit!”

As usual, I had a great time presenting at a London Java Community event, and this time I rolled out my ever-evolving “Chuck Norris Doesn’t Do DevOps” talk.

Sam from RecWorks very kindly agreed to film the talk, and she has uploaded the video to YouTube (thanks Sam, you’re a star!) :

You can also find the slides below, or at my SlideShare account here

LJC: “Chuck Norris Doesn’t Do DevOps…but Java developers might benefit” from Daniel Bryant

LJCConf “Chuck Norris Doesn’t Need DevOps” Slides

The LJC ran it’s ever-popular annual Open Conference on Saturday 23rd November, and this was the first time I’ve made it along. To say I was impressed was an understatement, and I’ll try and capture some more thoughts in a later blog post, but for the moment I wanted to share the slides from the main presentation I delivered “Chuck Norris Doesn’t Need DevOps”

 

Can’t see the presentation slides? Please click here http://www.slideshare.net/dbryant_uk/2013-ljcconf-chuck-norris-doesnt-need-devops

The original pitch for the talk was as follows:

“We all hear the term “DevOps” being thrown around on a daily basis, but what does it actually mean? With a little help from everyone’s favourite 80’s action hero, we’ll undergo a whistle-stop tour of the philosophy, culture and tooling behind this buzzword, specifically aimed at Java Developers.

We’ll also look at a real-world case study from Instant Access Technologies Ltd, and explore the key role that DevOps has played during a successful upgrade of the epoints customer loyalty platform to support increasing traffic. The core discussion will focus on the challenges encountered as we moved from a monolithic app deployed into a data centre on a ‘big bang’ schedule, to a platform of loosely-coupled components, all being continuously deployed into the Cloud.”

Thanks to everyone who attended my presentation! The feedback was most welcome, and the questions were great. If anyone wants to add anything further than please feel free to comment, email or tweet at me!

DevOps and the Cloud. Not just localised in the Bay Area…

I’ve just read this interesting blog post about DevOps and the Cloud, and felt compelled to leave a comment, which is now turned into a blog post. The original article can be found here:

DevOps and cloud: A view from outside the Bay Area bubble

The post is USA-centric, talking about the Bay Area in particular, but it does make some very good (and thought-provoking) comments about how cutting-edge practices such as the DevOps philosophy tend to gravitate around the well established tech hubs.

I wanted to add my 2 cents (2 pence?) to the discussion to make sure people don’t just assume this practice only occurs around the West coast of America. Obviously this geographical area is highly influential in the global IT landscape, but people all over the world experience similiar trends and practices, albeit on a more micro scale.

I work as a freelance development consultant in the London areas, and many small companies are investing heavily in the new DevOps philosophy, particularly around the “Silicon Roundabout” area which is a haven for tech-focused start-ups. Although there are many other tech-hubs around the UK (as I’m sure there are all over the US; NYC for example?) it’s all too easy to see the pattern mentioned in the above article, especially in the more established ‘traditional’ IT sectors. When it comes to the Cloud, people in these sectors often talk a good game, but play very badly. This trend is regardless of geographical location.

It’s not difficult to see why. If I’m riding my ‘startup’ pedal bike then I can change direction at any time. If I see something I like, or something that looks new and shiny I can hop onto the sidewalk or even ride down a one-way street if I really want to. If I’m driving my SME articulated truck then I have to think ahead, but if something interesting pops up on the sat nav then I can usually change direction within a reasonable distance. If I’m driving (piloting?) my Enterprise-grade freight train then I have to start planning things months in advance and talk to a thousand other people before I even consider travelling on another track.

Having said this, I am generally very encouraged to see these new ‘DevOps’ approaches emerging, regardless of where this is happening. Anyone who is a true practitioner of this philosophy knows and can demonstrate the benefits it will bring to a business. My personal favourites are how DevOps methodologies can enable the implementation of Continuous Delivery, thus allowing more iterative product/feature releases, and also how DevOps can facilitate the automation of provisioning and deployments, thus allowing rapid auto-scaling to meet demand and also lowering the cost of experimentation. Anyone who is a fan of the “Lean Startup” methodologies should be jumping up and down with joy at the thought of this, but notice how I mentioned the words ‘Lean Startup’ There isn’t a ‘Lean Enterprise’ philosophy that I know of

In my opinion it’s only a matter of time before these early DevOps adopters spread the good word and this practice becomes mainstream. It doesn’t really matter where they are located or in what size company they work – if the methodology is based on sound and proven principles then it will eventually become adopted by almost everyone in the industry. It’s just a matter of how flexible the organisation is, and this largely relates to size and willingness to take (what are perceived as) risks.

[Flashback to the early 2000’s] TDD and Agile development anyone? Surely only the cool Bay Area kids do that? 😉