ਕਿਸੇ ਅਜਿਹੀ ਚੀਜ਼ ਨੂੰ ਵਿਕਸਤ ਕਰਨ ਲਈ ਸਹਿਮਤ ਨਾ ਹੋਵੋ ਜੋ ਤੁਸੀਂ ਨਹੀਂ ਸਮਝਦੇ

2018 ਦੀ ਸ਼ੁਰੂਆਤ ਤੋਂ, ਮੈਂ ਟੀਮ ਵਿੱਚ ਲੀਡ/ਬੌਸ/ਲੀਡ ਡਿਵੈਲਪਰ ਦਾ ਅਹੁਦਾ ਸੰਭਾਲ ਰਿਹਾ ਹਾਂ - ਜੋ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਉਸਨੂੰ ਕਹੋ, ਪਰ ਗੱਲ ਇਹ ਹੈ ਕਿ ਮੈਂ ਇੱਕ ਮਾਡਿਊਲ ਅਤੇ ਕੰਮ ਕਰਨ ਵਾਲੇ ਸਾਰੇ ਡਿਵੈਲਪਰਾਂ ਲਈ ਪੂਰੀ ਤਰ੍ਹਾਂ ਜ਼ਿੰਮੇਵਾਰ ਹਾਂ। ਇਸ 'ਤੇ. ਇਹ ਸਥਿਤੀ ਮੈਨੂੰ ਵਿਕਾਸ ਪ੍ਰਕਿਰਿਆ 'ਤੇ ਇੱਕ ਨਵਾਂ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਦਿੰਦੀ ਹੈ, ਕਿਉਂਕਿ ਮੈਂ ਵਧੇਰੇ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹਾਂ ਅਤੇ ਫੈਸਲੇ ਲੈਣ ਵਿੱਚ ਵਧੇਰੇ ਸਰਗਰਮੀ ਨਾਲ ਸ਼ਾਮਲ ਹਾਂ। ਹਾਲ ਹੀ ਵਿੱਚ, ਇਹਨਾਂ ਦੋ ਚੀਜ਼ਾਂ ਲਈ ਧੰਨਵਾਦ, ਮੈਨੂੰ ਅਚਾਨਕ ਅਹਿਸਾਸ ਹੋਇਆ ਕਿ ਸਮਝ ਦਾ ਮਾਪ ਕੋਡ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਕਿੰਨਾ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ.

ਜੋ ਬਿੰਦੂ ਮੈਂ ਬਣਾਉਣਾ ਚਾਹੁੰਦਾ ਹਾਂ ਉਹ ਇਹ ਹੈ ਕਿ ਕੋਡ (ਅਤੇ ਅੰਤਮ ਉਤਪਾਦ) ਦੀ ਗੁਣਵੱਤਾ ਇਸ ਗੱਲ ਨਾਲ ਨੇੜਿਓਂ ਜੁੜੀ ਹੋਈ ਹੈ ਕਿ ਉਹ ਲੋਕ ਜੋ ਕੋਡ ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰ ਰਹੇ ਹਨ ਅਤੇ ਲਿਖ ਰਹੇ ਹਨ, ਉਹ ਕੀ ਕਰ ਰਹੇ ਹਨ ਬਾਰੇ ਕਿੰਨੇ ਜਾਣੂ ਹਨ।

