In our previous post on Hexagonal Architecture in a
back-end, we mentioned wrapping ID
generation and timestamps in concepts of their own. This might feel a bit
over-designed, but we have reasons to do so. In this post, we share the
trade-offs and rationale behind wrapping the standard stuff in abstractions of
your own.
Read More
Hexagonal Architecture allows us to continuously evolve a web back-end. In this
post, we’ll show you how we do that. It is a continuation of a series, previous
instalments demonstrated how Hexagonal architecture facilitates automated test
architecture, and development of a Vue.js
based front-end. In this post, we
will share how we applied it in the back-end for the Online Agile Fluency
Diagnostic application.
Read More
Deciding What To Put Where is half of the work of software development. What
should I put where, in such a way that me and my colleagues will be able to
find it back later? Finding a good place for things in code greatly helps or
hinders maintainability of the code later on.
Read More
We are fans of Test Driven Development (TDD). It has served us well over the
years. The TDD cycle - test, fail, run, refactor - is all about getting rich
feedback fast, feedback about design decisions, about the test, about your code.
We thrive on fast tests. We also want to test-drive our adapter integration and
UI tests. These tend to be slow and fragile with low quality feedback, so we try
to keep these minimal.
Read More
In this next post in our series on Dimensional Planning, we will share how we
applied Dimensional Planning to the Online Agile Fluency® Diagnostic application
we have been working on since spring.
Read More
In a previous post, we introduced the Dimensional Planning
technique, and shared how we used this
for a product we worked on. In
this post, we will go more in depth and show how you can use the roads metaphor
not only for releases of a product, but for individual features as well. This
provides a fine-grained mechanism for planning and delivering small, valuable
increments.
Read More
So you want to quickly deploy a small experiment to production. How do you do
that? Dokku is one way of doing that. Here
are my first impressions.
Read More
Are you regularly holding retrospectives, but they do not result in
improvements? In this post we will highlight how a team can move to a virtuous
cycle of continuous improvement.
Read More
Imagine your UI and end-to-end tests could run an order of magnitude faster than
they are now? Oh, you don’t have end-to-end tests, because they would be too
slow and brittle? I have had that too, don’t worry. Imagine then if you could
have cost-effective end-to-end tests. How would that impact your product
development?
Read More
When we visit clients and discuss the architecture of their software systems, we
often notice that people conflate different concerns under the term
‘architecture’. They tend to mix logical concerns with deployment concerns.
Examples of logical concerns would be domain logic, domain dynamics, and how
these are connected. Deployment concerns can be for instance REST APIs,
components, microservices, and lambdas. The recent ‘cloud native’ movement has made this
even worse, especially with serverless infrastructure concepts.
Read More
Imagine you grow a suite of automated tests that serve you well, but you are struggling to read through them. Quite a bit of repetition and boilerplate that obfuscates what is going on in individual tests. Builder is a pattern that lets our tests reveal their intent more succinctly, at the cost of making a small investment in creating a builder for our domain concept under test.
Read More
Testing a command line interface (CLI) should be just like testing a REST interface. A CLI is an adapter concern that we can test drive, separate from the business logic. In this post I’ll show an approach to test drive the command line interface of an application in Python.
Read More
In this post, we will explain how Dimensional Planning can work by sharing a story of how we
applied it in a project and how it helped
us to steer the project towards delivering its desired outcomes in time.
Read More
I was wondering if Lean Agile Exchange on 10 and 11 September would be as much a Community of Need
conference as e.g. Lean Agile Scotland or Agile Cambridge were. I was not disappointed.
Read More
In a previous post, we elaborated on why and how we apply Hexagonal Architecture in front end applications.
Read More
In this post, we will share another benefit of looking through the Hexagonal Architecture lens: it supports making decisions about the architecture of automated tests in your application landscape. It can guide you in questions like:
Read More
Front ends tend to start out simple, often as ‘just’ a form or a grid showing data that comes from a backend. It looks like ‘just’ a visual layer on top of backend APIs. When a front end evolves and grows, it inevitably becomes more complex. We then need to take a good hard look at the UX/UI and overall architecture.
Read More
Upaated 21 november 2020, added some more notes on Simon Wardleys segment.
Read More
Continuous delivery is valuable, but where do you start? At the start of
a greenfield development you have no software, and if you had any
software, you would not know how to put it into production.
Read More
Starting new product development with the question ‘What can we leave out?’ may
seem paradoxical. We do this to start a conversation between customers and
developers. As we go we develop a shared language, so that value can be delivered
early and often. This is called Dimensional Planning.
Read More
Over the years, we have done our share of UI and front end development. Long long time ago with SmallTalk, Visual Basic and Delphi, building web applications with server side rendering and React, and being involved in Angular projects at several clients. Recently we have been building front ends based on Vue.js. In a series of blog posts, we are going to share how we approach (hexagonal) architecture, test driven development, and incremental design in the front end.
Read More
Us three, having fallen into a conversation with code:
Read More
Hexagonal Architecture, also known as Ports and Adapters, is getting quite a bit of (well-deserved!) attention recently, especially in the Domain Driven Design community. Hexagonal Architecture is not a new thing: it was originally thought up by Alistair Cockburn (of Agile Manifesto fame) in the 90ies.
Read More
We are sponsoring the Lean Agile Exchange Conference happening online, 10 and 11 September (UK daytime).
Read More
Even when it doesn’t feel like it.
Read More
I enjoyed watching Container Solutions’ Jamie Dobson present an introduction to
their pattern language for strategy yesterday, titled “A
framework for strategy, making decisions in turbulent times”. I recommend viewing the recording, ‘A Pattern Language for Strategy’. Below are my main takeaways.
Read More
Work has, once again for me, become more personal. I’m getting back into
writing. This is a quick, rambling, update, so you can at least get some idea of what we are up to
at the moment.
Read More
Yesterday I thought I pushed out another iteration of our attempt at making the
QWAN website more accessible. Turns out I didn’t. While adjusting details,
reading CSS and accessibility documentation and blogposts, I missed the fact
that the shiny assets pipeline I added does not actually build on github.
Read More
Happy new year! We are restarting open enrollment courses this year. The first one up is our test driven Java course. This will take place in Utrecht, Netherlands in March 19 and 20 in 2020.
Read More
Marc and Rob are running a Hexagonal Architecture workshop this thursday at XP Days Benelux, tickets for XP Days have sold out, but apparently there is a waitlist. So who knows, you still might be able to get a ticket.
Read More
Rob and I participated in the brand new Agile Camp NL conference, a open-space-y conference on agile.
Kudos to Karlijn Moll & Thomas van Zuijlen for running the conference and creating such a nice atmosphere!
Read More
The QWAN site currently is not accessible for blind users. If you were to use a screen reader, the page might just as well be blank. A blind colleague mentioned to us a while ago that they could not read the home page at all. I have just started improving it.
Read More
To remind myself that I often find it easier to encourage others to change than to change myself, I have been using change is for other people as a mantra,
Read More
I was planning to use my keys left for something different today, but found myself in an associative storm of tweets, possible conference sessions to be proposed and some situated software I’ve been working on for a few years, intermittently.
Read More
For a production application I’m using PUX, a purescript wrapper around React. In the way we use it for WeReview we are experiencing performance and usability issues, beyond the slow rendering.
Read More
Red-Green-Refactor is broken, because the psychological reward happens at green. When you get that reward, you feel the task has been completed, and are inclined to stop. Therefore refactoring is a lot rarer than it should be.
Read More
Feature toggles - no thank you, I would rather ship piecemeal.
Read More
TLDR When you want others to improve how feedback loops work in your organisation, it is very effective
to amplify things that work in other groups. Liz Keogh pointed this out during Elizabeth Hendricskson’s session care and feeding of feedback loops at eXtreme Tuesday Club London two weeks ago.
Read More
Hot reloading a Halogen app with Parcel requires almost no configuration. Demo
Read More
Do you have pending tests left over from yesterday? Better delete them before they grow stale.
Read More
A liveblog of Don Reinertsens’ Agile Cambridge keynote
Read More
liveblog: the accidental sysadmin (starting at 28 minutes into the session)
Read More
This is the second part of my writeup of the session I did at XPDays Benelux and XP 2016 in
Edinburgh called “Bourne Again” on bootstrapping a unit testing framework
in the Bourne Again Shell (bash). This series of posts walk you through the
steps I took in 75 minutes of programming.
Read More
Here are some things we (re)found worthwile reading this week.
Read More
Here are seven things we found interesting reading for this week.
Read More
I did a public programming session at XPDays Benelux and XP 2016 in
Edinburgh called “Bourne Again” on bootstrapping a unit testing framework
in the Bourne Again Shell (bash). This series of posts walk you through the
steps I took in 75 minutes of programming.
Read More
A live blog of Mary Poppendieck’s xp2016 keynote.
Read More
Elizabeth Hendrickson keynoting on eXtreme programming at scale, XP2016 Edinburgh. Elizabeth works as VP R&D for
Cloud foundry development at Pivotal.
Read More
Last week Rob, Marc and I went to Software Circus, a
new conference on programmable infrastructure.
Read More
A Mass Pairing is a coding dojo that takes over all sessions for a slot
during a conference. We’ve found it a great way to introduce
participants to each other, and explore an aspect of programming at a
conference. We had some pleasant suprrises, and still have some questions.
Read More
I’m glad to be part of the organizing cabal behind FP Days
London this
year. I hope to have some time to go to sessions. I’ve programmed in
Clojure, Scala and Haskell this year, and there’s something from all of
that on the programme, and it’s cool to be able to find out more about
languages I haven’t used in anger yet like F# and Erlang.
Read More
So we are trying
a leaner way of creating conference
programs .
How is it going so far with /dev/summer, the free one day event for
developers? We took just two weeks to advertise the program
of /dev/summer. Not too bad. We’re not
facing a deluge of sessions on one hand, on the other hand, we got some
nice sessions coming in, so after tomorrow night we probably can put
together a program without turning many sessions away. On the one hand
it’s great if you can be selective, on the other hand, it feels wasteful
to have people propose and review sessions and then only run half or
less of them. On the other, other hand, this also enables us to give
feedback fast to the presenters.
Read More
I’ve received a few questions as to what we are exactly looking for in
/dev/summer talks or sessions. Imagine you are talking to another
developer about what you do (can be a tool you use or make, a practice
etc.). This developer may or may not have heard about your tool, but has
not had the time to explore it in depth, let alone try it out in a real
situation.
Read More
We’ve always been active in the UK, even more so now Willem has moved to
the UK (although he is doing work on the continent as well).
Read More
I’ve been wondering for a long time if many of the review cycles for
conferences are not overly long. For instance,
Rob and Marc are involved in XP Days
Benelux.
The XP Days call for
sessions
opened today. The conference itself is more than half a year from now.
If you propose a session today, will you be as interested in the topic
half a year from now, or are you occupied by something else?
Read More
Inspired by Ollie Charles 24 days of Hackage, I decided to try my hand at writing a series of daily blog posts about my experience developing a web application in Haskell.
Read More
A hands on tutorial at the upcoming Joy of Coding conference in Rotterdam, The Netherlands, on March 7.
Read More
This week Willem and I presented at the Modern Management Methods
NL conference (formerly known as Lean Kanban NL). We did a presentation
about applying frameworks like Cynefin to make sense of what’s
happening, in your team, your project, your organisation…
Read More