ਕੋਡ ਡੁਪਲੀਕੇਸ਼ਨ ਗਲਤ ਐਬਸਟਰੈਕਸ਼ਨ ਨਾਲੋਂ ਸਸਤੀ ਹੈ
ਡਿਵੈਲਪਰ DRY ਸਿਧਾਂਤ ਨੂੰ ਪਸੰਦ ਕਰਦੇ ਹਨ।
ਤੁਸੀਂ ਆਪਣੇ ਆਪ ਨੂੰ ਦੁਹਰਾਉਣ ਤੋਂ ਬਚਣਾ ਚਾਹੁੰਦੇ ਹੋ। ਤੁਸੀਂ ਸ਼ਾਨਦਾਰ ਅਤੇ ਮੁੜ ਵਰਤੋਂ ਯੋਗ (reusable) ਕੋਡ ਚਾਹੁੰਦੇ ਹੋ।
ਪਰ ਇਹ ਟੀਚਾ ਅਕਸਰ ਇੱਕ ਜਾਲ ਵੱਲ ਲੈ ਜਾਂਦਾ ਹੈ: ਸਮੇਂ ਤੋਂ ਪਹਿਲਾਂ ਕੀਤੀ ਗਈ ਐਬਸਟਰੈਕਸ਼ਨ (premature abstraction)।
ਕੋਡ ਨੂੰ ਦੁਹਰਾਉਣਾ ਗਲਤ ਲੱਗਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਡੁਪਲੀਕੇਸ਼ਨ ਅਕਸਰ ਇੱਕ ਮਾੜੀ ਐਬਸਟਰੈਕਸ਼ਨ ਨਾਲੋਂ ਸਸਤੀ ਹੁੰਦੀ ਹੈ।
ਅਸੀਂ ਸੰਪੂਰਨ ਮੋਡਿਊਲਰ ਸਿਸਟਮ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਾਂ। ਅਸੀਂ ਜਟਿਲਤਾ (complexity) ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਪੈਟਰਨਾਂ ਦੀ ਭਾਲ ਕਰਦੇ ਹਾਂ ਅਤੇ ਲੌਜਿਕ (logic) ਕੱਢਦੇ ਹਾਂ।
ਚੰਗੀ ਤਰ੍ਹਾਂ ਡਿਜ਼ਾਈਨ ਕੀਤੀਆਂ ਐਬਸਟਰੈਕਸ਼ਨਾਂ ਸਾਫਟਵੇਅਰ ਨੂੰ ਸਕੇਲ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦੀਆਂ ਹਨ।
ਪਰ ਬਹੁਤ ਸਾਰੀਆਂ ਐਬਸਟਰੈਕਸ਼ਨਾਂ ਬਹੁਤ ਜਲਦੀ ਬਣਾ ਦਿੱਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਜੇਕਰ ਤੁਸੀਂ ਸਮੱਸਿਆ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਨਹੀਂ ਸਮਝਦੇ, ਤਾਂ ਤੁਹਾਡੀ ਐਬਸਟਰੈਕਸ਼ਨ ਇੱਕ ਬੋਝ (liability) ਬਣ ਜਾਂਦੀ ਹੈ।
ਇੱਕ ਗਲਤ ਐਬਸਟਰੈਕਸ਼ਨ ਕਈ ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਕਰਦੀ ਹੈ:
- ਓਵਰ-ਇੰਜੀਨੀਅਰਿੰਗ (Over-engineering): ਤੁਸੀਂ ਸਧਾਰਨ ਸਮੱਸਿਆਵਾਂ ਲਈ ਗੁੰਝਲਦਾਰ ਹੱਲ ਬਣਾਉਂਦੇ ਹੋ।
- ਰਿਜਿਡਿਟੀ (Rigidity): ਤੁਹਾਡਾ ਕੋਡ ਬਦਲਣਾ ਮੁਸ਼ਕਲ ਹੋ ਜਾਂਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹ ਅਜਿਹੇ ਭਵਿੱਖ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ ਜੋ ਕਦੇ ਹੁੰਦਾ ਹੀ ਨਹੀਂ।
- ਧੁੰਦਲਾ ਇਰਾਦਾ (Obscured Intent): ਬਿਜ਼ਨਸ ਲੌਜਿਕ ਜੈਨਰਿਕ ਇੰਟਰਫੇਸਾਂ ਦੀਆਂ ਪਰਤਾਂ ਹੇਠਾਂ ਲੁਕ ਜਾਂਦਾ ਹੈ। ਇਸ ਨਾਲ ਡੀਬੱਗਿੰਗ (debugging) ਕਰਨਾ ਮੁਸ਼ਕਲ ਹੋ ਜਾਂਦਾ ਹੈ।
- ਟਾਈਟ ਕਪਲਿੰਗ (Tight Coupling): ਤੁਹਾਡੇ ਸਿਸਟਮ ਦੇ ਹਿੱਸੇ ਖੁਦ ਐਬਸਟਰੈਕਸ਼ਨ ਨਾਲ ਹੀ ਜੁੜ ਜਾਂਦੇ ਹਨ।
ਇਸਦੀ ਕੀਮਤ ਬਹੁਤ ਜ਼ਿਆਦਾ ਹੈ। ਤੁਸੀਂ ਉਪਭੋਗਤਾ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਦੀ ਬਜਾਏ ਆਪਣੇ ਆਪ ਦੇ ਆਰਕੀਟੈਕਚਰ ਨਾਲ ਲੜਨ ਵਿੱਚ ਸਮਾਂ ਬਿਤਾਉਂਦੇ ਹੋ। ਇਹ ਤੁਹਾਡੀ ਟੀਮ ਦੀ ਰਫ਼ਤਾਰ ਨੂੰ ਹੌਲੀ ਕਰ ਦਿੰਦਾ ਹੈ ਅਤੇ ਰੀਫੈਕਟਰੀਂਗ (refactoring) ਨੂੰ ਮੁਸ਼ਕਲ ਬਣਾਉਂਦਾ ਹੈ।
ਮੈਂ ਤੁਹਾਨੂੰ ਸਭ ਕੁਝ ਕਾਪੀ ਅਤੇ ਪੇਸਟ ਕਰਨ ਲਈ ਨਹੀਂ ਕਹਿ ਰਿਹਾ ਹਾਂ। ਮੈਂ ਇੱਕ ਵਿਹਾਰਕ (pragmatic) ਪਹੁੰਚ ਦਾ ਸੁਝਾਅ ਦੇ ਰਿਹਾ ਹਾਂ।
ਕੰਟਰੋਲਡ ਡੁਪਲੀਕੇਸ਼ਨ ਨੂੰ ਇੱਕ ਸਾਧਨ ਵਜੋਂ ਵਰਤੋ। ਇਸਦੀ ਵਰਤੋਂ ਉਹਨਾਂ ਖੇਤਰਾਂ ਵਿੱਚ ਕਰੋ ਜਿੱਥੇ ਲੋੜਾਂ ਤੇਜ਼ੀ ਨਾਲ ਬਦਲਦੀਆਂ ਹਨ ਜਾਂ ਜਿੱਥੇ ਤੁਹਾਨੂੰ ਅਨਿਸ਼ਚਿਤਤਾ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪੈਂਦਾ ਹੈ।
ਐਬਸਟਰੈਕਸ਼ਨ ਬਣਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਉਦੋਂ ਤੱਕ ਉਡੀਕ ਕਰੋ ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਪੈਟਰਨ ਨੂੰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਨਹੀਂ ਦੇਖ ਲੈਂਦੇ।