ਤੁਸੀਂ ਸ਼ਾਇਦ ਹੁਣੇ ਸੋਚ ਰਹੇ ਹੋਵੋਗੇ, "ਧੰਨਵਾਦ, ਕੈਪ. ਬੇਸ਼ੱਕ, ਇਹ ਸਮਝਣਾ ਚੰਗਾ ਹੋਵੇਗਾ ਕਿ ਤੁਸੀਂ ਆਮ ਤੌਰ 'ਤੇ ਕੀ ਲਿਖ ਰਹੇ ਹੋ. ਨਹੀਂ ਤਾਂ, ਤੁਸੀਂ ਮਨਮਾਨੇ ਚਾਬੀਆਂ ਨੂੰ ਮਾਰਨ ਲਈ ਬਾਂਦਰਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਨੂੰ ਕਿਰਾਏ 'ਤੇ ਲੈ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ ਉਸੇ 'ਤੇ ਛੱਡ ਸਕਦੇ ਹੋ। ਅਤੇ ਤੁਸੀਂ ਬਿਲਕੁਲ ਸਹੀ ਹੋ। ਇਸ ਅਨੁਸਾਰ, ਮੈਂ ਇਸ ਨੂੰ ਸਮਝਦਾ ਹਾਂ ਕਿ ਤੁਸੀਂ ਇਹ ਮਹਿਸੂਸ ਕਰਦੇ ਹੋ ਕਿ ਤੁਸੀਂ ਜੋ ਕਰ ਰਹੇ ਹੋ ਉਸ ਬਾਰੇ ਇੱਕ ਆਮ ਵਿਚਾਰ ਹੋਣਾ ਜ਼ਰੂਰੀ ਹੈ। ਇਸ ਨੂੰ ਸਮਝ ਦਾ ਜ਼ੀਰੋ ਪੱਧਰ ਕਿਹਾ ਜਾ ਸਕਦਾ ਹੈ, ਅਤੇ ਅਸੀਂ ਇਸ ਦਾ ਵਿਸਥਾਰ ਨਾਲ ਵਿਸ਼ਲੇਸ਼ਣ ਨਹੀਂ ਕਰਾਂਗੇ। ਅਸੀਂ ਵਿਸਤਾਰ ਵਿੱਚ ਦੇਖਾਂਗੇ ਕਿ ਤੁਹਾਨੂੰ ਅਸਲ ਵਿੱਚ ਕੀ ਸਮਝਣ ਦੀ ਲੋੜ ਹੈ ਅਤੇ ਇਹ ਤੁਹਾਡੇ ਦੁਆਰਾ ਰੋਜ਼ਾਨਾ ਲਏ ਗਏ ਫੈਸਲਿਆਂ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ। ਜੇ ਮੈਨੂੰ ਇਹ ਚੀਜ਼ਾਂ ਪਹਿਲਾਂ ਤੋਂ ਪਤਾ ਹੁੰਦੀਆਂ, ਤਾਂ ਇਹ ਮੇਰਾ ਬਹੁਤ ਸਾਰਾ ਸਮਾਂ ਬਰਬਾਦ ਕਰਨ ਅਤੇ ਪ੍ਰਸ਼ਨਾਤਮਕ ਕੋਡ ਨੂੰ ਬਚਾ ਸਕਦਾ ਸੀ।

ਹਾਲਾਂਕਿ ਤੁਸੀਂ ਹੇਠਾਂ ਕੋਡ ਦੀ ਇੱਕ ਲਾਈਨ ਨਹੀਂ ਦੇਖ ਸਕੋਗੇ, ਮੈਂ ਫਿਰ ਵੀ ਵਿਸ਼ਵਾਸ ਕਰਦਾ ਹਾਂ ਕਿ ਇੱਥੇ ਕਹੀ ਗਈ ਹਰ ਚੀਜ਼ ਉੱਚ-ਗੁਣਵੱਤਾ, ਭਾਵਪੂਰਣ ਕੋਡ ਲਿਖਣ ਲਈ ਬਹੁਤ ਮਹੱਤਵ ਰੱਖਦੀ ਹੈ।

ਸਮਝ ਦਾ ਪਹਿਲਾ ਪੱਧਰ: ਇਹ ਕੰਮ ਕਿਉਂ ਨਹੀਂ ਕਰਦਾ?

ਡਿਵੈਲਪਰ ਆਮ ਤੌਰ 'ਤੇ ਆਪਣੇ ਕਰੀਅਰ ਵਿੱਚ ਬਹੁਤ ਜਲਦੀ ਇਸ ਪੱਧਰ 'ਤੇ ਪਹੁੰਚ ਜਾਂਦੇ ਹਨ, ਕਈ ਵਾਰ ਦੂਜਿਆਂ ਦੀ ਮਦਦ ਤੋਂ ਬਿਨਾਂ ਵੀ - ਘੱਟੋ ਘੱਟ ਮੇਰੇ ਅਨੁਭਵ ਵਿੱਚ. ਕਲਪਨਾ ਕਰੋ ਕਿ ਤੁਹਾਨੂੰ ਇੱਕ ਬੱਗ ਰਿਪੋਰਟ ਮਿਲੀ ਹੈ: ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਕੁਝ ਫੰਕਸ਼ਨ ਕੰਮ ਨਹੀਂ ਕਰਦਾ, ਇਸਨੂੰ ਠੀਕ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਤੁਸੀਂ ਕਿਵੇਂ ਅੱਗੇ ਵਧੋਗੇ?

ਮਿਆਰੀ ਸਕੀਮ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ:

1. ਕੋਡ ਦਾ ਉਹ ਟੁਕੜਾ ਲੱਭੋ ਜੋ ਸਮੱਸਿਆ ਪੈਦਾ ਕਰ ਰਿਹਾ ਹੈ (ਇਹ ਕਿਵੇਂ ਕਰਨਾ ਹੈ ਇੱਕ ਵੱਖਰਾ ਵਿਸ਼ਾ ਹੈ, ਮੈਂ ਇਸਨੂੰ ਵਿਰਾਸਤੀ ਕੋਡ ਬਾਰੇ ਆਪਣੀ ਕਿਤਾਬ ਵਿੱਚ ਕਵਰ ਕਰਦਾ ਹਾਂ)
2. ਇਸ ਸਨਿੱਪਟ ਵਿੱਚ ਬਦਲਾਅ ਕਰੋ
3. ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਬੱਗ ਠੀਕ ਹੋ ਗਿਆ ਹੈ ਅਤੇ ਕੋਈ ਰੀਗਰੈਸ਼ਨ ਗਲਤੀ ਨਹੀਂ ਆਈ ਹੈ

