Rigidity. Rigidity is the tendency

Rigidity.
Rigidity is the tendency for software to be difficult to change, even in
simple ways. Every change causes a cascade of subsequent changes in dependent
modules. What begins as a simple two day change to one module grows into a multi-
week marathon of change in module after module as the engineers chase the thread of
the change through the application.
When software behaves this way, managers fear to allow engineers to fix non-critical
problems. This reluctance derives from the fact that they don’t know, with any reli-
ability, when the engineers will be finished. If the managers turn the engineers loose
on such problems, they may disappear for long periods of time. The software design
begins to take on some characteristics of a roach motel -- engineers check in, but they
don’t check out.
When the manager’s fears become so acute that they refuse to allow changes to soft-
ware, official rigidity sets in. Thus, what starts as a design deficiency, winds up being
adverse management policy.
Fragility.
Closely related to rigidity is fragility. Fragility is the tendency of the
software to break in many places every time it is changed. Often the breakage occurs
in areas that have no conceptual relationship with the area that was changed. Such
errors fill the hearts of managers with foreboding. Every time they authorize a fix,
they fear that the software will break in some unexpected way.
As the fragility becomes worse, the probability of breakage increases with time,
asymptotically approaching 1. Such software is impossible to maintain. Every fix
makes it worse, introducing more problems than are solved.
Robert C. Martin
Copyright (c) 2000 by Robert C. Martin. All Rights Reserved
.
www.objectmentor.com
3
Such software causes managers and customers to suspect that the developers have lost
control of their software. Distrust reigns, and credibility is lost.
Immobility.
Immobility is the inability to reuse software from other projects or
from parts of the same project. It often happens that one engineer will discover that he
needs a module that is similar to one that another engineer wrote. However, it also
often happens that the module in question has too much baggage that it depends upon.
After much work, the engineers discover that the work and risk required to separate
the desirable parts of the software from the undesirable parts are too great to tolerate.
And so the software is simply rewritten instead of reused.
Viscosity.
Viscosity comes in two forms: viscosity of the design, and viscosity of
the environment. When faced with a change, engineers usually find more than one
way to make the change. Some of the ways preserve the design, others do not (i.e.
they are hacks.) When the design preserving methods are harder to employ than the
hacks, then the viscosity of the design is high. It is easy to do the wrong thing, but
hard to do the right thing.
Viscosity of environment comes about when the development environment is slow
and inefficient. For example, if compile times are very long, engineers will be
tempted to make changes that don’t force large recompiles, even though those
changes are not optiimal from a design point of view. If the source code control sys-
tem requires hours to check in just a few files, then engineers will be tempted to make
changes that require as few check-ins as possible, regardless of whether the design is
preserved.
These four symptoms are the tell-tale signs of poor architecture. Any application that
exhibits them is suffering from a design that is rotting from the inside out. But what
causes that rot to take place

Results (Indonesian) 2:

