UPDATE: Now you can add workers to a column and see if it helps getting work done faster. Try experimenting with the numbers and get the best configuration!
While reading blogs about Agile games, I came across this link of Karl Scotland.
Because I always like combining programming with building something that gets across Agile principles (our Battleship game is also a good example) this seemed like a good new project for our Fridays at Zilverline HQ. Bob Forma and me started this and within a few days we came up with this (You can check the source code here)
Continue reading Flowmulator – A Kanban flow simulator
In the previous part we added blog post comment functionality. In this part we’ll do some refactoring and change the memory image implementation to automatically retry domain logic on optimistic locking conflicts, giving us a simplified form of transactions. We’ll also change the event store to support multiple types of event streams in a single event store.
Continue reading Simple event sourcing – refactoring and transactions (part 5)
Knowing how people think or feel about a certain subject can be very helpful in building trust, creating a team and to reveal impediments. Of course it can be very difficult to get team members to express their real opinions, especially when a team has just started. I think with patience and the right approach trust can (and will) be built and it will be easier to get real issues out in the open. The following practice can help you start this and make explicit what individual opinions in a team are.
I have used the following retrospective practice for several years now:
Continue reading How to fill your happiness metric
After our deep dive into a Redis event store implementation we’re now getting back to actually adding functionality to the blogging application. Like the Getting started with Rails guide we’ll add the capability to add comments to blog posts. Adding this functionality is straightforward, but it will require us to look into resolving conflicts when multiple people make modifications to the same blog post or comment concurrently.
Continue reading Simple Event Sourcing – conflict resolution (part 4)
In the previous part we developed a fake event store for our blogging application. This event store just kept all events in-memory, making it unsuitable for production use. But it did allow us to adapt our application to using an event store, and let us work out the details of the event store interface without having to worry about an actual persistence mechanism.
In this part we’ll develop an event store implementation on top of Redis, a key-value store with support for additional data structures (such as lists and hashes), publish/subscribe, and transactions. If you’re more interested in adding new application functionality, you can safely skip this part and go to part 4 – conflict resolution.
Continue reading Simple event sourcing – Redis event store (part 3)
In the first part of this series we developed a simple blogging application that uses event sourcing to keep track of all changes made by the users. However, we did not yet write these events to durable storage. This means all data is lost when the application is restarted, which is clearly not acceptable. Saving and restoring events will be the responsibility of the event store, which we’ll start implementing in this part. But before we get to actually writing events to disk, we must first tackle the problem of maintaining data consistency when using event sourcing.
Continue reading Simple event sourcing – consistency (part 2)
This is the first part of a series on building an event sourced application. We’ll build a simple blogging application (inspired by the Ruby on Rails “Getting Started” tutorial), so the domain should be familiar. This allows us to focus on implementing a memory image based architecture using event sourcing. Another goal is to show that this kind of architecture is not more complex (and arguably, simpler) than those implemented by traditional database centered applications. The example code is in Scala using the Play! web framework, but should be understandable enough if you come from a Java (or similar) background.
Continue reading Simple event sourcing – introduction (part 1)
Last friday I gave a Masterclass called ‘Lean Agile Architecting’ to architects. Very interesting masterclass and a couple of things struck me. The issue for architects in an Agile environment is their position and responsibility.
The thing with the change from waterfall to agile is that architects feel their role is being undercut, the team just goes fast and are only paying attention to the Product Owner. The standard answer they seem to get is: ‘then join the team’, but they feel reluctant to do so, and most of the times they can not fully commit (full time). So they pass, and they feel miserable about it, since now this Agile project is going to make mistakes, and can not learn from past experiences and their expertise.
The answer lies in the closer observation of the definition of Agile and Architecture.
Continue reading Architect in Scrum
Recently I had to adapt some older Java code to support a new requirement: an existing CSV report needed to include a user’s email address, translated from the user id. Pretty simple, but how does the CSV report generator translate the user id to an email address?
Continue reading Picking the right abstraction
Searching the web for new Agile games I came across: You sunk my Methodology. This game seemed like a strong metaphor to show the power of early feedback, while using Scrum.
Each shot costs 10.000 and when you sink a ship you get the_ships_size * 50.000 (e.g. the submarine of size 3 will reward you with 150.000). If you keep track of the balance after each iteration, you could also try to get across the idea that stopping after a few iterations might give ‘good enough’ rewards.
It can be downloaded from our GitHub repository as a zip or you can take a look at our code. Just double click on the index.html (in the public folder) to start a game.
**Update: Now also direct playable on GitHub.