ਆਉ ਹੁਣ ਦੂਜੇ ਬਿੰਦੂ 'ਤੇ ਧਿਆਨ ਦੇਈਏ - ਕੋਡ ਵਿੱਚ ਬਦਲਾਅ ਕਰਨਾ। ਇਸ ਪ੍ਰਕਿਰਿਆ ਦੇ ਦੋ ਤਰੀਕੇ ਹਨ. ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਇਹ ਪਤਾ ਲਗਾਉਣਾ ਹੈ ਕਿ ਮੌਜੂਦਾ ਕੋਡ ਵਿੱਚ ਅਸਲ ਵਿੱਚ ਕੀ ਹੋ ਰਿਹਾ ਹੈ, ਗਲਤੀ ਦੀ ਪਛਾਣ ਕਰੋ ਅਤੇ ਇਸਨੂੰ ਠੀਕ ਕਰੋ। ਦੂਜਾ: ਮਹਿਸੂਸ ਕਰਕੇ ਅੱਗੇ ਵਧੋ - ਇੱਕ ਕੰਡੀਸ਼ਨਲ ਸਟੇਟਮੈਂਟ ਜਾਂ ਲੂਪ ਵਿੱਚ ਜੋੜੋ, ਕਹੋ, +1 ਕਰੋ, ਦੇਖੋ ਕਿ ਕੀ ਫੰਕਸ਼ਨ ਲੋੜੀਂਦੇ ਦ੍ਰਿਸ਼ ਵਿੱਚ ਕੰਮ ਕਰਦਾ ਹੈ, ਫਿਰ ਕੁਝ ਹੋਰ ਅਜ਼ਮਾਓ, ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਵਿਗਿਆਪਨ ਅਨੰਤ.

ਪਹਿਲੀ ਪਹੁੰਚ ਸਹੀ ਹੈ. ਜਿਵੇਂ ਕਿ ਸਟੀਵ ਮੈਕਕੋਨਲ ਆਪਣੀ ਕਿਤਾਬ ਕੋਡ ਕੰਪਲੀਟ (ਜਿਸ ਦੀ ਮੈਂ ਬਹੁਤ ਜ਼ਿਆਦਾ ਸਿਫ਼ਾਰਿਸ਼ ਕਰਦਾ ਹਾਂ, ਤਰੀਕੇ ਨਾਲ) ਵਿੱਚ ਵਿਆਖਿਆ ਕਰਦਾ ਹੈ, ਹਰ ਵਾਰ ਜਦੋਂ ਅਸੀਂ ਕੋਡ ਵਿੱਚ ਕੁਝ ਬਦਲਦੇ ਹਾਂ, ਤਾਂ ਸਾਨੂੰ ਭਰੋਸੇ ਨਾਲ ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਇਹ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਭਾਵਤ ਕਰੇਗਾ। ਮੈਂ ਮੈਮੋਰੀ ਤੋਂ ਹਵਾਲਾ ਦੇ ਰਿਹਾ ਹਾਂ, ਪਰ ਜੇਕਰ ਕੋਈ ਬੱਗਫਿਕਸ ਤੁਹਾਡੇ ਦੁਆਰਾ ਉਮੀਦ ਕੀਤੇ ਤਰੀਕੇ ਨਾਲ ਕੰਮ ਨਹੀਂ ਕਰਦਾ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਬਹੁਤ ਚਿੰਤਾ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ ਆਪਣੀ ਪੂਰੀ ਕਾਰਜ ਯੋਜਨਾ 'ਤੇ ਸਵਾਲ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।

ਕੀ ਕਿਹਾ ਗਿਆ ਹੈ ਨੂੰ ਸੰਖੇਪ ਕਰਨ ਲਈ, ਇੱਕ ਵਧੀਆ ਬੱਗ ਫਿਕਸ ਕਰਨ ਲਈ ਜੋ ਕੋਡ ਦੀ ਗੁਣਵੱਤਾ ਨੂੰ ਘਟਾਉਂਦਾ ਨਹੀਂ ਹੈ, ਤੁਹਾਨੂੰ ਕੋਡ ਦੀ ਪੂਰੀ ਬਣਤਰ ਅਤੇ ਖਾਸ ਸਮੱਸਿਆ ਦੇ ਸਰੋਤ ਦੋਵਾਂ ਨੂੰ ਸਮਝਣ ਦੀ ਲੋੜ ਹੈ।