Kekakuan.
Kekakuan adalah kecenderungan untuk perangkat lunak menjadi sulit untuk mengubah, bahkan dalam
cara sederhana. Setiap perubahan menyebabkan kaskade perubahan berikutnya dalam tergantung
modul. Apa yang dimulai sebagai perubahan dua hari sederhana untuk satu modul tumbuh menjadi multi
minggu maraton perubahan dalam modul setelah modul sebagai insinyur mengejar benang dari
perubahan melalui aplikasi.
Ketika software berperilaku dengan cara ini, manajer takut untuk memungkinkan para insinyur untuk memperbaiki non-kritis
masalah. Keengganan ini berasal dari fakta bahwa mereka tidak tahu, dengan-agama
kemampuan, ketika para insinyur akan selesai. Jika manajer mengubah insinyur longgar
pada masalah tersebut, mereka mungkin menghilang untuk jangka waktu yang lama. Desain perangkat lunak
mulai mengambil beberapa karakteristik dari sebuah motel roach - insinyur check-in, tetapi mereka
tidak memeriksa.
Ketika ketakutan manajer menjadi begitu akut yang mereka menolak untuk memungkinkan perubahan lunak
ware, kekakuan set resmi. Jadi, apa yang dimulai sebagai kekurangan desain, sampai menjadi
merugikan kebijakan manajemen.
Kerapuhan.
Terkait erat dengan kekakuan adalah kerapuhan. Kerapuhan adalah kecenderungan
software untuk istirahat di banyak tempat setiap kali berubah. Seringkali kerusakan yang terjadi
di daerah yang tidak memiliki hubungan konseptual dengan daerah yang berubah. Seperti
kesalahan mengisi hati manajer dengan firasat. Setiap kali mereka mengotorisasi memperbaiki,
mereka takut bahwa perangkat lunak akan mematahkan dalam beberapa cara yang tak terduga.
Seperti kerapuhan menjadi lebih buruk, kemungkinan kerusakan meningkat dengan waktu,
asimtotik mendekati 1. Perangkat lunak tersebut adalah mustahil untuk mempertahankan. Setiap memperbaiki
membuatnya lebih buruk, memperkenalkan lebih banyak masalah daripada yang dipecahkan.
Robert C. Martin
Copyright (c) 2000 oleh Robert C. Martin. All Rights
Reserved.
Www.objectmentor.com
3
Perangkat lunak tersebut menyebabkan manajer dan pelanggan untuk menduga bahwa pengembang telah kehilangan
kendali atas perangkat lunak mereka. Ketidakpercayaan memerintah, dan kredibilitas hilang.
Imobilitas.
Imobilitas adalah ketidakmampuan untuk menggunakan kembali perangkat lunak dari proyek-proyek lain atau
dari bagian proyek yang sama. Sering terjadi bahwa salah satu insinyur akan menemukan bahwa ia
membutuhkan modul yang mirip dengan salah satu yang insinyur lain menulis. Namun, juga
sering terjadi bahwa modul tersebut memiliki terlalu banyak bagasi yang itu tergantung pada.
Setelah banyak pekerjaan, para insinyur menemukan bahwa kerja dan risiko diperlukan untuk memisahkan
bagian-bagian yang diinginkan dari perangkat lunak dari bagian-bagian yang tidak diinginkan yang terlalu besar untuk mentolerir .
Dan sehingga perangkat lunak hanya ditulis ulang bukannya digunakan kembali.
Viskositas.
Viskositas datang dalam dua bentuk: viskositas desain, dan viskositas
lingkungan. Ketika dihadapkan dengan perubahan, insinyur biasanya menemukan lebih dari satu
cara untuk membuat perubahan. Beberapa cara melestarikan desain, yang lainnya tidak (yaitu
mereka hacks.) Ketika metode desain melestarikan lebih sulit untuk mempekerjakan daripada
hacks, maka viskositas dari desain adalah tinggi. Sangat mudah untuk melakukan hal yang salah, tetapi
sulit untuk melakukan hal yang benar.
Viskositas lingkungan timbul pada saat lingkungan pengembangan lambat
dan tidak efisien. Misalnya, jika kali kompilasi yang sangat panjang, insinyur akan
tergoda untuk melakukan perubahan yang tidak memaksa recompiles besar, meskipun mereka
perubahan tidak optiimal dari sudut pandang desain. Jika kode kontrol sumber sistemik
tem membutuhkan jam untuk check-in hanya beberapa file, maka insinyur akan tergoda untuk membuat
perubahan yang memerlukan sedikitnya check-in mungkin, terlepas dari apakah desain yang
diawetkan.
Keempat gejala kirim yang tanda-tanda -tale arsitektur miskin. Setiap aplikasi yang
menunjukkan mereka menderita desain yang membusuk dari dalam ke luar. Tapi apa
yang menyebabkan itu busuk berlangsung