Source Page: http://mikepackdev.com/blog_posts/24-the-right-way-to-code-dci-in-ruby

ரூபி சமூகத்தில் காணப்படும் பல கட்டுரைகள் பெரிதும் முடிந்துவிட்டது DCI பயன்பாடு எளிமைப்படுத்த. என் சொந்த உட்பட இக்கட்டுரைகள், டிசிஐ, இயங்கு நேரத்தில் பொருட்களை DCI கட்டிடக்கலை சாரம் பாத்திரங்கள் செலுத்தியுள்ளார் என்பதை எடுத்துக்காட்டுகின்றன. பல பதிவுகள் பின்வரும் வழியில் DCI கருதுகின்றன:

class User; end # Data
module Runner # Role
  def run
    ...
  end
end

user = User.new # Context
user.extend Runner
user.run

இது போன்ற எளிமைப்படுத்தப்பட்ட உதாரணங்கள் மீது ஒரு சில குறைபாடுகள் உள்ளன. முதல், அது “இந்த DCI செய்ய எப்படி உள்ளது” கூறுகிறது. DCI வெறும் விரிவாக்கும் பொருட்களை விட மிக அதிகமாக உள்ளது. இரண்டாவது, அது போன்ற #extend உயர்த்தி காட்டுகிறது போக வேண்டிய செயல்படுத்தப்படும் நேரத்தில் பொருள்கள் முறைகள் சேர்த்து வழிமுறையாக. வெறும் விரிவாக்கும் பொருட்களை தாண்டி DCI: இந்த கட்டுரையில், நான் குறிப்பாக முன்னாள் பிரச்சனைக்கு தீர்வு காண விரும்புகிறேன். ஒரு வரை பின்பற்ற பதவியை இல்லையெனில் #extend மற்றும் யன்படுத்தி பொருட்களை ஒரு பாத்திரங்கள் புகுத்த நுட்பங்களை ஒரு ஒப்பீடு கொண்டிருக்கும்.

DCI(டேட்டா-சூழல் சம்பாஷணை)

முன்னர் குறிப்பிட்டது போல், DCIபற்றி அதிகம் தான் செயல்படுத்தப்படும் நேரத்தில் பொருட்களை விரிவாக்கும் விட உள்ளது. அது இறுதியில் பயனர் மன மாதிரி கைப்பற்றி மற்றும் பராமரிக்கப்படுகிறது குறியீடு ஒரு மறுகட்டமைப்பு பற்றி தான். அதை நாம் முதலில் பயனர் ஒருங்கிணைப்பு மற்றும் தரவு மாதிரியை இரண்டாவது கருதுவதால் அவர் BDD, ஒத்த அணுகுமுறையில் ஒரு வெளியே →, தான். அணுகுமுறை வெளியே → நான் கட்டிடக்கலை அன்பு காரணங்களில் ஒன்றாகும்; அது நன்றாக மேலும் பரிசோதிக்க இயலுமை ஆகிய BDD பாணி, பொருந்தும்.

DCIபற்றி எனக்கு முக்கியம் என்று அது குறியீடு விட பற்றி என்று உள்ளது. அது செயல்முறை மற்றும் பற்றி தான். அது Agile மற்றும் Lean பின்னால் கொள்கைகள் தொடங்குகிறது குறியீடு அந்த பரவியுள்ளது. DCIபின்வரும் உண்மையான நன்மை அது Agile மற்றும் Lean நன்றாக நடிக்கிறார் என்று. அதை மாற்ற, பதிலளிக்காது மற்றும் அமைப்பு முறை (அது தரவு மாதிரியை) என்ன (அது செயல்பாடு தான்) என்ன இணைப்புநீக்கத்தைக், குறியீடு பராமரிப்புக்கு பற்றி தான்.

நான் ஒரு ரெயில்ஸ் பயன்பாட்டை உள்ள DCIசெயல்படுத்தி பாதிப்புகள் தொடங்கி தரவு மாதிரி நகரும் ஒரு நடத்தை சார்ந்த அணுகுமுறை எடுக்க வேண்டும். பெரும்பாலான, நான் முதலில் சோதனை குறியீடு எழுத போகிறேன். நீங்கள் DCIபின்னால் கூறுகளின் ஒரு திட புரிந்து கொள்ள நிச்சயமாக, ஒரு முறை, நீங்கள் முதல் சோதனைகள் எழுத முடியும். நான் சோதனை முதல் விளக்கி ஒரு சிறந்த வழி உள்ளது நினைக்கவில்லை.