ਸਮਝ ਦਾ ਦੂਜਾ ਪੱਧਰ: ਇਹ ਕੰਮ ਕਿਉਂ ਕਰਦਾ ਹੈ?

ਇਸ ਪੱਧਰ ਨੂੰ ਪਿਛਲੇ ਇੱਕ ਨਾਲੋਂ ਬਹੁਤ ਘੱਟ ਅਨੁਭਵੀ ਰੂਪ ਵਿੱਚ ਸਮਝਿਆ ਗਿਆ ਹੈ। ਮੈਂ, ਅਜੇ ਵੀ ਇੱਕ ਨਵੀਨਤਮ ਡਿਵੈਲਪਰ ਹੋਣ ਦੇ ਬਾਵਜੂਦ, ਇਹ ਮੇਰੇ ਬੌਸ ਦਾ ਧੰਨਵਾਦ ਹੈ, ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਵਾਰ-ਵਾਰ ਨਵੇਂ ਆਏ ਲੋਕਾਂ ਨੂੰ ਮਾਮਲੇ ਦੇ ਸਾਰ ਦੀ ਵਿਆਖਿਆ ਕੀਤੀ.

ਇਸ ਵਾਰ, ਚਲੋ ਕਲਪਨਾ ਕਰੀਏ ਕਿ ਤੁਹਾਨੂੰ ਇੱਕੋ ਸਮੇਂ ਦੋ ਬੱਗ ਰਿਪੋਰਟਾਂ ਪ੍ਰਾਪਤ ਹੋਈਆਂ ਹਨ: ਪਹਿਲੀ ਦ੍ਰਿਸ਼ A ਬਾਰੇ ਹੈ, ਦੂਜੀ ਦ੍ਰਿਸ਼ B ਬਾਰੇ ਹੈ। ਦੋਵਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ, ਕੁਝ ਗਲਤ ਵਾਪਰਦਾ ਹੈ। ਇਸ ਅਨੁਸਾਰ, ਤੁਸੀਂ ਪਹਿਲਾਂ ਪਹਿਲੇ ਬੱਗ ਨਾਲ ਨਜਿੱਠਦੇ ਹੋ। ਅਸੀਂ ਲੈਵਲ 1 ਦੀ ਸਮਝ ਲਈ ਵਿਕਸਿਤ ਕੀਤੇ ਸਿਧਾਂਤਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਤੁਸੀਂ ਸਮੱਸਿਆ ਨਾਲ ਸੰਬੰਧਿਤ ਕੋਡ ਦੀ ਡੂੰਘਾਈ ਵਿੱਚ ਖੋਜ ਕਰੋ, ਇਹ ਪਤਾ ਲਗਾਓ ਕਿ ਇਹ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਦ੍ਰਿਸ਼ A ਵਿੱਚ ਵਿਵਹਾਰ ਕਰਨ ਦਾ ਕਾਰਨ ਕਿਉਂ ਬਣਾਉਂਦੀ ਹੈ, ਅਤੇ ਉਚਿਤ ਵਿਵਸਥਾਵਾਂ ਕਰੋ ਜੋ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਨਤੀਜੇ ਦੀ ਉਮੀਦ ਕਰਦੇ ਹੋ। . ਸਭ ਕੁਝ ਵਧੀਆ ਚੱਲ ਰਿਹਾ ਹੈ।

ਫਿਰ ਤੁਸੀਂ ਦ੍ਰਿਸ਼ B ਵੱਲ ਵਧਦੇ ਹੋ। ਤੁਸੀਂ ਇੱਕ ਗਲਤੀ ਨੂੰ ਭੜਕਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਵਿੱਚ ਦ੍ਰਿਸ਼ ਨੂੰ ਦੁਹਰਾਉਂਦੇ ਹੋ, ਪਰ - ਹੈਰਾਨੀ! - ਹੁਣ ਸਭ ਕੁਝ ਉਸੇ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦਾ ਹੈ ਜਿਵੇਂ ਇਹ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ. ਆਪਣੇ ਅੰਦਾਜ਼ੇ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਬੱਗ A 'ਤੇ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਕੀਤੀਆਂ ਤਬਦੀਲੀਆਂ ਨੂੰ ਅਣਡੂ ਕਰ ਦਿੰਦੇ ਹੋ, ਅਤੇ ਬੱਗ B ਵਾਪਸ ਆ ਜਾਂਦਾ ਹੈ। ਤੁਹਾਡੇ ਬੱਗਫਿਕਸ ਨੇ ਦੋਵਾਂ ਸਮੱਸਿਆਵਾਂ ਦਾ ਹੱਲ ਕੀਤਾ ਹੈ। ਖੁਸ਼ਕਿਸਮਤ!

