Life on the Edge

“But even more important,” he said, “is the way complex systems seem to
strike a balance between the need for order and the imperative to change.
Complex systems tend to locate themselves at a place we call ‘the edge of chaos.'”
Ian Malcolm at the Santa Fe Institute


If you’ve been following the announcements surrounding the Java platform, you may have noticed something peculiar happening with the latest Java SE versions. Hardly has the ink dried on books describing the Java 9 release, and we’re already on Java 10. Even more unusual: if you go to Oracle’s Java downloads, you’ll find sections on Java 10 and Java 8, but 9 is gone already, and that in only half a year! The obvious reason for this is Oracle’s new release cadence, where so-called “Long-Term-Release” versions will still use the 3-year cadence, but between these LTS versions Oracle has moved to a 6-month cadence. The reasoning: “developers prefer rapid innovation”. While on the whole Oracle had been getting a lot of flak for it’s slow pace, the combination of a faster pace with rapid removal of older versions will come as a shock for many.

If you compare this with what has happened in the world of Browsers, then it shouldn’t come as a big surprise, because there we see that “big” release numbers have already vanished into oblivion. Who still remembers the toils of “IE fill-in-your-favorite-number” compatibility, especially when catering to slow-changing corporations? Nowadays browser version numbers are hardly ever mentioned, and they range from 17 for Microsoft Edge to 66 for Google Chrome. Sites like “Can I use?” ( provide detailed analyses of the different versions and how well they support HTML, CSS, and other standards, and specialized JavaScript libraries dynamically add support for missing bits.

So is this increased pace really a Good Thing™, simply a natural and inevitable evolution, or is Gartner finally right with its continuing predictions of doom for the Java platform?

Continue reading

Posted in Agile, Microservices, Programming Languages, Software Architecture | Leave a comment

Agile Architecture, or When not “to Architect”

The sword in the scabbard is a price beyond compare.
Jerome, the first Wayfarer.

Agile Architecture is an interesting subject from a people point of view, especially when funny movies are circulated about a house-building team embracing “Agile”. The movie shows how the team starts constructing happily, but stops somewhere halfway after finishing the ground floor, because other priorities pop up. The point raised is ostensibly that some things simply don’t fit with a agile way of working, comparable to a manager stating “I don’t need to be Agile; I know what I want! Just build it already!” Naturally, when the poster of the movie is cornered about his or her opinions on Agile Software Development, the reply invariably goes towards the comedy value of the content rather than the point it appears to make. So far however, I have yet to find someone making the correct observation that this team lacked a sense of their customer, and probably a Product Owner. As Dave Thomas argued in his presentation “Agile is dead” at GOTO 2015, agility is about taking small steps towards your goal, and after every step evaluating what it did for you. Being able to change direction after every step is what makes you agile, not whether you actually do change direction.

When I read Robert C. Martin’s book “Clean Architecture”, I was intrigued by a chapter called “Details”, which started with “The Database is a Detail”. It discusses the application of agile architecture, and not over-architecting when a simple solution will do. The point is that even the choice of your database technology is a detail which might not be important enough to solve up-front. If, like me, you work in a large organization which values the selection of a standardized Relational Database, that approach can be quite a challenge.

Continue reading

Posted in Agile, Software Architecture | Leave a comment

Closing the Knowledge Gap

If they were handing out Lamborghini’s for free, let’s say the Aventador, would you take one? I know that for myself, this would be a bit of a poser. I’ve seen enough lotteries where you could win dreamcars, but in the back of my head I would always admit that I would probably put it up for sale. Let’s be really honest here; I definitely would like to take it for a drive, but I don’t have any sports-driving skills, it’s way to big for most parking spots, and having to cross the 5 speedbumps in my neighbourhood just to get home would completely trash the spoilers. But the real long-term killer is the required budget for upkeep; maintenance costs alone would kill any chance of a decent holiday for the family. Even if we stretch reality a bit further and include free spare parts, you need specialized tools and knowledge, and you need the room to house it properly. In the Netherlands that last bit can be a real killer.

That all said, if I’m planning to do a lot of miles, nobody can deny that a Lamborghini can really take care of that! But the thing that really jumps into my mind about them is mr Clarkson of Top Gear fame, who enthasiastically explains how you can actually switch off most “protection” to get the best performance, and end up with a car that feels like it is actively trying to kill you. A bit dramatized, I admit, but he was definitely on edge about his personal safety in that car, while pushing it to its limits.

Now read on as I try to revert back to software and applications, while maintaining relevance to the Lamborghini introduction.

Continue reading

Posted in Microservices, Software Architecture, Software Engineering, Tools | Leave a comment

Turning your application on its head

If nothing what you do wil do, then what do you do?
Hisamatsu Shin’ichi (1889-1980)

So I’ve started by telling you that the Way of the Microservice has to do with quality, that this aspect is more important than the obvious aspects of size and deployment, and that trying to be like Netflix is likely to trip you up if you don’t get the quality bit right. Even Gartner, that ultimate fond of business wisdom, warns its customers that “You are not Netflix.” Bummer. So, why are we even going this path? I mean, apart from the lofty goal of delivering high-quality software, which I hope you’re not against. It’s most likely this nagging feeling that you want affordable quality, not quality at any cost.

An important thing you’re going to get from using a microservices architecture, and totally worth the (apperent) trouble, is increased autonomy. If your “application” is built as a group of cooperating small processes, and they adhere to those principles of loose coupling and high cohesion, you gain a lot of flexibility. Since the components are small, making sure they are secure and fault-tolerant is also a lot easier. Luckily there is a fairly simple trick to help you achieve the increased independence: stop building applications that move data around, but model the flow of data first, and let your microservices process or produce them: Implement a Data-Driven Architecture.

Continue reading

Posted in Microservices, Software Architecture | Leave a comment

XML still not fit for human consumption, and neither is YAML

A while back I wrote about XML (The Problem with XML), arguing that it is essentially great for computers, but definitely less so for humans. Since then, XML’s popularity in the enterprise world hasn’t really diminished that much, although we do have a strong competitor in JSON (the JavaScript Object Notation) for REST calls over the public Internet. But wait, more is happening! Binary is BACK thanks to our friends at Google, who argued that, within the confines of the (corporate) local network, binary is pretty acceptable, and way more compact and thus efficient. They named their baby “protobuf” for Protocol Buffers. Duh! Who’d have thought that? I mean, apart from any young upcoming developer… and most older ones as well. Even then, admitting I haven’t looked at the underlying encoding of the bits and bytes, didn’t we already have something like that with CORBA? Or ASN.1?

However, setting the bitching about re-inventing the wheel aside, there is a new contender for human non-consumption these days. It fits in nicely with the new name of my site, being used by tools such as Docker and Kubernetes, and its name is YAML, for “Yet Another Meta-Language”… Oh no! “YAML ain’t Meta Language“? Ye gods, yet another recursive name! (YARN) Yet another human-readable data serialization language, (YAHRDS) and this one is a doozy! Like our favourites of lots of years ago it uses whitespace to denote structure: start a line of text with more spaces then the last, and you are apparently detailing whatever was in the last line. Worse: if you want the detail to stop, just start the line with the same amount of whitespace as the level you want to return to. So if there are a lot of lines with details, you have to hunt upwards with a ruler to find out how many levels were just “closed”. YUC! (You Unintentionally Cringe)

Posted in Uncategorized | Leave a comment

Happy New Year!

‘scuse me for the late well-wishing, but there you go! 🙂 I’ve been busy with helping my eldest move to her first student-apartment-room-thingy. Next I started redecorating her ‘old’ room for use by the undersigned. Takes a bit longer than planned, but I can almost start flying virtually again.

Posted in Uncategorized | Leave a comment

Why are Microservices so hard?

If a microservice in the cloud stops responding,
and no logs were generated,
did it fail at all?

Suppose I have two applications, one a “classical” monolith, called so even though it was built using a multi-tiered architecture, the other using a microservices architecture. Furthermore, lets keep it simple and assume the functional requirements were the same, so they both provide the same functionality to the organisation and users. What can we say about how difficult they are to build and run? How do they compare? Why would I prefer the one over the other?

The monolith looks like the easy winner in build effort if I were starting from scratch, having the advantage of a simple infrastructure and application design. Hokay, now let’s add in a sense of reality: I have performance requirements, splitting the users in internal (employees), external (customers), and IT staff. (“keep everything running”) So the infrastructure needs a bit more thought; probably a separate database server and web-application server. Maybe a separate web-application server for the internal users, so their work won’t inconvenience the customers and vice-versa, and a common back-office system to tie it all together. Security is a thing as well, so set up a secure directory server to manage accounts, a DMZ around the front-end to secure the back-end further, some DDOS protection, you know the drill.

We’re hitting all the important points, so let’s take a look at the alternative: We take an account at one of the major cloud providers, select the appropriate lego-blocks from the catalogue, and start filling it with components. Funny thing is, this sounds easier, because we don’t have a lot of the infrastructure hassles.

Fast forward to the working application and we’re ready to throw a wrench into the system. Monkey wrench? Yeah, a Chaos Monkey wrench. Customers start calling that the site isn’t working. Now what?

Continue reading

Posted in Uncategorized | Leave a comment