1The Dependency InversionPrincipleT

1
The Dependency Inversion
Principle
This is the third of my Engineering Notebookcolumns for The C++ Report. The articles
that will appear in this column will focus on the use of C++ and OOD, and will address
issues of software engineering. I will strive for
articles that are pragmatic
and directly useful to the
software engineer in the
trenches. In these articles I
will make use of Booch’s
and Rumbaugh’s new unifiednotation (Version 0.8)
for documenting object oriented designs. The sidebar
provides a brief lexicon of
this notation.
Introduction
My last article (Mar, 96) talked about the Liskov Substitution Principle (LSP). This principle, when applied to C++, provides guidance for the use of public inheritance. It states that
every function which operates upon a reference or pointer to a base class, should be able to
operate upon derivatives of that base class without knowing it. This means that the virtual
member functions of derived classes must expect no more than the corresponding member
functions of the base class; and should promise no less. It also means that virtual member
functions that are present in base classes must also be present in the derived classes; and
they must do useful work. When this principle is violated, the functions that operate upon
pointers or references to base classes will need to check the type of the actual object to
make sure that they can operate upon it properly. This need to check the type violates the
Open-Closed Principle (OCP) that we discussed last January.
In this column, we discuss the structural implications of the OCP and the LSP. The
structure that results from rigorous use of these principles can be generalized into a principle all by itself. I call it “The Dependency Inversion Principle” (DIP).
Sidebar: Unified Notation 0.8
Base Class
Derived 1 Derived 2
Had by
Reference
Had By Value
Used
2 What goes wrong with software?
What goes wrong with software?
Most of us have had the unpleasant experience of trying to deal with a piece of software
that has a “bad design”. Some of us have even had the much more unpleasant experience
of discovering that we were the authors of the software with the “bad design”. What is it
that makes a design bad?
Most software engineers don’t set out to create “bad designs”. Yet most software
eventually degrades to the point where someone will declare the design to be unsound.
Why does this happen? Was the design poor to begin with, or did the design actually
degrade like a piece of rotten meat? At the heart of this issue is our lack of a good working
definition of “bad” design.
The Definition of a “Bad Design”
Have you ever presented a software design, that you were especially proud of, for review
by a peer? Did that peer say, in a whining derisive sneer, something like: “Why’d you do it
thatway?”. Certainly this has happened to me, and I have seen it happen to many other
engineers too. Clearly the disagreeing engineers are not using the same criteria for defining what “bad design” is. The most common criterion that I have seen used is the TNTWIWHDI or “That’s not the way I would have done it” criterion.
But there is one set of criteria that I think all engineers will agree with. A piece of
software that fulfills its requirements and yet exhibits any or all of the following three
traits has a bad design.
1. It is hard to change because every change affects too many other parts of the system. (Rigidity)
2. When you make a change, unexpected parts of the system break. (Fragility)
3. It is hard to reuse in another application because it cannot be disentangled from
the current application. (Immobility)
Moreover, it would be difficult to demonstrate that a piece of software that exhibits
none of those traits, i.e. it is flexible, robust, and reusable, and that also fulfills all its
requirements, has a bad design. Thus, we can use these three traits as a way to unambiguously decide if a design is “good” or “bad”.
The Cause of “Bad Design”.
What is it that makes a design rigid, fragile and immobile? It is the interdependence of the
modules within that design. A design is rigid if it cannot be easily changed. Such rigidity
is due to the fact that a single change to heavily interdependent software begins a cascade
of changes in dependent modules. When the extent of that cascade of change cannot be
3 : The Dependency Inversion Principle
predicted by the designers or maintainers, the impact of the change cannot be estimated.
This makes the cost of the change impossible to predict. Managers, faced with such unpredictability, become reluctant to authorize changes. Thus the design becomes officially
rigid.
Fragility is the tendency of a program to break in many places when a single change is
made. Often the new problems are in areas that have no conceptual relationship with the
area that was changed. Such fragility greatly decreases the credibility of the design and
maintenance organization. Users and managers are unable to predict the quality of their
product. Simple changes to one part of the application lead to failures in other parts that
appear to be completely unrelated. Fixing those problems leads to even more problems,
and the maintenance process begins to resemble a dog chasing its tail.
A design is immobile when the desirable parts of the design are highly dependent
upon other details that are not desired. Designers tasked with investigating the design to
see if it can be reused in a different application may be impressed with how well the
design would do in the new application. However if the design is highly interdependent,
then those designers will also be daunted by the amount of work necessary to separate the
desirable portion of the design from the other portions of the design that are undesirable.
In most cases, such designs are not reused because the cost of the separation is deemed to
be higher than the cost of redevelopment of the design.
Example: the “Copy” program.
A simple example may help
to make this point. Consider a
simple program that is charged
with the task of copying characters typed on a keyboard to a
printer. Assume, furthermore,
that the implementation platform does not have an operating
system that supports device independence. We might conceive of
a structure for this program that
looks like Figure 1:
Figure 1 is a “structure chart”
1
. It shows that there are three modules, or subprograms,
in the application. The “Copy” module calls the other two. One can easily imagine a loop
within the “Copy” module. (See Listing 1.) The body of that loop calls the “Read Keyboard” module to fetch a character from the keyboard, it then sends that character to the
“Write Printer” module which prints the character.
1. See: The Practical Guide To Structured Systems Design, by Meilir Page-Jones, Yourdon Press,
1988
Figure 1. Copy Program.
Copy
Read
Keyboard
Write
Printer
4 Dependency Inversion
The two low level modules are nicely reusable. They
can be used in many other
programs to gain access to the
keyboard and the printer. This
is the same kind of reusability
that we gain from subroutine
libraries.
However the “Copy” module is not reusable in any context which does not involve a
keyboard or a printer. This is a shame since the intelligence of the system is maintained in
this module. It is the “Copy” module that encapsulates a very interesting policy that we
would like to reuse.
For example, consider a new program that copies keyboard characters to a disk file.
Certainly we would like to reuse the “Copy” module since it encapsulates the high level
policy that we need. i.e. it knows how to copy characters from a source to a sink. Unfortunately, the “Copy” module is dependent upon the “Write Printer” module, and so cannot
be reused in the new context.
We could certainly
modify the “Copy”module
to give it the new desired
functionality. (See Listing
2). We could add an ‘if’
statement to its policy and
have it select between the
“Write Printer” module
and the “Write Disk” module depending upon some
kind of flag. However this
adds new interdependencies to the system. As time goes on, and more and more devices
must participate in the copy program, the “Copy” module will be littered with if/else statements and will be dependent upon many lower level modules. It will eventually become
rigid and fragile.
Dependency Inversion
One way to characterize the problem above is to notice that the module containing the
high level policy, i.e. the Copy() module, is dependent upon the low level detailed modules
that it controls. (i.e. WritePrinter() and ReadKeyboard()). If we could find a way to make
the Copy() module independent of the details that it controls, then we could reuse it freely.
We could produce other programs which used this module to copy characters from any
void Copy()
{
int c;
while ((c = ReadKeyboard()) != EOF)
WritePrinter(c);
}
Listing 1. The Copy Program
enum OutputDevice {printer, disk};
void Copy(outputDevice dev)
{
int c;
while ((c = ReadKeyboard()) != EOF)
if (dev == printer)
WritePrinter(c);
else
WriteDisk(c);
}
Listing 2. The “Enhanced” Copy Program
5 : The Dependency Inversion Principle
input device to any output device. OOD
gives us a mechanism for performing
this dependency inversion.
Consider the simple class diagram
in Figure 2. Here we have a “Copy”
class which contains an abstract
“Reader” class and an abstract “Writer”
class. One can easily imagine a loop
within the “Copy” class that gets characters from its “Reader” and sends
them to its “Writer” (See Listing 3). Yet
this “Copy” class does not depend upon
the “Keyboard Reader” nor the “Printer
Writer” at all. Thus the dependencies
have been inverted; the “Copy” class
depends upon abstractions, and the
detailed readers and writers depend
upon the same abstractions.
Now we can reuse the “Copy”
class, independently of the “Keyboard Reader” and the “Printer
Writer”. We can inve