ਤੁਸੀਂ ਇਸ 'ਤੇ ਬਿਲਕੁਲ ਵੀ ਭਰੋਸਾ ਨਹੀਂ ਕੀਤਾ। ਤੁਸੀਂ ਦ੍ਰਿਸ਼ A ਵਿੱਚ ਗਲਤੀ ਨੂੰ ਠੀਕ ਕਰਨ ਦਾ ਇੱਕ ਤਰੀਕਾ ਲੈ ਕੇ ਆਏ ਹੋ ਅਤੇ ਤੁਹਾਨੂੰ ਇਸ ਗੱਲ ਦਾ ਕੋਈ ਪਤਾ ਨਹੀਂ ਹੈ ਕਿ ਇਹ ਦ੍ਰਿਸ਼ B ਲਈ ਕਿਉਂ ਕੰਮ ਕਰਦਾ ਹੈ। ਇਸ ਪੜਾਅ 'ਤੇ, ਇਹ ਸੋਚਣਾ ਬਹੁਤ ਹੀ ਪਰਤਾਵਾ ਹੈ ਕਿ ਦੋਵੇਂ ਕਾਰਜ ਸਫਲਤਾਪੂਰਵਕ ਪੂਰੇ ਹੋ ਗਏ ਹਨ। ਇਹ ਕਾਫ਼ੀ ਤਰਕਸੰਗਤ ਹੈ: ਬਿੰਦੂ ਗਲਤੀਆਂ ਨੂੰ ਦੂਰ ਕਰਨਾ ਸੀ, ਹੈ ਨਾ? ਪਰ ਕੰਮ ਅਜੇ ਪੂਰਾ ਨਹੀਂ ਹੋਇਆ ਹੈ: ਤੁਹਾਨੂੰ ਅਜੇ ਵੀ ਇਹ ਪਤਾ ਲਗਾਉਣਾ ਪਏਗਾ ਕਿ ਤੁਹਾਡੀਆਂ ਕਾਰਵਾਈਆਂ ਨੇ ਦ੍ਰਿਸ਼ B ਵਿੱਚ ਗਲਤੀ ਨੂੰ ਠੀਕ ਕਿਉਂ ਕੀਤਾ। ਕਿਉਂ? ਕਿਉਂਕਿ ਇਹ ਗਲਤ ਸਿਧਾਂਤਾਂ 'ਤੇ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ, ਅਤੇ ਫਿਰ ਤੁਹਾਨੂੰ ਬਾਹਰ ਨਿਕਲਣ ਦਾ ਕੋਈ ਹੋਰ ਰਸਤਾ ਲੱਭਣ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ. ਇੱਥੇ ਅਜਿਹੇ ਮਾਮਲਿਆਂ ਦੀਆਂ ਕੁਝ ਉਦਾਹਰਣਾਂ ਹਨ:

• ਕਿਉਂਕਿ ਹੱਲ ਗਲਤੀ B ਦੇ ਅਨੁਕੂਲ ਨਹੀਂ ਸੀ, ਸਾਰੇ ਕਾਰਕਾਂ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹੋਏ, ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਅਣਜਾਣੇ ਵਿੱਚ ਫੰਕਸ਼ਨ C ਨੂੰ ਤੋੜਿਆ ਹੋਵੇ।
• ਇਹ ਸੰਭਵ ਹੈ ਕਿ ਉਸੇ ਫੰਕਸ਼ਨ ਨਾਲ ਸਬੰਧਤ ਇੱਕ ਤੀਜਾ ਬੱਗ ਵੀ ਕਿਤੇ ਲੁਕਿਆ ਹੋਇਆ ਹੈ, ਅਤੇ ਤੁਹਾਡਾ ਬੱਗਫਿਕਸ ਦ੍ਰਿਸ਼ B ਵਿੱਚ ਸਿਸਟਮ ਦੇ ਸਹੀ ਸੰਚਾਲਨ ਲਈ ਇਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਹੁਣ ਸਭ ਕੁਝ ਠੀਕ ਲੱਗ ਰਿਹਾ ਹੈ, ਪਰ ਇੱਕ ਦਿਨ ਇਹ ਤੀਜਾ ਬੱਗ ਦੇਖਿਆ ਜਾਵੇਗਾ ਅਤੇ ਹੱਲ ਕੀਤਾ ਜਾਵੇਗਾ। ਫਿਰ ਦ੍ਰਿਸ਼ B ਵਿੱਚ ਗਲਤੀ ਦੁਬਾਰਾ ਆਵੇਗੀ, ਅਤੇ ਇਹ ਚੰਗਾ ਹੈ ਜੇਕਰ ਉੱਥੇ ਹੀ ਹੋਵੇ।

