While I always rigorously stick to my preferred template structure in my architecture documentation, the design process is not always strictly in the order of the chapters. This ‘journal’ is an example of the ‘creative’ design process.
Having written the enterprise architecture canvas article I realized that I could use a tool that helps me keep track of the elements of any enterprise architecture.
So, first step is to outline an information model that can represent the elements on the canvas:
It extends the enterprise architecture canvas to also cover software requirements, which helps when developing new or maintaining existing solutions.
Based on the information model, the next step is to outline a page structure for a web application:
While I often go for single-page-applications, entities will manage large quantities of items organized in a complex structure. And ideally, multiple users will work on different parts simultaneously, which makes me lean towards a more traditional multi-page web application.
Today I need to consider concurrency aspects of a multi-user application. Multiple users may find themselves editing the same entity at the same time, either editing its properties or adding/removing some of its children.
One such conflict occurs when two different users both rename a process entity almost simultaneously, but to two different names.
When the first user starts editing the process (changing its name), a new draft version of the process entity is created. When the second user starts editing the same entity, yet another new draft version of the process entity is created.
The user who saves his or her edit first, will update the master process entity, and the draft is deleted. The second user can’t just save his or her edit, because the draft version contains outdated attribute values. So, the the second user must first refresh his or her draft with the recent updated master, and chose between the recently updated process name or the name he or she is trying to save.
Another scenario is that two users each add a child capability under a capability entity, for example one adds “Online sales” under “Sales” and another adds “Shop sales”. When the first user saves the added “Online sales”, it’s added to the master and the draft version is deleted. When the second user saves the added “Shop sales”, the master capability is silently updated with the additional child capability.
Having pondered concurrency issues for a while, and acknowledging its enormous impact on the complexity of the design – and being realistic about the chances of ever attracting other users, I’m deciding to circumvent the issue by not allowing multiple users editing the same data altogether. This also allows me to exclude functionality for user registration and subscription billing.