app/contexts/add_to_cart_context.rb

class AddToCartContext attr_reader :user, :book def self.call(user, book) AddToCartContext.new(user, book).call end def initialize(user, book) @user, @book = user, book @user.extend Customer end def call @user.add_to_cart(@book) end end

மேலே குறியீடு முக்கிய குறிக்கோள் நாம் சரியான வாதங்கள் #add_to_cart முறை அழைப்பு என்பதை உறுதி செய்ய உள்ளது. நாம் AddToCartContext உள்ள பயனர் நடிகர் அது தான் ஒரு வாதம் புத்தகம் என்று #add_to_cart முறை தான் இருக்க வேண்டும் என்று எதிர்பார்ப்பு அமைக்க இந்த செய்கிறோம்.

டிசிஐ அதிகம் இல்லை. நாம் பொருட்களை மற்றும் அவர்கள் தொடர்பு எந்த சூழல் இடையேயான தொடர்பானது மூடப்பட்டிருக்கும். முக்கிய குறியீடு, ஏற்கனவே எழுதப்பட்ட. விட்டு மட்டும் தான் ஊமை தரவு ஆகிறது.

“டேட்டா”

தரவு மெலிந்த இருக்க வேண்டும். கட்டைவிரல் ஒரு நல்ல ஆட்சியை உங்கள் மாதிரிகள் முறைகள் வரையறுக்க முடியாது உள்ளது. இந்த எப்போதும் வழக்கு அல்ல. சிறந்த புட்: “டேட்டா பொருள் இடைமுகங்கள் எளிய மற்றும் குறைந்தபட்ச உள்ளன: போதும் டொமைன் பண்புகள் கைப்பற்ற ஆனால் எந்த குறிப்பிட்ட சூழ்நிலையில் தனிப்பட்ட என்று நடவடிக்கைகளை இல்லாமல்” (லீன் கட்டுமானம்). தரவு உண்மையில் மட்டுமே தொடர்ந்திருந்தன தரவு பயன்படுத்தப்படுகிறது எப்படி என்பதையும், நிலைபேறு உயர்நிலை முறைகளுக்கு உள்ளடக்கியதாக இருக்க வேண்டும். நாம் ஏற்கனவே அடிப்படை பண்புகளை கிண்டல் நான் எந்த புத்தகத்தை மாதிரி பார்க்கிறேன்.

app/controllers/book_controller.rb

class BookController < ApplicationController def add_to_cart AddToCartContext.call(current_user, Book.find(params[:id])) end end

பயனர் கதைகள்

பயனர் கதைகள் கட்டிடக்கலை என்றாலும் வேறுபடுத்தப்படவில்லை DCIஒரு முக்கிய அம்சம் ஆகும். அவர்கள் அமைப்பு என்ன வரையறுக்கும் தொடக்கப் புள்ளியாக இருக்கும். பயனர் கதைகள் தொடங்கி அழகானவர்கள் ஒரு அது ஒரு சுறுசுறுப்பான செயல்முறை நன்றாக பொருந்துகிறது என்று. பொதுவாக, நாம் நம் இறுதி பயனர் அம்சம் வரையறுக்கிறது ஒரு கதை வழங்கப்படும். எளிமையாக்கப்பட்ட கதை தொடர்ந்து போல இருக்கும்:

“ஒரு பயனர், நான் என் வண்டியில் ஒரு புத்தகத்தை சேர்க்க வேண்டும்.”

 

இந்த கட்டத்தில், நாம் செயல்படுத்த வேண்டும் அம்சம் ஒரு பொது யோசனை.

தவிர: DCIகூடுதல் முறையான செயல்படுத்த வழக்கு பயன்படுத்த ஒரு பயனர் கதை திருப்பு தேவைப்படும். பயன்பாடு வழக்கு பின்னர் உள்ளீடு, வெளியீடு, ஊக்கம், பாத்திரங்கள், முதலியன மேலும் விளக்கங்களை வழங்குவதாக

சில சோதனைகள் எழுதவும்

நாம் இந்த வசதியை ஒரு ஏற்பு சோதனை எழுதவும் இந்த கட்டத்தில் போதுமான வேண்டும். பயன்படுத்த அனுமதிக்க RSpec மற்றும் capybara :

spec/integration/add_to_cart_spec.rb

describe ‘as a user’ do
it ‘has a link to add the book to my cart’ do
@book = Book.new(:title => ‘Lean Architecture’)
visit book_path(@book)
page.should have_link(‘Add To Cart’)
end
end