ਇਹ ਸਭ ਕੋਡ ਵਿੱਚ ਹਫੜਾ-ਦਫੜੀ ਜੋੜਦਾ ਹੈ ਅਤੇ ਕਿਸੇ ਦਿਨ ਤੁਹਾਡੇ ਸਿਰ 'ਤੇ ਡਿੱਗ ਜਾਵੇਗਾ - ਸਭ ਤੋਂ ਵੱਧ ਸੰਭਾਵਨਾ ਵਾਲੇ ਸਮੇਂ 'ਤੇ. ਤੁਹਾਨੂੰ ਇਹ ਸਮਝਣ ਲਈ ਸਮਾਂ ਬਿਤਾਉਣ ਲਈ ਮਜਬੂਰ ਕਰਨ ਲਈ ਆਪਣੀ ਇੱਛਾ ਸ਼ਕਤੀ ਨੂੰ ਇਕੱਠਾ ਕਰਨਾ ਪਏਗਾ ਕਿ ਸਭ ਕੁਝ ਕੰਮ ਕਿਉਂ ਕਰਦਾ ਹੈ, ਪਰ ਇਹ ਇਸਦੀ ਕੀਮਤ ਹੈ।

ਸਮਝ ਦਾ ਤੀਜਾ ਪੱਧਰ: ਇਹ ਕੰਮ ਕਿਉਂ ਕਰਦਾ ਹੈ?

ਮੇਰੀ ਤਾਜ਼ਾ ਸੂਝ ਇਸ ਪੱਧਰ ਨਾਲ ਬਿਲਕੁਲ ਸੰਬੰਧਿਤ ਹੈ, ਅਤੇ ਇਹ ਸ਼ਾਇਦ ਉਹ ਹੈ ਜਿਸ ਨੇ ਮੈਨੂੰ ਸਭ ਤੋਂ ਵੱਧ ਲਾਭ ਦਿੱਤਾ ਹੁੰਦਾ ਜੇ ਮੈਂ ਇਸ ਵਿਚਾਰ ਨੂੰ ਪਹਿਲਾਂ ਆਇਆ ਹੁੰਦਾ।

ਇਸਨੂੰ ਸਪੱਸ਼ਟ ਕਰਨ ਲਈ, ਆਓ ਇੱਕ ਉਦਾਹਰਨ ਵੇਖੀਏ: ਤੁਹਾਡੇ ਮੋਡੀਊਲ ਨੂੰ ਫੰਕਸ਼ਨ X ਦੇ ਅਨੁਕੂਲ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ। ਤੁਸੀਂ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਫੰਕਸ਼ਨ X ਤੋਂ ਜਾਣੂ ਨਹੀਂ ਹੋ, ਪਰ ਤੁਹਾਨੂੰ ਦੱਸਿਆ ਗਿਆ ਸੀ ਕਿ ਇਸਦੇ ਅਨੁਕੂਲ ਹੋਣ ਲਈ ਤੁਹਾਨੂੰ F ਫਰੇਮਵਰਕ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਮਾਡਿਊਲ ਜੋ X ਦੇ ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਹੁੰਦੇ ਹਨ ਉਸ ਨਾਲ ਬਿਲਕੁਲ ਕੰਮ ਕਰਦੇ ਹਨ।

ਤੁਹਾਡਾ ਕੋਡ ਆਪਣੇ ਜੀਵਨ ਦੇ ਪਹਿਲੇ ਦਿਨ ਤੋਂ ਹੀ F ਫਰੇਮਵਰਕ ਦੇ ਸੰਪਰਕ ਵਿੱਚ ਨਹੀਂ ਹੈ, ਇਸ ਲਈ ਇਸਨੂੰ ਲਾਗੂ ਕਰਨਾ ਇੰਨਾ ਆਸਾਨ ਨਹੀਂ ਹੋਵੇਗਾ। ਇਸ ਦੇ ਮਾਡਿਊਲ ਦੇ ਕੁਝ ਹਿੱਸਿਆਂ ਲਈ ਗੰਭੀਰ ਨਤੀਜੇ ਹੋਣਗੇ। ਹਾਲਾਂਕਿ, ਤੁਸੀਂ ਆਪਣੇ ਆਪ ਨੂੰ ਵਿਕਾਸ ਵਿੱਚ ਸੁੱਟ ਦਿੰਦੇ ਹੋ: ਤੁਸੀਂ ਕੋਡ ਲਿਖਣ, ਟੈਸਟਿੰਗ, ਪਾਇਲਟ ਸੰਸਕਰਣਾਂ ਨੂੰ ਰੋਲ ਆਊਟ ਕਰਨ, ਫੀਡਬੈਕ ਪ੍ਰਾਪਤ ਕਰਨ, ਰੀਗਰੈਸ਼ਨ ਗਲਤੀਆਂ ਨੂੰ ਠੀਕ ਕਰਨ, ਅਣਕਿਆਸੇ ਪੇਚੀਦਗੀਆਂ ਦੀ ਖੋਜ ਕਰਨ, ਮੂਲ ਰੂਪ ਵਿੱਚ ਸਹਿਮਤ ਸਮਾਂ-ਸੀਮਾਵਾਂ ਨੂੰ ਪੂਰਾ ਨਾ ਕਰਨ, ਕੁਝ ਹੋਰ ਕੋਡ ਲਿਖਣ, ਟੈਸਟਿੰਗ, ਫੀਡਬੈਕ ਸੰਚਾਰ ਪ੍ਰਾਪਤ ਕਰਨ ਵਿੱਚ ਹਫ਼ਤੇ ਬਿਤਾਉਂਦੇ ਹੋ, ਰਿਗਰੈਸ਼ਨ ਗਲਤੀਆਂ ਨੂੰ ਠੀਕ ਕਰਨਾ - ਇਹ ਸਭ F ਫਰੇਮਵਰਕ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ।

