एज केस कैसे आपके आदर्श समाधान में छिपी कमजोरियों को प्रकट करते हैं

आपने अपने पागल टेस्टिंग समस्या का सही समाधान ढूंढ लिया। आपको बस DEFAULT_HOST कॉन्स्टेंट को ओवरराइड करना है, और आप व्यवसाय में होंगे।

सिवाय इसके कि आपको उस भद्दे संदेश को दूर करने के लिए वार्निंग्स बंद करने होंगे। लेकिन अब आपके सभी टेस्ट पास हो जाते हैं, और आपको केवल कुछ लाइनें बदलनी पड़ीं!

उस एक टेस्ट को छोड़कर जहां आप नहीं चाहते कि होस्ट ओवरराइड हो। लेकिन आप बस कॉन्स्टेंट को फिर से ओवरराइड कर सकते हैं, वार्निंग्स को फिर से बंद कर सकते हैं, और सुनिश्चित कर सकते हैं कि यह टेस्ट के अंत में रीसेट हो जाए। आप पूरा होने के इतने करीब हैं, आप लगभग इसका स्वाद ले सकते हैं!

सिवाय… सिवाय… सिवाय…

और कुछ दिनों बाद, जब आप सत्ताईसवीं बार अटक जाते हैं और आपका ऐप हैक्स का एक विशाल गोला बन गया है, तो आप पीछे हटेंगे और आश्चर्य करेंगे: मैं यह सब क्यों कर रहा हूं? क्या समाधान समस्या से भी बदतर नहीं है?

बहुत चालाक समस्या को कैसे हल करें

यह स्पष्ट है कि आपका मूल विचार आपकी पूरी समस्या को हल नहीं करेगा। तो आप एक बेहतर विचार कैसे सोचते हैं, जो उन सभी एज केसेज को हल करता है जिन्हें आपका मूल विचार नहीं कर सका?

आप नहीं कर सकते। आप बहुत अधिक चालाकी से अधिक चालाकी से नहीं लड़ सकते। कम से कम, सीधे नहीं। इसके बजाय, दूसरी तरफ जाएं। सरल जाएं। सीधे जाएं।

इसका क्या मतलब है?

उस कोड को इंलाइन करें जिसे आप अमूर्त करने की कोशिश कर रहे थे। खुद को दोहराएं। अपने कोड को स्पष्ट रखें।

यदि आप एक अलग डिफ़ॉल्ट होस्ट के साथ DEFAULT_HOST कॉन्स्टेंट को ओवरराइड करने की कोशिश कर रहे थे, तो डिफ़ॉल्ट के पूरे विचार को भूल जाएं। बस इसे हर बार निर्दिष्ट करें।

इसलिए, इसके बजाय:

test/integration/welcome_test.rb

require 'test_helper'
silence_warnings do
  Rack::Test::DEFAULT_HOST = "www.justinweiss.com"
end
class WelcomeTest < ActionDispatch::IntegrationTest
  include Rack::Test::Methods
  test "can visit the homepage" do
    get "/"
    # ...
  end
  # ...
end

कुछ ऐसा करें:

test/integration/welcome_test.rb

require 'test_helper'
class WelcomeTest < ActionDispatch::IntegrationTest
  test "can visit the homepage" do
    get "https://www.justinweiss.com/"
    # ...
  end
  # ...
end

जब भी मेरे प्रतीत होने वाले सही समाधान टूटते हैं, तो ऐसा इसलिए होता है क्योंकि मैंने उन एज केसेज की कल्पना नहीं की थी जिन्हें मुझे अंततः संभालना होगा।

यह ठीक है। हम भविष्य की भविष्यवाणी नहीं कर सकते। लेकिन जब आप इसे होते हुए देखते हैं, तो खुदाई करना बंद करें। केवल पैच दर पैच लागू न करें। इसके बजाय, अपने मूल समाधान को खोल दें और एक बेहतर समाधान निकालें।

बेहतर समाधान कैसे निकालें

जब आपका सारा कोड स्पष्ट, सीधे तरीके से लिखा गया हो, तो आप इसे पुनर्गठित करने के तरीकों के बारे में सोचना शुरू कर देंगे।

आमतौर पर, सही जगह पर Extract Method या Extract Class लागू करना पर्याप्त होता है। चाल यह तय करना है कि वह सही जगह क्या है। लेकिन यह पता लगाना बहुत आसान है जब आप अपने सामने बहुत सारी दोहराव देखते हैं।

और विरासत और डेलीगेशन पर भरोसा करें। वे सरल बिल्डिंग ब्लॉक्स हैं जो आपको बहुत चालाक बने बिना अपने कोड को साफ करने में मदद करेंगे।

एक और बात

डॉक्यूमेंटेशन पढ़ना न भूलें:

test/integration/welcome_test.rb

require 'test_helper'
class WelcomeTest < ActionDispatch::IntegrationTest
  setup do
    # यह पहले से मौजूद है:
    host! "www.justinweiss.com"
  end
  test "can visit the homepage" do
    get "/"
    # ...
  end
  # ...
end

उत्तर हमेशा इतना स्पष्ट नहीं होगा। लेकिन यह महसूस करने से ज्यादा विनम्र कुछ नहीं है कि जिस सटीक समस्या को हल करने के लिए आपने तीन क्लासेस और एक जेम लिखा था, उसके लिए एक-मेथड बिल्ट-इन समाधान है।

अंत में एक बेहतर समाधान

आपका दूसरा समाधान आमतौर पर आपके मूल समाधान की तुलना में हर तरह से बेहतर होगा।

ऐसा क्यों है?

आपके पास एक डेवलपर के रूप में अधिक अनुभव है।

इसलिए आपके पास इस बारे में बेहतर विचार होगा कि अच्छा कोड क्या बनाता है।
आप उस प्रणाली के बारे में अधिक जानते हैं जिसे आपने बनाया है।

इसलिए आप इस बारे में बेहतर निर्णय ले सकते हैं कि आप जो कोड लिख रहे हैं वह इसमें कैसे फिट बैठता है।
आप जानते हैं कि आपकी कौन सी धारणाएं गलत थीं

इसलिए आपके समाधान उन वास्तविक समस्याओं को बेहतर ढंग से फिट कर सकते हैं जो मौजूद हैं, न कि उन समस्याओं को जिनकी आपने कल्पना की थी कि वे हो सकती हैं।

और अंत में, आपकी चालाकी का सबसे अच्छा हिस्सा वापस फिट हो सकता है। इस बार, हैक्स के बिना।

आपको खुदाई रोकनी होगी

चालाक कोड लिखना मजेदार है। रूबी में, इसे लिखना भी आसान है। और यह विशेष रूप से आसान है कि आप एक रास्ते पर चलते रहें, तब भी जब आप जानते हैं कि यह आपको गलत जगह ले जा रहा है।

लेकिन एक बार जब आपको वह कचोटने वाली भावना मिलती है कि कुछ सही नहीं है, तो एक मिनट के लिए रुकें। अपने कोड को अन-फैक्टर करें। डॉक्यूमेंटेशन पढ़ें। अपने कोड को स्पष्ट और सीधा बनाएं। और एक बेहतर तरीका खोजें।

क्या आपको याद है कि आखिरी बार आपने खुद को एक ऐसे गड्ढे में खोदा था जो खत्म ही नहीं होता था? आप इससे कैसे निकले? और आपके द्वारा अंत में प्राप्त कोड कैसा दिखता था?