BDD ஆவி, நாங்கள் எங்கள் டொமைன் மாதிரி (எங்கள் தரவு) இருக்கும் எப்படி அடையாளம் ஆரம்பித்துவிட்டேன். நாம் வேதத்தைக் ஒரு தலைப்பு பண்பு கொண்டிருக்கும் என்று தெரியும். DCIஆவி, நாங்கள் இந்த பயன்படுத்தலாம் வழக்கு இயற்றியுள்ளது எந்த சூழலும் முக்கிய பகுதிகளில் விளையாட எந்த நடிகர்கள் அடையாளம். சூழல் வண்டியில் ஒரு புத்தகம் சேர்த்து வருகிறது. நாங்கள் கண்டுபிடித்திருக்கிறோம் நடிகர் பயனர் உள்ளது.

தத்ரூபமாக, நாம் இப்போது நன்றாக மேலும் இந்த வசதியை மறைப்பதற்கு சோதனைகள் ஆனால் மேலே வழக்குகள் எங்களுக்கு சேர்க்க வேண்டும்.

“பங்களிப்பு”

நடிகர்கள் கதாபாத்திரங்களில். இந்த குறிப்பிட்ட அம்சம், நாம் உண்மையில் ஒரே ஒரு நடிகர், பயனர் வேண்டும். பயனர் தங்கள் வண்டியில் ஒரு பொருளை சேர்க்க பார்த்து ஒரு வாடிக்கையாளர் பங்கு வகிக்கிறது. பாத்திரங்கள் கணினியில் என்ன வரையறுக்க பயன்படுத்த வழிமுறைகளை விவரிக்க.

அது வரை குறியீடு நாம்:

app/roles/customer.rb

module Customer
def add_to_cart(book)
self.cart << book
end
end

எங்கள் வாடிக்கையாளர் பாத்திரத்தை உருவாக்குதல் எங்கள் தரவு மாதிரி, பயனர் பற்றி மேலும் தகவல் கிண்டல் உதவியது. இப்போது நாம் வாடிக்கையாளர் பங்கு வகிக்கிறது எந்த தரவு பொருட்களின் மீது ஒரு #cart முறை வேண்டும் என்று.

மேலே வரையறுக்கப்பட்ட வாடிக்கையாளர் பங்கு #cart என்ன பற்றி மிகவும் வெளிப்படுத்தாது. நான் மேலே நேரத்தில் செய்து ஒரு வடிவமைப்பு முடிவு, எளிமை பொருட்டு, வண்டி பதிலாக sesssion தரவுத்தள சேமிக்கப்படும் விருக்கிறார். வாடிக்கையாளர் பங்கு விளையாடும் எந்த நடிகர் இல் வரையறுக்கப்பட்ட #cart முறை ஒரு வண்டி ஒரு விரிவான செயல்படுத்த இருக்க கூடாது. நான் வெறுமனே ஒரு எளிய சங்கம் கொள்கிறேன்.

பாத்திரங்கள் கூட பாலிமார்பிஸத்துடனான நன்றாக விளையாட. வாடிக்கையாளர் பாத்திரத்தை #cart முறை காரணம் என பதிலளிக்கும் எந்த பொருள் நடித்தார். பங்கு தன்னை அது சூழல் அந்த முடிவிற்கு வரை விட்டு, அதிகரிக்க செய்யும் பொருள் என்ன வகை தெரியும்.

சில சோதனைகள் எழுதவும்

சோதிக்கும் முறையில் மீண்டும் குதிக்க மற்றும் புதிதாக உருவாக்கப்பட்ட பாத்திரம் சுற்றி சில சோதனைகள் எழுத அனுமதிக்க.

spec/roles/customer_spec.rb

describe Customer do
let(:user) { User.new }
let(:book) { Book.new }

before do
user.extend Customer
end

describe ‘#add_to_cart’ do
it ‘puts the book in the cart’ do
user.add_to_cart(book)
user.cart.should include(book)
end
end
end

நாங்கள், ஒரு குறிப்பிட்ட பின்னணியில், இந்த பாத்திரம், வாடிக்கையாளர் பயன்படுத்தி வண்டியில் ஒரு புத்தகம் சேர்த்து வேண்டும் எப்படி மேலே சோதனை குறியீடு கூட வெளிப்படுத்துகிறது. இந்த உண்மையில் சூழல் இறந்த எளிய எழுதி Segway செய்கிறது.

“சூழல்”