ਅਤੇ ਕਿਸੇ ਸਮੇਂ ਤੁਸੀਂ ਅਚਾਨਕ ਮਹਿਸੂਸ ਕਰਦੇ ਹੋ - ਜਾਂ ਸ਼ਾਇਦ ਕਿਸੇ ਤੋਂ ਸੁਣਦੇ ਹੋ - ਕਿ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਫਰੇਮਵਰਕ F ਤੁਹਾਨੂੰ ਵਿਸ਼ੇਸ਼ਤਾ X ਨਾਲ ਅਨੁਕੂਲਤਾ ਪ੍ਰਦਾਨ ਨਹੀਂ ਕਰੇਗਾ। ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਉਹ ਸਾਰਾ ਸਮਾਂ ਅਤੇ ਕੋਸ਼ਿਸ਼ ਪੂਰੀ ਤਰ੍ਹਾਂ ਨਾਲ ਗਲਤ ਕੀਤੀ ਗਈ ਹੋਵੇ।

ਅਜਿਹਾ ਹੀ ਕੁਝ ਇਕ ਵਾਰ ਇਕ ਪ੍ਰੋਜੈਕਟ 'ਤੇ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਹੋਇਆ, ਜਿਸ ਲਈ ਮੈਂ ਜ਼ਿੰਮੇਵਾਰ ਸੀ। ਅਜਿਹਾ ਕਿਉਂ ਹੋਇਆ? ਕਿਉਂਕਿ ਮੈਨੂੰ ਇਸ ਬਾਰੇ ਬਹੁਤ ਘੱਟ ਸਮਝ ਸੀ ਕਿ X ਕੀ ਫੰਕਸ਼ਨ ਹੈ ਅਤੇ ਇਹ ਫਰੇਮਵਰਕ F ਨਾਲ ਕਿਵੇਂ ਸੰਬੰਧਿਤ ਹੈ। ਮੈਨੂੰ ਕੀ ਕਰਨਾ ਚਾਹੀਦਾ ਸੀ? ਵਿਕਾਸ ਕਾਰਜ ਸੌਂਪਣ ਵਾਲੇ ਵਿਅਕਤੀ ਨੂੰ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਇਹ ਦੱਸਣ ਲਈ ਕਹੋ ਕਿ ਕਿਸ ਤਰ੍ਹਾਂ ਦੀ ਕਾਰਵਾਈ ਦਾ ਉਦੇਸ਼ ਲੋੜੀਂਦੇ ਨਤੀਜੇ ਵੱਲ ਲੈ ਜਾਂਦਾ ਹੈ, ਨਾ ਕਿ ਸਿਰਫ਼ ਦੂਜੇ ਮਾਡਿਊਲਾਂ ਲਈ ਕੀ ਕੀਤਾ ਗਿਆ ਸੀ ਨੂੰ ਦੁਹਰਾਉਣ ਜਾਂ ਇਸਦੇ ਲਈ ਉਹਨਾਂ ਦੇ ਸ਼ਬਦ ਨੂੰ ਲੈਣ ਦੀ ਬਜਾਏ ਕਿ ਇਹ ਉਹੀ ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ ਜੋ X ਨੂੰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

