#begin

Last summer I was finally able to grab a copy of this book: Object-Oriented Software Engineering, A Use Case Driven Approach by Ivar Jacobson, Magnus Christerson, Patrik Jonsson and Gunnar Övergaard. Since the book is quite pricey, I had been scouring websites of second hand book dealers for a long time, and I finally was able to get a (1th edition, hard cover :D) copy.

I did not have the time to start reading it then, but recently I have found some free time here and there to start digging into the book. This book has been on my radar for a long time since it is praised a lot in the software craftsmanship community and I think it is one of the first books that presents an approach that really looks at the architecture of a software system based on it’s Use Cases. It also provides you with a project workflow, strategies and implementation principles. This is also the book where Uncle Bob based his entire Clean architecture approach on. Plus you can see how other VerticalSlice-Union-Hexagonal-Ports-and-adapter’ish architectures have taken great inspiration from it.

I will write a full review for this book once I have read it front-to-cover. However, I read something really interesting which I want to document for myself, and for you, the reader of course.

In Chapter 7; Analysis, section 7.3.2 there is a short mention of “different strategies how to allocate functionality” in a system. Here, the authors shortly describe what types of control might exist in a particular system. I thought this was really interesting since I’ve never read any other literature that presents control in a system in such a clear way.

Control

So they mention 4 types of control; computation dominant, dialogue dominant, mixed and balanced control. Let’s discuss all four of them.

Computation Dominant Control

Computational dominant, or embedded control is when we place the most functionality that controls the system internal to the system. This means that the system itself does most, if not all of the work. In these kind of systems, the User Interface is minimal and does not have much functionality. This way of structuring the system can be very efficient in execution but very difficult to prototype. Because you have to write all the functionality first, before you are able to experiment through for example a simple User Interface.

Dialogue Dominant Control

Dialogue dominant control is really the opposite of computational control; this is where lots of the functionality is placed in the User Interface to model the system. So in this case, there is not much internal logic going on since most control is exposed to the user. This strategy can be very easy to prototype , but it increases the complexity of the User Interface a great deal because for example the levels of abstraction mix.

Mixed Control

Mixed control places the control on both sides of the spectrum; so allowing for invocations through the User Interface  and allowing it from the computational / internal side. This offers flexibility but requires discipline to maintain the independence of the User Interfaces.

Balanced Control

Balanced control is where we abstract out the “control” parts of the system into it’s own objects. These objects then govern both the User Interface and the computation. So in this case the User Interface provides the user with just enough to do his work, and the computation takes place guided by control objects that we, as developers, create and abstract. In the case that is presented in this book, those objects are the Use Case objects. In Clear Architecture they are called Interactors. And other architectures all have their own name for this kind of object.

Further Reading

So of-course I will recommend you to read the entire book, but it’s a big sucker so that might going to take a while. As for now, I have to say it’s a really interesting book to read. I’ve had a couple of A-H Moments where I remember studying things in school yet without the background presented in this book. I think we have all heard of Use Cases, yet not in the way presented here. Which is pretty weird because this is how they were originally presented!

There is also more reading to do when you are interested in the sequential dialogue control I layed out here. The book refers to an entire paper about it which you can read here: hartson_human-computer_interface_development_concepts_and_systems. It’s an old paper, but as with many other “old” computer science literature it is really interesting to read!

#end

01010010 01110101 01100010 01100101 01101110