DCIஇல், சூழல் தரவு அவர்களின் பங்களிப்பு இயக்க பொருள்கள் எந்த சூழல். ஒவ்வொரு ஒரு பயனர் கதை குறைந்தபட்சம் ஒரு சூழல் எப்போதும் உள்ளது. பயனர் கதை சிக்கலான பொறுத்து, சாத்தியமான ஒரு கதை இடைவெளி கீழே அத்தியாவசியமாக்குகிறது.சில மேற்பட்ட சூழல் இருக்கலாம். சூழல் நோக்கம் தரவு பொருள்கள் (அமைப்பு என்ன) க்கு (கணினியில் என்ன) பாத்திரங்கள் இணைக்க வேண்டும்.

இந்த கட்டத்தில், நாம் பயன்படுத்தி கொள்ள வேண்டும் பங்கு, வாடிக்கையாளர் தெரியும், மற்றும் நாம் augmenting வேண்டும் தரவு பொருள், பயனர் பற்றி ஒரு வலுவான யோசனை.

அது வரை குறியீடு நாம்:

app/contexts/add_to_cart_context.rb

class AddToCartContext
attr_reader :user, :book

def self.call(user, book)
AddToCartContext.new(user, book).call
end

def initialize(user, book)
@user, @book = user, book
@user.extend Customer
end

def call
@user.add_to_cart(@book)
end
end

புதுப்பிக்கப்பட்டது: தறுவாய்கள் ஜிம் Coplien செயல்படுத்த AddToCartContext # சூழலில் தூண்டுதல் இயக்க பயன்படுத்துகிறது. ரூபி சொற்றொடர்கள், procs மற்றும் lambdas ஆதரவு, உதாரணங்கள் AddToCartContext # அழைப்பு பயன்படுத்த மாற்றப்பட்டுள்ளன.

கவனிக்க வேண்டிய சில முக்கிய புள்ளிகள் இருக்கிறது:

• ஒரு சூழல் ஒரு வர்க்கம் வரையறுக்கப்படுகிறது. வர்க்கம் instantiating மற்றும் அது அழைப்பு செயல் தூண்டும் என அறியப்படுகிறது #call முறை தான்.
• வர்க்கம் முறை AddToCartContext.call கொண்டு வெறுமனே தூண்டுவதில் உதவுவதற்காக ஒரு வசதிக்காக முறையாகும்.
• DCIசாரம் @ user.extend வாடிக்கையாளர் உள்ளது. Augmenting தரவு பாத்திரங்கள் தற்காலிக வலுவான பிணைநீக்கத்திற்காக அனுமதிக்கிறது என்ன உருவாக்க முடியும். பொருட்களை பாத்திரங்கள் புகுத்த, #extend ஒன்று இருப்பது ஒரு மில்லியன் வழிகள் இருக்கின்றன. ஒரு ஆண்டில் பின்தொடர்தல் கட்டுரை , நான் இந்த அடைய முடியும் இதில் மற்ற வழிகள் உரையாற்ற வேண்டும்.
• சூழல் பயனர் மற்றும் புத்தகம் பொருட்களை கடந்து பங்கு முறைகள் பற்றிய மோதல்கள் பெயரிடும் ஏற்படலாம். இந்த போக்க உதவ, அதை USER_ID கடந்து மற்றும் சூழல் ஒரு book_id மற்றும் சூழல் சம்பந்தமான பொருட்கள், சேது அனுமதிக்க ஏற்றுக்கொள்ள வேண்டும்.
• ஒரு சூழல் அதை செயல்படுத்த எந்த நடிகர்கள் அம்பலப்படுத்த வேண்டும். இந்த வழக்கில், attr_readeruser மற்றும்book வெளிப்படுத்துவதற்காக பயன்படுத்தப்படுகிறது. book எனினும் அது முழுமையான க்கான வெளிப்படும், இந்த சூழலில் ஒரு நடிகராக அல்ல.
• மிக noteably: (அசாத்திய) ஒரு பொருளிலிருந்து ஒரு பங்கு #unextend நீங்கள் அரிதாக வேண்டும். தரவு பொருள் வழக்கமாக மட்டுமே ஒரு குறிப்பிட்ட சூழல் உள்ள ஒரு நேரத்தில் ஒரு பங்கு வகிக்கும். (: பயன்பாடு வழக்கு ஒன்றுக்கு, பயனர் கதை முக்கியத்துவம்) மட்டுமே பயன்படுத்த வழக்கு ஒன்றுக்கு ஒரு சூழல் இருக்க வேண்டும். எனவே, நாங்கள் அரிதாக செயல்பாடு நீக்க அல்லது பெயரிடும் மோதல்கள் அறிமுகப்படுத்த வேண்டும் வேண்டும். டிசிஐ, அது ஒரு குறிப்பிட்ட சூழலில் ஒரு பொருள் ஒரு பல பாத்திரங்களை புகுத்த ஏற்றுக்கொள்கிறார். எனவே மோதல்கள் பெயரிடும் பிரச்சனை இன்னும் வாழ்கிறது ஆனால் அரிதாக ஏற்படும் வேண்டும்.