ਇਸ ਪ੍ਰੋਜੈਕਟ ਦੇ ਅਨੁਭਵ ਨੇ ਮੈਨੂੰ ਉਦੋਂ ਤੱਕ ਵਿਕਾਸ ਪ੍ਰਕਿਰਿਆ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਇਨਕਾਰ ਕਰਨਾ ਸਿਖਾਇਆ ਜਦੋਂ ਤੱਕ ਸਾਨੂੰ ਇਸ ਗੱਲ ਦੀ ਸਪੱਸ਼ਟ ਸਮਝ ਨਹੀਂ ਆਉਂਦੀ ਕਿ ਸਾਨੂੰ ਕੁਝ ਚੀਜ਼ਾਂ ਕਰਨ ਲਈ ਕਿਉਂ ਕਿਹਾ ਜਾ ਰਿਹਾ ਹੈ। ਬਿਲਕੁਲ ਇਨਕਾਰ ਕਰੋ. ਜਦੋਂ ਤੁਸੀਂ ਕੋਈ ਕੰਮ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹੋ, ਤਾਂ ਪਹਿਲਾ ਪ੍ਰਭਾਵ ਤੁਰੰਤ ਇਸ ਨੂੰ ਪੂਰਾ ਕਰਨਾ ਹੁੰਦਾ ਹੈ ਤਾਂ ਜੋ ਸਮਾਂ ਬਰਬਾਦ ਨਾ ਹੋਵੇ। ਪਰ "ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਉਦੋਂ ਤੱਕ ਫ੍ਰੀਜ਼ ਕਰੋ ਜਦੋਂ ਤੱਕ ਅਸੀਂ ਸਾਰੇ ਵੇਰਵਿਆਂ ਵਿੱਚ ਨਹੀਂ ਆਉਂਦੇ" ਨੀਤੀ ਵਿਸ਼ਾਲਤਾ ਦੇ ਆਦੇਸ਼ਾਂ ਦੁਆਰਾ ਬਰਬਾਦ ਹੋਏ ਸਮੇਂ ਨੂੰ ਘਟਾ ਸਕਦੀ ਹੈ।

ਭਾਵੇਂ ਉਹ ਤੁਹਾਡੇ 'ਤੇ ਦਬਾਅ ਪਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਨ, ਤੁਹਾਨੂੰ ਕੰਮ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਮਜਬੂਰ ਕਰਦੇ ਹਨ, ਹਾਲਾਂਕਿ ਤੁਸੀਂ ਇਸਦਾ ਤਰਕ ਨਹੀਂ ਸਮਝਦੇ ਹੋ, ਵਿਰੋਧ ਕਰੋ। ਪਹਿਲਾਂ, ਇਹ ਪਤਾ ਲਗਾਓ ਕਿ ਤੁਹਾਨੂੰ ਅਜਿਹਾ ਕੰਮ ਕਿਉਂ ਦਿੱਤਾ ਜਾ ਰਿਹਾ ਹੈ, ਅਤੇ ਫੈਸਲਾ ਕਰੋ ਕਿ ਕੀ ਇਹ ਟੀਚਾ ਪ੍ਰਾਪਤ ਕਰਨ ਦਾ ਸਹੀ ਰਸਤਾ ਹੈ। ਮੈਨੂੰ ਇਹ ਸਭ ਮੁਸ਼ਕਲ ਤਰੀਕੇ ਨਾਲ ਸਿੱਖਣਾ ਪਿਆ - ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਮੇਰੀ ਉਦਾਹਰਣ ਉਹਨਾਂ ਲਈ ਜੀਵਨ ਆਸਾਨ ਬਣਾ ਦੇਵੇਗੀ ਜੋ ਇਸਨੂੰ ਪੜ੍ਹਦੇ ਹਨ।

ਸਮਝ ਦਾ ਚੌਥਾ ਪੱਧਰ: ???

ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿੱਚ ਸਿੱਖਣ ਲਈ ਹਮੇਸ਼ਾਂ ਹੋਰ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਮੇਰਾ ਮੰਨਣਾ ਹੈ ਕਿ ਮੈਂ ਸਿਰਫ ਸਮਝ ਦੇ ਵਿਸ਼ੇ ਦੀ ਸਤ੍ਹਾ ਨੂੰ ਖੁਰਚਿਆ ਹੈ. ਕੋਡ ਨਾਲ ਕੰਮ ਕਰਨ ਦੇ ਸਾਲਾਂ ਦੌਰਾਨ ਤੁਸੀਂ ਸਮਝ ਦੇ ਹੋਰ ਕਿਹੜੇ ਪੱਧਰ ਲੱਭੇ ਹਨ? ਤੁਸੀਂ ਕਿਹੜੇ ਫੈਸਲੇ ਲਏ ਜਿਨ੍ਹਾਂ ਦਾ ਕੋਡ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਗੁਣਵੱਤਾ 'ਤੇ ਸਕਾਰਾਤਮਕ ਪ੍ਰਭਾਵ ਪਿਆ? ਕਿਹੜੇ ਫੈਸਲੇ ਗਲਤ ਨਿਕਲੇ ਅਤੇ ਤੁਹਾਨੂੰ ਇੱਕ ਕੀਮਤੀ ਸਬਕ ਸਿਖਾਇਆ? ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਆਪਣਾ ਅਨੁਭਵ ਸਾਂਝਾ ਕਰੋ।

ਸਰੋਤ: www.habr.com