Results (Indonesian) 1:

1Pembalikan ketergantunganPrinsipIni adalah ketiga dari Notebookcolumns saya teknik untuk The C++ laporan. Artikelyang akan muncul di kolom ini akan fokus pada penggunaan C ++ dan OOD, dan akan alamatisu-isu rekayasa perangkat lunak. Saya akan berusaha untukArtikel yang pragmatisdan langsung berguna untuksoftware engineer diparit. Dalam artikel ini sayaakan membuat penggunaan Beli batu Mangan didan Rumbaugh yang baru unifiednotation (Versi 0.8)untuk mendokumentasikan desain berorientasi objek. Sidebarmenyediakan kosakata singkatnotasi ini.PengenalanArtikel terakhir saya (Mar, 96) berbicara tentang prinsip substitusi Liskov (LSP). Prinsip ini, bila diterapkan ke c + +, memberikan panduan untuk penggunaan umum warisan. Ia menyatakan bahwasetiap fungsi yang beroperasi berdasarkan referensi atau pointer ke kelas dasar, harus mampuberoperasi berdasarkan turunan dari kelas dasar tanpa menyadarinya. Ini berarti bahwa virtualfungsi anggota kelas turunan harus mengharapkan tidak lebih dari anggota sesuaifungsi kelas dasar; dan harus berjanji tidak kurang. Ini juga berarti bahwa anggota virtualfungsi yang hadir di kelas dasar juga harus hadir di kelas turunan; danmereka harus melakukan kerja berguna. Ketika prinsip ini dilanggar, fungsi yang beroperasi berdasarkanpetunjuk atau referensi ke dasar kelas akan perlu memeriksa jenis objek yang sebenarnyaPastikan bahwa mereka dapat beroperasi atasnya dengan benar. Ini perlu memeriksa jenis melanggarDitutup terbuka prinsip (OCP) yang kita bahas Januari lalu.Dalam kolom ini, kita membahas implikasi struktural dari OCP dan LSP. Thestruktur yang hasil dari penggunaan ketat prinsip-prinsip ini dapat generalized ke dalam prinsip yang dengan sendirinya. Saya menyebutnya "Ketergantungan inversi prinsip" (berenang). Sidebar: Unified notasi 0,8Kelas dasar1 berasal berasal 2DenganReferensiDengan nilaiDigunakan2 apa yang salah dengan perangkat lunak?Apa yang salah dengan perangkat lunak?Sebagian besar dari kita telah memiliki pengalaman tidak menyenangkan berusaha untuk berurusan dengan perangkat lunakyang memiliki "desain buruk". Beberapa dari kita bahkan telah memiliki pengalaman jauh lebih menyenangkanmenemukan bahwa kita adalah penulis perangkat lunak dengan "desain buruk". Apa ituyang membuat desain yang buruk?Kebanyakan insinyur perangkat lunak tidak berangkat untuk menciptakan "desain yang buruk". Namun sebagian besar perangkat lunakakhirnya mendegradasi ke titik di mana seseorang akan menyatakan desain untuk menjadi tidak kukuh.Mengapa hal ini terjadi? Itu desain miskin untuk memulai dengan, atau melakukan desain benar-benarmenurunkan seperti sepotong daging busuk? Di jantung masalah ini kita kekurangan yang baik bekerjaDefinisi Desain "buruk".Definisi dari "Desain buruk"Apakah Anda pernah disajikan desain perangkat lunak, yang kau terutama bangga, untuk reviewoleh rekan? Apakah yang rekan mengatakan, dalam mencemooh mengejek merengek, sesuatu seperti: "Mengapa Anda akan melakukannyathatway? ". Tentu saja hal ini terjadi kepada saya, dan saya telah melihat hal itu terjadi banyak laininsinyur terlalu. Jelas para insinyur disagreeing tidak menggunakan kriteria yang sama untuk mendefinisikan apa "desain buruk". Kriteria paling umum yang pernah digunakan adalah TNTWIWHDI atau "Itu adalah bukan cara saya akan melakukannya" kriteria.Tapi ada satu set kriteria yang saya pikir semua insinyur akan setuju dengan. Sepotongperangkat lunak yang memenuhi persyaratan mereka dan belum menunjukkan salah satu atau semua tiga berikutCiri-ciri ini memiliki desain yang buruk. 1. hal ini sulit untuk berubah karena setiap perubahan yang mempengaruhi terlalu banyak bagian-bagian lain dari sistem. (Kekakuan)2. ketika Anda membuat perubahan, tak terduga bagian dari sistem istirahat. (Kerapuhan)3. ini sulit untuk menggunakan kembali dalam aplikasi lain karena tidak bisa disentangled dari aplikasi saat ini. (Imobilitas)Selain itu, akan sulit untuk menunjukkan bahwa perangkat lunak yang pamerantidak ada sifat tersebut, yaitu ini fleksibel, kuat dan dapat digunakan kembali, dan yang juga memenuhi semua yangpersyaratan, memiliki desain yang buruk. Dengan demikian, kita dapat menggunakan sifat-sifat tiga ini sebagai cara untuk jelas memutuskan apakah desain "baik" atau "buruk".Penyebab "Desain buruk".Apakah yang membuat desain yang kaku, rapuh, dan bergerak? Ini adalah saling ketergantungan antaramodul-modul dalam desain yang. Sebuah desain kaku jika tidak dapat dengan mudah diubah. Kekakuan sepertikarena kenyataan bahwa satu perubahan perangkat lunak bergantung dimulai cascadeperubahan dalam tergantung modul. Ketika tingkat cascade bahwa perubahan tidak dapat3: prinsip inversi ketergantungandiperkirakan oleh desainer atau pengelola, dampak perubahan tidak dapat diperkirakan.Hal ini membuat biaya perubahan mustahil untuk memprediksi. Manajer, dihadapkan dengan ketidakpastian tersebut, menjadi enggan untuk melakukan perubahan. Dengan demikian desain menjadi resmikaku.Kerapuhan adalah kecenderungan program untuk istirahat di banyak tempat ketika perubahan tunggaldibuat. Sering masalah baru di daerah yang tidak memiliki konseptual hubungan dengandaerah yang berubah. Seperti kerapuhan sangat mengurangi kredibilitas desain danorganisasi pemeliharaan. Pengguna dan manajer tidak mampu memperkirakan kualitas merekaproduk. Perubahan sederhana ke salah satu bagian dari aplikasi mengakibatkan kegagalan lain bagian yangtampaknya sama sekali tidak terkait. Memperbaiki masalah yang menyebabkan masalah bahkan lebih,dan proses pemeliharaan mulai menyerupai seekor anjing mengejar ekornya. Desain yang tak bergerak ketika bagian yang diinginkan dari desain sangat tergantungBerdasarkan rincian lainnya yang tidak diinginkan. Desainer yang ditugaskan untuk menyelidiki desainmelihat apakah dia dapat digunakan kembali dalam aplikasi yang berbeda mungkin terkesan dengan cara baikDesain akan lakukan dalam aplikasi baru. Namun jika desain sangat salingmaka orang-orang desainer akan juga daunted oleh jumlah pekerjaan yang diperlukan untuk memisahkanBagian desain dari bagian-bagian lain dari desain yang tidak diinginkan yang diinginkan.Dalam kebanyakan kasus, rancangan tersebut tidak akan digunakan karena biaya pemisahan dianggaplebih tinggi daripada biaya pembangunan desain.Contoh: program "Copy".Contoh sederhana dapat membantuuntuk membuat titik ini. Pertimbangkanprogram sederhana yang dikenakan biayadengan tugas penyalinan karakter mengetik pada keyboard untukprinter. Berasumsi, selanjutnya,bahwa pelaksanaan platform tidak memiliki operasisistem yang mendukung perangkat kemerdekaan. Kita mungkin membayangkanstruktur ini program yangterlihat seperti gambar 1:Gambar 1 adalah "struktur tabel"1. Ini menunjukkan bahwa ada tiga modul, atau Subprogram,dalam aplikasi. Modul "Copy" panggilan dua lainnya. Satu dapat dengan mudah membayangkan sebuah loopdalam modul "Copy". (Lihat daftar 1.) Tubuh loop itu memanggil modul "Membaca Keyboard" untuk mengambil karakter dari keyboard, kemudian mengirimkan karakter yang"Menulis Printer" modul yang mencetak karakter.1. Lihat: Panduan praktis untuk desain sistem yang terstruktur, oleh Meilir halaman-Jones, Yourdon Press, 1988Gambar 1. Salinan Program.SalinanBacaKeyboardMenulisPrinter4 ketergantungan inversiDua tingkat rendah modul baik dapat digunakan kembali. Merekadapat digunakan dalam banyak lainnyaprogram untuk mendapatkan akses kekeyboard dan printer. Iniadalah jenis yang sama usabilitasbahwa kita memperoleh dari subrutinPerpustakaan. Namun modul "Copy" ini tidak dapat digunakan kembali dalam konteks yang tidak melibatkankeyboard atau printer. Ini adalah rasa malu karena intelijen sistem dipertahankan diModul ini. Itu adalah "Copy" modul yang merangkum kebijakan yang sangat menarik bahwa kitaingin kembali.Sebagai contoh, pertimbangkan program baru yang menyalin keyboard karakter ke disk file.Tentu saja kami ingin kembali modul "Copy" karena Ia merangkum tingkat tinggikebijakan yang kita butuhkan. yaitu tahu cara untuk menyalin karakter dari sumber ke wastafel. Sayangnya, modul "Copy" tergantung pada modul "Menulis Printer", dan sehingga tidak bisadigunakan kembali dalam konteks baru.Kita bisa pastimengubah modul "Copy"untuk memberikan baru diinginkanfungsi. (Lihat daftar2). kita bisa menambahkan 'if'pernyataan kebijakan dantelah memilih antaraModul "Menulis Printer"dan modul "Menulis Disk" tergantung pada beberapajenis bendera. Namun inimenambah ketergantungan baru ke sistem. Seiring waktu, dan perangkat lebih dan lebihharus berpartisipasi dalam program salinan, "Salin" modul akan menjadi penuh dengan jika/lain pernyataan dan akan bergantung pada banyak modul tingkat yang lebih rendah. Akhirnya akan menjadikaku dan rapuh.Ketergantungan inversiSalah satu cara untuk menandai permasalahan diatas adalah untuk melihat bahwa modul yang mengandungkebijakan tingkat tinggi, yaitu modul Copy(), itu tergantung dari modul rinci tingkat rendahkontrol itu. (yaitu WritePrinter() dan ReadKeyboard()). Jika kita bisa menemukan cara untuk membuatmodul Copy() independen dari rincian yang mengontrol, maka kita bisa menggunakan kembali dengan bebas.Kita bisa menghasilkan program lain yang menggunakan modul ini untuk menyalin karakter dari setiapmembatalkan Copy(){Int c;Sementara ((c = ReadKeyboard())! = EOF)WritePrinter(c);}Daftar 1. Salinan ProgramENUM OutputDevice {printer, disk};membatalkan Copy (outputDevice dev){Int c;Sementara ((c = ReadKeyboard())! = EOF)Jika (dev == printer)WritePrinter(c);lainWriteDisk(c);}Daftar 2. Program "Disempurnakan" Copy5: prinsip inversi ketergantunganperangkat input ke perangkat output. OODmemberikan kita sebuah mekanisme untuk melakukanini ketergantungan inversi.Perhatikan diagram kelas sederhanapada gambar 2. Di sini kita memiliki "Copy"kelas yang berisi abstrak"Reader" kelas dan abstrak "Penulis"kelas. Satu dapat dengan mudah membayangkan sebuah loopdalam kelas "Salin" yang membuat karakter dari "Reader" dan mengirimmereka yang "penulis" (Lihat daftar 3). Namunkelas "Salin" ini tidak bergantung pada"Keyboard Reader" atau "PrinterPenulis"sama sekali. Dengan demikian dependensitelah terbalik; kelas "Copy"tergantung pada abstraksi, danrinci pembaca dan penulis tergantungBerdasarkan abstraksi sama.Sekarang dapat kita reuse "Copy"kelas, terlepas dari "Keyboard Reader" dan "PrinterPenulis". Kita bisa inve