சில சோதனைகள் எழுதவும்

நான் பொதுவாக கேலி மற்றும் stubbing ஒரு பெரிய ஆதரவாளராக இல்லை ஆனால் நான் நாம் ஏற்கனவே நம் பங்கு கண்ணாடியை குறியீடு இயங்கும் சோதனை செய்த ஏனெனில் அது சூழல்களில் வழக்கில் பொருத்தமான என்று நான் நினைக்கிறேன். இந்த இடத்தில் நாம் வெறும் ஒருங்கிணைப்பு சோதனை செய்கிறோம்.

“டேட்டா”

தரவு மெலிந்த இருக்க வேண்டும். கட்டைவிரல் ஒரு நல்ல ஆட்சியை உங்கள் மாதிரிகள் முறைகள் வரையறுக்க முடியாது உள்ளது. இந்த எப்போதும் வழக்கு அல்ல. சிறந்த புட்: “டேட்டா பொருள் இடைமுகங்கள் எளிய மற்றும் குறைந்தபட்ச உள்ளன: போதும் டொமைன் பண்புகள் கைப்பற்ற ஆனால் எந்த குறிப்பிட்ட சூழ்நிலையில் தனிப்பட்ட என்று நடவடிக்கைகளை இல்லாமல்” (லீன் கட்டுமானம்). தரவு உண்மையில் மட்டுமே தொடர்ந்திருந்தன தரவு பயன்படுத்தப்படுகிறது எப்படி என்பதையும், நிலைபேறு உயர்நிலை முறைகளுக்கு உள்ளடக்கியதாக இருக்க வேண்டும். நாம் ஏற்கனவே அடிப்படை பண்புகளை கிண்டல் நான் எந்த புத்தகத்தை மாதிரி பார்க்கிறேன்.

app/controllers/book_controller.rb

class BookController < ApplicationController def add_to_cart AddToCartContext.call(current_user, Book.find(params[:id])) end end

இங்கே DCIரெயில்ஸ் மீதமுள்ள பாராட்டுக்களை எப்படி விவரிக்கும் ஒரு வரைபடம் இருக்கிறது. சூழல் பயனர் இடைமுகம் மற்றும் தரவு மாதிரியை இடையே ஒரு நுழைவாயில் ஆகிறது.

நாம் என்ன செய்தோம்

பின்வரும் அது சொந்த கட்டுரை தான் அளிக்கவில்லை முடியும், ஆனால் நான் சுருக்கமாக DCIகொண்டு அமைப்பதாகும் குறியீடு நன்மைகள் சில பார்க்க வேண்டும்.

• நாம் மிகவும் தரவு உண்மையில் சேமிக்கப்பட்ட இருந்து கணினி செயல்பாடு decoupled. இது எங்களுக்கு சுருக்க மற்றும் எளிதாக பாலிமர்பிஸம்கள் சேர்க்கப்பட்ட நன்மை கொடுக்கிறது.
• நாம் படிக்க குறியீடு உருவாக்கப்பட்டது. அவற்றுள் கோப்புப்பெயர்கள் மற்றும் உள்ள வழிமுறைகளை பயன்படுத்தி குறியீடு இருவரும் சுமார் காரணம் எளிது. இது அனைத்து நன்றாக ஏற்பாடு. பார்க்கவும் கோப்பு-நிலை வாசிப்பு பற்றி மாமா பாப் ஜீரண .
• நாம் முன்னேற மற்றும் கணினியில் என்ன பாத்திரங்கள் மேலாளர் போது நமது தரவு மாதிரி, அமைப்பு என்ன, நிலையாக இருக்க முடியும்.
• நாம் நெருங்கி இறுதி பயனர் மன மாதிரி குறிக்கும் வந்திருக்கிறேன். இந்த மீதமுள்ள முதன்மை நோக்கம் காலப்போக்கில் வளைக்கப்பட்டது வருகிறது என்று ஒன்று உள்ளது.

