Effective Software Development for the Enterprise: Beyond Domain Driven Design, Software Architecture, and Extreme Programming 1st Edition Tengiz Tutisani download pdf
Effective Software Development for the Enterprise: Beyond Domain Driven Design, Software Architecture, and Extreme Programming 1st Edition Tengiz Tutisani download pdf
com
OR CLICK HERE
DOWLOAD NOW
https://ebookmass.com/product/flight-simulation-software-design-
development-and-testing-david-allerton/
ebookmass.com
https://ebookmass.com/product/latin-poetry-in-the-ancient-greek-
novels-daniel-jolowicz/
ebookmass.com
Women’s Private Practices of Knowledge Production in Early
Modern Europe 1st Edition Natacha Klein Käfer
https://ebookmass.com/product/womens-private-practices-of-knowledge-
production-in-early-modern-europe-1st-edition-natacha-klein-kafer/
ebookmass.com
https://ebookmass.com/product/humes-imagination-tito-magri/
ebookmass.com
https://ebookmass.com/product/tres-semanas-para-enamorarte-3-escocia-
contemporanea-1a-edition-nessa-mcdubh/
ebookmass.com
https://ebookmass.com/product/retail-management-5th-edition-gibson-e-
vedamani/
ebookmass.com
https://ebookmass.com/product/a-soul-to-steal-duskwalker-brides-book-
six-mm-opal-reyne/
ebookmass.com
(Original PDF) Intro Stats 5th Edition by Richard
https://ebookmass.com/product/original-pdf-intro-stats-5th-edition-by-
richard/
ebookmass.com
Ef fective Sof tware
Development for
the Enterprise
Beyond Domain Driven Design,
Software Architecture, and
Extreme Programming
—
Tengiz Tutisani
Effective Software
Development for the
Enterprise
Beyond Domain Driven Design,
Software Architecture,
and Extreme Programming
Tengiz Tutisani
Effective Software Development for the Enterprise: Beyond Domain Driven
Design, Software Architecture, and Extreme Programming
Tengiz Tutisani
Charlotte, NC, USA
Acknowledgments����������������������������������������������������������������������������xvii
Preface����������������������������������������������������������������������������������������������xix
Chapter 1: Introduction������������������������������������������������������������������������1
History of Inefficient Monoliths�����������������������������������������������������������������������������1
Why People Avoid Building Effective Software�����������������������������������������������������2
Learning Curve������������������������������������������������������������������������������������������������3
Quality over Quantity���������������������������������������������������������������������������������������3
Highly Paid Experts������������������������������������������������������������������������������������������5
Naive Hopes to Survive�����������������������������������������������������������������������������������5
Software Development Perfectionism as a State of Mind������������������������������������6
Is It Crazy?�������������������������������������������������������������������������������������������������������6
Desire Behind Perfectionism���������������������������������������������������������������������������7
Is It Worth It?���������������������������������������������������������������������������������������������������7
Six Pillars of Effective Software����������������������������������������������������������������������������8
#1. Meet Users’ Expectations��������������������������������������������������������������������������8
#2. Allow No Defects���������������������������������������������������������������������������������������9
#3. Scale Out Horizontally�����������������������������������������������������������������������������10
#4. Have No Dedicated Production Support Team�����������������������������������������11
v
Table of Contents
vi
Table of Contents
vii
Table of Contents
viii
Table of Contents
ix
Table of Contents
x
Table of Contents
Front-End Development�������������������������������������������������������������������������������215
Exception Handling��������������������������������������������������������������������������������������222
Testing Code�����������������������������������������������������������������������������������������������������226
Unit Testing��������������������������������������������������������������������������������������������������227
TDD, ATDD, and BDD������������������������������������������������������������������������������������230
Code Deployment and Maintenance�����������������������������������������������������������������232
CI/CD Before Development��������������������������������������������������������������������������232
Planning Deployment When Developing������������������������������������������������������233
Planning Maintenance When Developing����������������������������������������������������234
Summary����������������������������������������������������������������������������������������������������������234
xi
Table of Contents
Chapter 7: Deployment���������������������������������������������������������������������275
Culture of Releases�������������������������������������������������������������������������������������������276
Why Release Software?�������������������������������������������������������������������������������276
Unimportance of Releases���������������������������������������������������������������������������277
CI/CD—Deployment Foundation�����������������������������������������������������������������������280
Continuous Integration��������������������������������������������������������������������������������280
Continuous Deployment������������������������������������������������������������������������������282
Building Deployment-Ready Applications���������������������������������������������������������283
Developing Deployable Units�����������������������������������������������������������������������283
Ensuring Smooth Deployments via CI/CD����������������������������������������������������284
Dev–Prod Parity�������������������������������������������������������������������������������������������285
Effects of Containerization on Deployments������������������������������������������������286
Summary����������������������������������������������������������������������������������������������������������287
Afterword: Wrap-up��������������������������������������������������������������������������299
References����������������������������������������������������������������������������������������301
Index�������������������������������������������������������������������������������������������������315
xii
About the Author
Tengiz Tutisani has been in the software
development industry for over 20 years. His
experience ranges from startups to Fortune
500 corporations. He has held a variety of roles
in technology leadership (software engineer,
technical lead, development manager,
application architect, solutions architect,
enterprise architect, and chief architect).
Tengiz’s broad experience and frequent
recognition for outstanding quality and performance have convinced
him to teach others unique engineering and architecture techniques.
He authored this book to describe advanced techniques for professional
software development and architecture disciplines.
xiii
About the Technical Reviewer
Tom Graves has been an independent
consultant for more than four decades
in business transformation, enterprise
architecture, and knowledge management.
His clients in Europe, Australasia, and the
Americas cover a broad range of industries,
including banking, utilities, manufacturing,
logistics, engineering, media, telecoms, research, defense, and
government. He has a special interest in architectures beyond IT and
integration between IT-based and non-IT-based services.
xv
Acknowledgments
I want to acknowledge and thank the people who helped me make this
book a reality. I am grateful to every person that I mention here.
First, a big thank you goes to every individual who took time to read
the final manuscript of this book and wrote a short review, which will
be used in various ways to inform the readers about the book’s benefits:
Dave Black, Jim Hammond, Preeti Baranga, Lasha Kochoradze, Nugzar
Nebieridze, and Romana Stasiv.
Furthermore, I want to thank those who provided invaluable feedback
about the manuscript by noticing typos or unclear sentences or even
proofreading it: Dave Black, Jim Hammond, Gomti Mehta, Preeti Baranga,
and Romana Stasiv. I know that all of you went the extra mile to ensure that
this book reached its deserved quality. Without you, I am afraid that I would
have published text that would make me feel embarrassed in the future.
Additional gratitude goes toward the Apress editorial team, who guided
me through turning this publication into a polished piece of work worth
taking to the shelves and screens of a broad audience. The Apress team
includes Aditee Mirashi, Shobana Srinivasan, Mark Powers, James Markham,
and Sowmya Thodur. A special thank you goes to the technical reviewer,
Thomas Graves, who provided subject-matter expertise, challenging technical
questions, and feedback essential to taking the book to the next level.
Finally, my unmeasurable appreciation goes to my wife, Romana
Stasiv, who patiently supported me while I worked on the book, both the
initial manuscript and with Apress. I wrote the text once, but I rewrote
it about 150 times! Nobody would have tolerated so many long working
hours without genuine love connecting our hearts. Also, with Romana’s
Agile expertise, I received early feedback about many topics in this
publication, which helped me pave the road to the finish line.
xvii
Preface
Before getting into the book’s central chapters, I want to explain why
I wrote it to begin with, what you will learn, and how it will benefit you on
your path to building software solutions.
xix
Preface
***
At my first job, I was the only developer on a team. I had the freedom
to write code in any way I wanted, and that seemed to be a perfect
environment in which to thrive. I developed many applications and
components from scratch, and I enjoyed the freedom of improvising in
code. Everything was going smoothly until the codebase grew to the point
that I had a hard time working with it. I almost wanted to start it all over
again! It turns out that many developers struggle with the same issue
throughout their career paths.
How can the code that we wrote ourselves bite us back? There must be
something wrong with what we do, don’t you agree?
Therefore, we will learn how to write code that does not become our
problem shortly after we author it.
***
At my second job, I worked on a team consisting of a couple of
engineers, so I had a chance to read code written by other developers. It
was a rather complex banking domain, and I needed to learn it fast to keep
the job.
When such a challenge faces us, we realize that the codebase can
either be our friend or our enemy, depending on whether it helps or blocks
us from the goal.
I read a lot of code, but it did not give me any knowledge about the
domain. Instead, it confused me more and more as time passed. I could
only explain this complexity by believing that the code was not supposed
to be understood by people because it was written just for computers. That
was a naive thought.
xx
Preface
We are humans in the first place, so we should write code for humans.
Computers will understand code no matter how we write it. So writing a
program for them is a piece of cake. Try to write code that humans can
understand—that is a challenge!
Therefore, we will learn how to write code that expresses valuable domain
knowledge and is readable by technical learners of the problem space.
***
I once worked on a project where developers had good knowledge of a
problem space, and specialists in the subject matter were also accessible.
However, meetings occurred in silos instead of leveraging access to
domain knowledge. First, a domain expert would describe a requirement
in business terms; next, the conversation would transfer to the developers,
while domain experts did not (or could not) participate in the discussion
from that point on. Engineers would “interpret” the expectation using
technical concepts, patterns, and frameworks, and would use their
terminology and tools for implementation. Because of this intentional
disconnect, the resulting solution was too technical and often had little or
no relevance to how the business worked; instead, it added inconvenience
and complexity for business SMEs (Subject Matter Experts).
Therefore, we will learn how to write software that serves both
developers and non-developers equally. It is time that we start helping
business colleagues instead of complicating their lives.
***
One more project comes to mind. We could not focus on new feature
development because the defects were frequent. We had to jump on them
as they appeared due to the high visibility of the application. We would fix
errors and then go back to our current sprint (iteration) backlog, and we
just knew that the next bug was hours, if not minutes, away. Consequently,
new feature development went slowly and was unorganized.
xxi
Preface
***
I remember the tired face of an engineer who was tasked with
supporting an application in a production environment. He did not even
write that software and did not know all the intricacies inside the system.
He had to keep bugging an actual development team with questions
when a new kind of issue was discovered. He had a handbook full of
troubleshooting steps for various types of symptoms that the application
could produce. He was hesitant to contact the development team every
time because the engineers were “cool guys” who had more important
tasks than to support the application (written by them in the first place).
As you can imagine, the mentioned system was a nightmare to run and
troubleshoot. In my mind, the root cause was developers’ being unaware
of production support’s pain points and lacking the necessary skills for
producing better software that would be easier to maintain.
Would the outcome be different if developers had to run and support
their solutions in a production environment instead of somebody else
doing it for them?
To tackle the described problem, we will learn how to build software
that works in a production environment without a dedicated production
support team by distilling ways to develop better programs and maintain
them in production with minimal to no cost.
***
xxii
Preface
***
I recently encountered a web application that was deployed to three
servers to handle many parallel requests. Surprisingly to engineers
and their management, the system was struggling to serve only 100
simultaneous users. They tried to add more servers, but even more
strangely, it only worsened the situation. As a last resort, the team
rearchitected the application for better scalability, but that exposed other
bottlenecks, complicating the goal of reaching more users.
When such circumstances happen, you need to admit that your
application is not scalable.
Therefore, we will learn how to build software that scales out
horizontally by adding more instances of the application when the number
of users increases.
***
These situations just described served as a foundation for the six
primary pillars upon which this book is built. We will go into more detail in
the next section.
xxiii
Preface
For now, I hope that most of you either recognized your experience or
felt an urge to solve these kinds of problems at present or in the future.
2. Has no defects.
You must remember these items because they form the foundation of
this book. If my writing is successful, you should see that each chapter or
section targets at least one of these points.
Throughout the book, I will be referring to these items in various ways
interchangeably: “six pillars of effective software,” “six elements of quality,”
and so on.
I will go into slightly more detail about each of the mentioned elements
in the next chapters, thus helping you understand why they are essential.
xxiv
Preface
xxv
Preface
For all those synergies that I just described, the book in front of you
can become a supporting mechanism when implementing SAFe or other
organizational process initiatives.
xxvi
Preface
xxvii
Preface
The topic of crosscutting concerns will precede the rest of the subjects.
This order is essential because most crosscutting solutions do not fit
into any of the typical stages but still require attention beforehand to
agree on fundamental assumptions. Afterward, diving into each step of
software development will uncover and address various concerns within
those areas.
At the end of the book, I have included references to reading materials
that support this publication. A link to a reference is a codename enclosed
with square brackets. For example, [Tutisani web] is a link to my website,
which you can find in the references under the “Tutisani web” codename.
An index with keywords is the last piece of this publication, which will
help you find specific terms in the book’s text.
Enjoy your reading!
xxviii
CHAPTER 1
Introduction
In this chapter, I want to examine the fundamental ideas surrounding the
building of effective software. Presented topics will range from historical
reasons for the industry’s problems to decisions of avoiding or accepting
ideal solutions. Additionally, I offer a deep dive into the definition of
effective software that I briefly introduced in the preface.
2
Chapter 1 Introduction
out, people still hesitate, and I will explain some of the typical reasons for
this. I want to present these challenges to encourage you to overcome them
and to set realistic expectations.
Before we go any further, you should know that you have chosen not
an easy path for yourself, but also not an impossible one. I have a rather
low level of risk tolerance, and my suggestions are reasonable to me, which
should further assure you that matters are not hopeless at all. Instead, it is
my responsibility to tell you what to expect when attempting to build ideal
software solutions.
Learning Curve
I have collected the necessary skills to build effective software throughout
my career. At the time of this writing, that is more than 17 years.
Admittedly, it took me so long because I was not always sure what I was
seeking—I made up my mind on the way. Nevertheless, all the techniques
needed to build such a high-quality product are scattered everywhere—
process, technology, concepts, patterns, project management, testing,
development, architecture, and so on. While this book should help you
navigate your way in the universe of endless knowledge and information, it
will not shorten the journey drastically. It is just not possible. There is thus
a significant learning curve behind the effort of building effective software.
I am glad that you are still going for it, as not everybody does.
3
Chapter 1 Introduction
So, you are not giving up quantity for quality as long as your project
lasts for at least a couple of months. However, the misconception still exists
that effective software requires a sacrifice of quantity to attain quality.
4
Chapter 1 Introduction
5
Chapter 1 Introduction
Is It Crazy?
When you introduce something new and utterly different from everything
else, it may seem crazy. I do not want to take too much credit, but it is
similar to the effect of inventing electricity or discovering that the earth is
round and not flat. Those ideas were once considered crazy. Therefore, if
we want to improve, we must give a chance to new proposals.
I do what I teach in this book daily. Nobody thinks that I am crazy. So,
it is not so scary to try it.
6
Chapter 1 Introduction
If you worry that others will see you as stubborn, I assure you, that is
not what I am advocating. This book is only a collection of knowledge that
can improve your skills. The rest depends on how far you want to take it in
practice.
7
Chapter 1 Introduction
2. Allow no defects.
While these pillars express the intent, they can also create confusion,
disagreement, and resistance. This split in opinion happens because
each of us is unique, and we look at things differently. Some will say that
the problems I try to fix do not exist at all; others will say that there is no
solution to them, or that I am not solving the right issue.
To align our vision, I want to clarify what each pillar means.
8
Chapter 1 Introduction
If not for all this overhead with defects, you could focus more on new
feature development. Furthermore, defects create discontent for both the
customers and the developers.
9
Chapter 1 Introduction
10
Chapter 1 Introduction
11
Chapter 1 Introduction
Summary
This was quite an introduction. We glanced at both the hesitations and
enthusiasm behind building effective software and what it is that we aim to
deliver.
In the next chapter, we will look at commonly overlooked subjects vital
to delivering needed outcomes, such as leadership, people, and culture.
12
CHAPTER 2
Cross-cutting
Concerns
Building effective solutions is not only about writing code or architecting
systems; this process relies heavily on leadership, operations,
organizational structure, and even internal politics. Ignoring these vital
aspects is comparable to dismissing the weather forecast when predicting
the quality of harvesting season.
Experience has proven that an effective technology transformation
has to be driven by leadership. No matter how hard engineers try, their
attempts will not suffice against a wall of political resistance. Hence,
I will start this chapter with recommendations applicable to leaders and
managers.
After leadership accepts the importance of their role in the act of
producing high-quality software, it is time to rethink other supporting
factors for positive outcomes. The organization’s shape and processes
within it must aid the optimal flow of information, growth, and scale; this
reasoning puts the mentioned topics on our radar. Finally, we will drill into
culture and people as they are essential constituents of organizations. This
thread of thought guides the structure of the chapter.
14
Chapter 2 Cross-cutting Concerns
15
Random documents with unrelated
content Scribd suggests to you:
The Elias Hasket Derby House
Among all the residences of Old Salem, that which was most
ambitious and pretentious no longer exists, save in picture and
memory. This was the famous mansion built by McIntire in 1798 for
Elias Hasket Derby, Salem’s greatest merchant, at a cost of $80,000.
Derby lived only a few months after taking possession, and the
upkeep of so expensive an establishment deterring prospective
purchasers, this splendid house was dismantled and finally razed in
1815—the land being donated to the town for a public market. Derby
Square, where the present Market House now stands, was the
location of the famous house.
McIntire was in 1804 erecting a house at 142 Federal Street for
Captain Cook. Business reverses greatly delayed its completion, and
McIntire continued it at his leisure, taking advantage of the
dismantling of the Derby mansion to utilize much of its beautifully
carved woodwork in the interior. The result was the Cook-Oliver
house, as it is now known—one of the most satisfying to the artistic
sense of any in all Salem.
Existing plans and sketches of the Derby mansion show us a huge
rectangular building, suggesting a court-house, or some such public
structure, standing well back from the street, its great doorway
flanked by double columns supporting a balustraded balcony. Above
this is a splendid Palladian window, and above this again hand-
tooled festoons of drapery. The door itself has ornate fanlight with
side-lights to correspond, and stands at the head of a flight of
massive steps.
The flat roof with its elaborate cornice and heavy balustrade is
supported by pilasters, six in number, having carved capitals; and
these in turn at the second floor level rest upon plain pilasters. A
huge cupola surmounts the roof, with bell-shaped top, carved
garlands, and arched windows. The lintels of the first two tiers of the
house windows are heavy with ornament, while the third tier
illustrates the familiar plan of foreshortening. A great deal of iron
fencing with ornamental posts surrounds the spacious yard.
With all the prodigality of architectural detail embodied in this great
mansion, it must still be admitted that it was not overdone, as the
large proportions and wide spaces pleasantly distributed the
ornamentation over a broad field.
The Derby mansion doubtless represented the climax of effort in
the line of house-building in Salem—the sudden death of its owner,
followed by its own demolition, being a melancholy comment upon
the uncertainty of human plans.
The Neal-Kittridge-Rogers House
Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.
ebookmass.com