I, like a lot of people, find themselves working in the IT sector despite previous work experience and education to the contrary. While there is certainly a place for educated technicians and professionals to flourish and succeed, alongside me are a number of people with degrees and practice in vastly different fields—psychology, chemistry, humanties, etc. That being said, having a strong technical background can make a huge difference. And it is with that hope I embarked upon Dominic Duggan’s Enterprise Software Architecture & Design: Entities, Services, and Resources (2012).
And ‘embark’ is the correct word. Not an Enterprise Architecture for Idiots, the book assumes a basic knowledge and understanding of the components and interaction of IT, goes about presenting its subject matter in dense, technical fashion, and assumes you will keep up. There are brief examples, but the motherload of content is abstract in the descriptive sense. Each word and sentence requires fitting together into the described structure or pattern, something which Duggan does effectively if not without many practical examples. Likewise, the text requires revision to remind one’s self what certain acronyms mean, and likely for some with only a basic knowledge of IT, additional research online for some of the core principles. With a good portion of the text bound in programming and protocol language, it is not for the faint of heart. Here is an example:
“Unlike agile software development, the objective is to model domain concepts as object-oriented software abstractions, rather than to provide early executable code realizations from requirements analysis. The resulting software design is recognized as the domain model—the code itself is the realization of that model.”
And that is not even to mention the pages of computer code, network protocol languages, etc.
What is covered in the book? Well, as the title indicates, Duggan goes over the major and minor components of modern enterprise IT architecture. From networking (protocols, messaging, routing, etc.) to the differing methods/philosophies of how to configure hardware (service oriented, RESTful, domain driven, SaaS, etc.), all in strong, technical detail. Duggan provides excellent footnotes and a full list of references at the end of every chapter for further investigation.
In the end, Enterprise Software Architecture & Design was a difficult and partially rewarding journey (again, ‘embark’). I stuck with it, forcing myself through each word and sentence, taking notes, and slowly building a broader understanding of the IT systems we all use and interact with everyday, yet think nothing of—even for many, many people working in the IT field. A lot of people are afraid of the complexity of IT, and this book defines why that stereotype is valid. Duggan does not provide many practical examples backing the theory, but the information is all there, waiting to be parsed. As such, the book is probably best used in a university setting where a professor can elaborate the theory with real-world examples. I imagine something like Enterprise Architecture for Dummies (if such a thing exists) would be a better, more approachable option for most people looking to get an better understanding. But for the ambitious, dedicated person, there is value tucked away.