ஆம், நாம் சிக்கலான மற்றொரு அடுக்கு சேர்த்து வருகிறோம். நாம் எமது பாரம்பரிய மீதமுள்ள மேல் சூழல் மற்றும் பங்களிப்பு கண்காணிக்க வேண்டும். சூழல், குறிப்பாக, இன்னும் குறியீடு வெளிப்படுத்துகின்றன. நாம் இன்னும் கொஞ்சம் மேல்நிலை அறிமுகப்படுத்த. எனினும், இந்த மேல்நிலை செழிப்புடன் ஒரு பெரிய பட்டம் வருகிறது. டெவலப்பர்கள் ஒரு டெவலப்பர் அல்லது குழு, அது இந்த நன்மைகள் உங்கள் வணிக மற்றும் பொறியியல் வியாதிகளுக்கு தீர்க்க முடியும் என்பதை உங்கள் descretion தான்.

இறுதி வார்த்தைகள்

DCIசிக்கல்கள் ஆகியவைகள் உள்ளன. முதலில், இது ஒரு பெரிய மாற்றம் தேவைப்படுகிறது. அது மீதமுள்ள (மாதிரி காட்சி கட்டுப்பாட்டாளர்) பாராட்டு வடிவமைக்கப்பட்டுள்ளது அது ரெயில்ஸ் நன்றாக பொருந்துகிறது ஆனால் அது கட்டுப்படுத்தி மற்றும் மாதிரி வெளியே உங்கள் குறியீடு நகர்த்த வேண்டும். நாம் அனைத்து தெரியும், ரெயில்ஸ் சமூகம் மாதிரிகள் மற்றும் கட்டுப்பாட்டு உள்ள குறியீடு வைப்பதற்கான ஒரு காரணமின்றி உள்ளது. மாற்றம், சில பயன்பாடுகள் ஒரு பெரிய மேலாளர் தேவைப்படும் என்று ஏதாவது பெரியது. எனினும், DCIஒருவேளை பயன்பாடுகள் படிப்படியாக DCIவேண்டும் “கொழுப்பு மாதிரிகள், ஒல்லியாக கட்டுப்பாட்டு” இருந்து மாற்ற அனுமதிக்கிறது ஒரு வழக்கு மூலம் வழக்கு அடிப்படையில் உள்ள refactored. இரண்டாவது, அது முக்கியமான செயல்திறன் சீரழிவதற்கு செல்கிறது காரணமாக பொருட்களை இந்த விளம்பரத்தை நீட்டிக்கப்பட்டுள்ளது என்று உண்மையில்,.

ரூபி சமூகம் தொடர்பாக DCIமுக்கிய நன்மை அது பராமரிக்கப்படுகிறது குறியீடு விவாதிக்க இது ஒரு அமைப்பு வழங்குகிறது. என்ற தொனியில் சமீபத்திய விவாதம் நிறைய இருந்தது “‘கொழுப்பு மாதிரிகள், ஒல்லியாக கட்டுப்பாட்டு மோசமாக உள்ளது’; உங்கள் கட்டுப்படுத்தி அல்லது உங்கள் மாதிரி உள்ள குறியீடு வைக்க வேறு அதை வைக்க வேண்டாம்.” பிரச்சனை நாங்கள் எங்கள் குறியீடு இடங்களில் இருக்க வேண்டும் வழிகாட்டல் இல்லாத மற்றும் அது எப்படி கட்டமைக்கப்பட வேண்டும். நாம் அது மாதிரி, நாம் கட்டுப்படுத்தி அதை விரும்பவில்லை விரும்பவில்லை, நாம் நிச்சயமாக பார்வையில் அது விரும்பவில்லை. பெரும்பாலான, இந்த தேவைகள் ஒட்டியுள்ள குழப்பம், மிகைப் பொறியியல், நிலைத்தன்மையும் ஒரு பொது பற்றாக்குறை ஏற்படுகிறது. DCIஎங்களுக்கு ரெயில்ஸ் அச்சு உடைத்து மற்றும் பராமரிக்கப்படுகிறது, testable, decoupled குறியீடு உருவாக்க ஒரு செயல்திட்டமாக கொடுக்கிறது.

தவிர: இந்த பகுதியில் வேறு வேலை இருந்தது. Avdi கிரிம் என்று ஒரு phenominal புத்தகம் உள்ளது ரூபி ஆன் பொருள்கள் மாற்று தீர்வுகள் முன்மொழிவின்.