Results (Indonesian) 2:

1
The Ketergantungan Inversi
Prinsip
ini adalah ketiga saya Teknik Notebookcolumns untuk The C ++ Report. Artikel-artikel
yang akan muncul di kolom ini akan fokus pada penggunaan C ++ dan OOD, dan akan membahas
isu-isu rekayasa perangkat lunak. Saya akan berusaha untuk
artikel yang pragmatis
dan langsung berguna untuk
insinyur perangkat lunak dalam
parit. Dalam artikel ini saya
akan memanfaatkan Booch ini
unifiednotation baru dan Rumbaugh ini (Version 0.8)
untuk mendokumentasikan berorientasi objek desain. Sidebar
menyediakan leksikon singkat
notasi ini.
Pengenalan
saya artikel terakhir (Mar, 96) berbicara tentang Liskov Pergantian Prinsip (LSP). Prinsip ini, bila diterapkan pada C ++, memberikan panduan untuk penggunaan warisan publik. Ini menyatakan bahwa
setiap fungsi yang beroperasi pada referensi atau pointer ke kelas dasar, harus dapat
beroperasi pada turunan dari kelas dasar tanpa menyadarinya. Ini berarti bahwa virtual
fungsi anggota dari kelas turunan harus mengharapkan tidak lebih dari anggota yang sesuai
fungsi dari kelas dasar; dan harus berjanji tidak kurang. Ini juga berarti bahwa anggota maya
fungsi yang hadir di kelas dasar juga harus hadir di kelas turunan; dan
mereka harus melakukan pekerjaan yang bermanfaat. Ketika prinsip ini dilanggar, fungsi yang beroperasi pada
pointer atau referensi untuk kelas dasar akan perlu memeriksa jenis objek yang sebenarnya untuk
memastikan bahwa mereka dapat beroperasi atasnya benar. Kebutuhan ini untuk memeriksa jenis melanggar
Open-Tertutup Prinsip (OCP) yang kita bahas Januari lalu.
Dalam kolom ini, kita membahas implikasi struktural dari OCP dan LSP. The
struktur yang dihasilkan dari penggunaan ketat dari prinsip-prinsip ini dapat digeneralisasi menjadi prinsip dengan sendirinya. Saya menyebutnya "The Dependency Pembalikan Prinsip" (DIP).
Sidebar: Bersatu Notasi 0.8
Base Class
Berasal 1 Berasal 2
Telah oleh
Referensi
Memiliki By Nilai
Digunakan? 2 Apa yang salah dengan perangkat lunak? Apa yang salah dengan software Sebagian besar dari kita telah memiliki pengalaman tidak menyenangkan mencoba untuk berurusan dengan software yang memiliki "desain yang buruk". Sebagian dari kita bahkan telah memiliki pengalaman lebih menyenangkan dari menemukan bahwa kita adalah penulis dari perangkat lunak dengan "desain yang buruk". Apa itu yang membuat sebuah desain yang buruk? Kebanyakan insinyur perangkat lunak tidak berangkat untuk membuat "desain yang buruk". Namun sebagian besar perangkat lunak akhirnya degradasi ke titik di mana seseorang akan mendeklarasikan desain menjadi tidak sehat. Mengapa hal ini terjadi? Apakah desain miskin untuk memulai dengan, atau apakah desain benar-benar menurunkan seperti sepotong daging busuk? Di jantung masalah ini adalah kurangnya dari kerja yang baik definisi "buruk" desain. Definisi dari "Desain Bad" Apakah Anda pernah disajikan desain software, bahwa Anda sangat bangga, untuk ditinjau oleh rekan? Apakah rekan yang mengatakan, dalam seringai mengejek merengek, sesuatu seperti: "Mengapa kau melakukannya thatway?". Tentu saja ini telah terjadi kepada saya, dan saya telah melihat hal itu terjadi pada banyak lainnya insinyur juga. Jelas insinyur setuju tidak menggunakan kriteria yang sama untuk mendefinisikan apa "desain yang buruk" adalah. Kriteria yang paling umum yang saya telah melihat digunakan adalah TNTWIWHDI atau "Itu bukan cara saya akan melakukannya" kriteria. Tapi ada satu set kriteria yang saya pikir semua insinyur akan setuju dengan. Sepotong perangkat lunak yang memenuhi persyaratan dan belum menunjukkan salah satu atau semua dari tiga berikut ciri-ciri memiliki desain yang buruk. 1. Sulit untuk berubah karena setiap perubahan mempengaruhi terlalu banyak bagian lain dari sistem. (Kekakuan) 2. Ketika Anda membuat perubahan, bagian tak terduga dari sistem istirahat. (Kerapuhan) 3. Sulit untuk menggunakan kembali dalam aplikasi lain karena tidak dapat mengurai dari aplikasi saat ini. (Imobilitas) Selain itu, akan sulit untuk menunjukkan bahwa software yang menunjukkan tidak ada sifat-sifat, yakni fleksibel, kuat, dan dapat digunakan kembali, dan yang juga memenuhi semua nya persyaratan, memiliki desain yang buruk. Dengan demikian, kita dapat menggunakan tiga sifat-sifat ini sebagai cara untuk tegas memutuskan apakah sebuah desain adalah "baik" atau "buruk". Penyebab "Bad Design". Apa yang membuat desain yang kaku, rapuh dan tak bergerak? Ini adalah saling ketergantungan dari modul dalam desain tersebut. Sebuah desain kaku jika tidak dapat dengan mudah berubah. Kekakuan tersebut adalah karena fakta bahwa perubahan tunggal untuk software berat saling dimulai riam perubahan modul tergantung. Ketika tingkat yang kaskade perubahan tidak bisa 3: The Ketergantungan Inversi Prinsip. Diprediksi oleh para desainer atau pengembang, dampak perubahan tidak dapat diperkirakan ini membuat biaya perubahan mungkin untuk memprediksi. Manajer, dihadapkan dengan ketidakpastian seperti itu, menjadi enggan untuk mengotorisasi perubahan. Dengan demikian desain menjadi resmi kaku. Kerapuhan adalah kecenderungan program untuk istirahat di banyak tempat ketika perubahan tunggal dibuat. Seringkali masalah baru di daerah yang tidak memiliki hubungan konseptual dengan daerah yang berubah. Kerapuhan seperti sangat mengurangi kredibilitas desain dan pemeliharaan organisasi. Pengguna dan manajer tidak dapat memprediksi kualitas mereka produk. Perubahan sederhana untuk salah satu bagian dari aplikasi menyebabkan kegagalan di bagian lain yang tampaknya sama sekali tidak berhubungan. Memperbaiki masalah tersebut mengarah untuk bahkan lebih banyak masalah, dan proses pemeliharaan mulai menyerupai anjing mengejar ekornya. Sebuah desain adalah bergerak ketika bagian diinginkan dari desain sangat tergantung pada rincian lain yang tidak diinginkan. Desainer bertugas menyelidiki desain untuk melihat apakah itu dapat digunakan kembali dalam aplikasi yang berbeda mungkin akan terkesan dengan seberapa baik desain akan dilakukan di aplikasi baru. Namun jika desain sangat saling tergantung, maka mereka desainer juga akan gentar dengan jumlah pekerjaan yang diperlukan untuk memisahkan bagian yang diinginkan dari desain dari bagian-bagian lain dari desain yang diinginkan. Dalam kebanyakan kasus, desain tersebut tidak digunakan kembali karena biaya pemisahan dianggap lebih tinggi daripada biaya pembangunan kembali desain. Contoh: program "Copy". Contoh sederhana dapat membantu untuk membuat titik ini. Mempertimbangkan program sederhana yang dibebankan dengan tugas menyalin karakter diketik di keyboard ke printer. Asumsikan, lebih jauh lagi, bahwa platform implementasi tidak memiliki operasi sistem yang mendukung kemerdekaan perangkat. Kita mungkin membayangkan struktur untuk program ini yang terlihat seperti Gambar 1: Gambar 1 adalah "struktur grafik" 1. Hal ini menunjukkan bahwa ada tiga modul, atau subprogram, dalam aplikasi. "Copy" modul panggilan dua lainnya. Satu dapat dengan mudah membayangkan loop dalam "Copy" modul. (Lihat Listing 1.) Tubuh loop yang memanggil "Baca Keyboard" modul untuk mengambil karakter dari keyboard, kemudian mengirimkan karakter yang ke "Menulis Printer" modul yang mencetak karakter. 1. Lihat: Panduan Praktis Untuk Terstruktur Desain Sistem, oleh Meilir Page-Jones, Yourdon Press, 1988. Gambar 1. Copy Program Copy Baca Keyboard Write Printer 4 Ketergantungan Inversi Kedua modul tingkat rendah yang baik dapat digunakan kembali. Mereka dapat digunakan di banyak lainnya program untuk mendapatkan akses ke keyboard dan printer. Ini adalah jenis yang sama dari usabilitas yang kita peroleh dari subrutin perpustakaan. Namun "Copy" modul tidak dapat digunakan kembali dalam konteks yang tidak melibatkan keyboard atau printer. Ini adalah rasa malu karena kecerdasan sistem dipertahankan dalam modul ini. Ini adalah "Copy" modul yang merangkum kebijakan yang sangat menarik bahwa kita ingin menggunakan kembali. Sebagai contoh, perhatikan program baru yang karakter salinan keyboard untuk file disk. Tentu kami ingin menggunakan kembali "Copy" modul karena merangkum tingkat tinggi kebijakan yang kita butuhkan. yaitu ia tahu bagaimana untuk menyalin karakter dari sumber ke wastafel. Sayangnya, "Copy" modul tergantung pada "Write Printer" modul, sehingga tidak dapat digunakan kembali dalam konteks baru. Kita pasti bisa memodifikasi "Copy" modul untuk memberikan baru yang diinginkan fungsi. (Lihat Daftar 2). Kita bisa menambahkan 'jika' pernyataan kebijakan dan memilikinya pilih antara "Menulis Printer" modul dan "Write Disk" modul tergantung pada beberapa jenis bendera. Namun ini menambah ketergantungan baru ke sistem. Dengan berjalannya waktu, dan semakin banyak perangkat harus berpartisipasi dalam program copy, "Copy" modul akan dikotori dengan jika / pernyataan yang lain dan akan tergantung pada banyak modul tingkat yang lebih rendah. Ini akhirnya akan menjadi kaku dan rapuh. Ketergantungan Inversi Salah satu cara untuk mengkarakterisasi masalah di atas adalah untuk melihat bahwa modul yang berisi kebijakan tingkat tinggi, yaitu Copy () modul, tergantung pada tingkat rendah rinci modul yang mengontrol. (yaitu WritePrinter () dan ReadKeyboard ()). Jika kita bisa menemukan cara untuk membuat Copy () modul independen dari detail yang mengontrol, maka kita bisa menggunakan kembali secara bebas. Kita bisa menghasilkan program lain yang digunakan modul ini untuk menyalin karakter dari setiap kekosongan Copy () {int c; sementara ((c = ReadKeyboard ()) = EOF!) WritePrinter (c);} Listing 1. Copy Program enum OutputDevice {printer, hard disk}; kekosongan Copy (outputDevice dev) {int c; sementara ((c = ReadKeyboard ( !)) = EOF) jika (dev == printer) WritePrinter (c); lain WriteDisk (c);} Listing 2. "Peningkatan" Program Copy 5: The Ketergantungan Inversi Prinsip masukan perangkat ke perangkat output. OOD memberi kita suatu mekanisme untuk melakukan ketergantungan inversi ini. Perhatikan diagram kelas sederhana pada Gambar 2. Di sini kita memiliki "Copy" kelas yang berisi abstrak "Pembaca" kelas dan abstrak "Penulis" kelas. Satu dapat dengan mudah membayangkan loop dalam "Copy" kelas yang mendapat karakter dari "Pembaca" dan mengirim mereka ke "Penulis" (Lihat Listing 3). Namun ini "Copy" kelas tidak tergantung pada "Keyboard Pembaca" maupun "Printer Penulis" sama sekali. Sehingga dependensi telah terbalik; "Copy" kelas tergantung pada abstraksi, dan pembaca rinci dan penulis tergantung pada abstraksi yang sama. Sekarang kita dapat menggunakan kembali "Copy" kelas, secara independen dari "Keyboard Pembaca" dan "Printer Writer". Kita bisa Inve