Event Sourcing: To develop better?

Do you know that? They develop software (whether it is for the customer or for the internal expert department), and as soon as they are made, the first change and adaptation requests come: new tasks, more complex analysis, more reports and so on. And often the correct data often disappears, or the code adjustment is more complex and more pronounced as they should be. And this causes disappointment: with you and your users too.

Advertisement

But what if the software can be developed in such a way that such changes and extensions are very easy and more flexible? This is the same that is about today: We see why many systems are not made for these challenges and how we can solve it better. And if you want to become more flexible and more efficient in software development, then you are here.

How do we work with data

What is the problem? Perfectly as you work in which architecture you work, whether you develop a monolith, a client server system, a colleague-to-cum-solution, a distributed service-based application or something else-something is always the same. Is, ie data storage. Perhaps now you will answer that this will not be true, because at least not only will the relationship -database, but also storage NOSQL database and also and also, but one thing, but one thing is one thing: they always stool status quo.

Semgrep’s response: OpenGrep Open Code Analysis Ensures Tools

For example, if you write software for a library in which you can borrow, expand and return books, then it is very likely that the book is one for each book when it is included in the inventory. The data record will be made, and this is the data record when the book is borrowed, it is extended, extended or returned, and is finally removed, and finally removed, if, if it is removed, if The book is so torn at some point that it is removed from the stock. And it seems so logical and clear that you usually do not question whether it is really useful.

Crud …

But why does it look so logical and clear? Well, very simple: because we all got from an early age – whether you have done a training or studied, whether you are in the university of applied sciences or in a university, or with which programming language you grew up: Chances that you have learned to save the data in this way, that is, to make a data record, to change if necessary and finally to remove it at a point, is almost always given.

For this method of dealing with data, even a technical term, ie “crude”: which stands for “Create”, “Reed”, “Update” and “Delete”, ie four actions whose which With we get up in one can access database data. And it is actually found everywhere, whether you use a relationship database such as postgresql or Microsoft SQL server or whether you work with Nosql database such as Mongodb or Redis. And this is what I mean: The way we store data and handle the data are always the same.

… and his problems

First of all, it does not feel bad, as it has been clearly working without any problem for several decades. And the data is now created, replaced and removed. It is a universal principle. But: Where there is light, there is always shadow. And of course there are aspects that do not work well with this crude approach only. I am sure that you have experienced such a scenario at least once, namely: delete is not usually a particularly good idea.

Because if something is removed, it is later – surprise! – away. But this is often undesirable, as the user may have only clicked and would like to undo extinguished. The problem is only this: if the data is already gone, it should not be restored. What to do? Ok, you just don’t remove it, you have one IsDeleted-Plag, so instead of removing an update and puts on this flag true,

This can be undone on one side, and on the other, in the remaining applications, such marked data records can be easily ignored – so it seems as if they were actually removed. This means that we are technically an update that matches the removal from the technical point of view.

Technical vs. technical thinking

In fact, this is not completely correct, because from a technical point of view it is not about the “delete” of a book, but about the removal of a book from the inventory. Delete is only a word in database language that comes closest to this process, but if, for example, a person steals a book, it should also be removed from a technical point of view, which a removal (or more properly one Will also be updated) – Technical however, these are two completely different processes.

This means that we already have three levels: technical one in which a book is removed from the portfolio, technical one in which we include IsDeleted-Pred flag, and a third level that is somewhere in the middle and actually expresses technical intentions because we originally wanted to delete one.

And? Have I already managed to confuse you with it?

Misunderstanding

If so: Congratulations! If you think at the point that it is really quite complex for the trivial process, you are in a good company, because many developers are the same: we have managed to create three different linguistic levels for a banquet example. , For example a banquet, so that every time we talk about such procedures, we have to turn into the worst position twice. Misconception is definitely indispensable.

Massively, imagine it on a really large and complex application. Then an expert comes from the department and states that a certain process should be expanded, and they are considering what this person means because they are not familiar with technical language and think:

“Ah, this is definitely about the place where we remove a one!”

Then talk to someone who manages the database and is seen as if he came from another star when you have been told:

“We don’t delete here, we only update one.”

It is very happy to do everything and clarify what happens in the code now, with what intentions, why and why, and how and where and where. The misunderstanding is almost indispensable, because everyone speaks in any way, but no one really understands the concerned counterpart.