ਲਾਭ:
- ਸਾਫਟਵੇਅਰ ਡਿਵੈਲਪਮੈਂਟ ਲਾਈਫਸਾਈਕਲ ਵਿੱਚ ਕਿੱਥੇ AI ਅਸਲ ਗਤੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਅਤੇ ਜਿੱਥੇ ਫੈਸਲਾ ਅਤੇ ਜ਼ਿੰਮੇਵਾਰੀ ਇੰਜੀਨੀਅਰ ਦੇ ਕੋਲ ਰਹਿੰਦੀ ਹੈ, ਇਸ ਵਿੱਚ ਫਰਕ ਕਰਨ ਦੀ ਸਮਰੱਥਾ
- ਤਿੰਨ-ਪੱਧਰੀ ਇੰਜੀਨੀਅਰਿੰਗ ਅਨੁਸ਼ਾਸਨ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਜੋ ਸੰਕਲਨ, ਟੈਸਟਿੰਗ ਅਤੇ ਸਮੀਖਿਆ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੇ ਗਏ ਹਰੇਕ ਕੋਡ ਅਤੇ ਡਿਜ਼ਾਈਨ ਦੀ ਪੁਸ਼ਟੀ ਕਰਦੀ ਹੈ।
- ਗੁਪਤ ਸਰੋਤ ਕੋਡ, ਪ੍ਰਮਾਣ ਪੱਤਰ ਅਤੇ ਗਾਹਕ ਡੇਟਾ ਨੂੰ ਸਾਂਝਾ ਕੀਤੇ ਬਿਨਾਂ AI ਦਾ ਲਾਭ ਉਠਾਉਣ ਲਈ ਸੰਦਰਭ ਨੂੰ ਸਾਫ਼ ਕਰਨ ਦੀ ਆਦਤ ਪਾਓ
ਜਦੋਂ ਤੁਸੀਂ ਕੰਪਿਊਟਰ ਇੰਜੀਨੀਅਰ ਦੇ ਦਿਨ ਨੂੰ ਦੇਖਦੇ ਹੋ, ਤਾਂ ਜ਼ਿਆਦਾਤਰ ਟੀਮਾਂ ਵਿੱਚ ਤਸਵੀਰ ਇੱਕੋ ਜਿਹੀ ਹੁੰਦੀ ਹੈ: ਕਿਸੇ ਕਾਰੋਬਾਰੀ ਬੇਨਤੀ ਨੂੰ ਸਮਝਣਾ, ਡਿਜ਼ਾਈਨ ਕਰਨਾ, ਕੋਡ ਲਿਖਣਾ, ਕਿਸੇ ਹੋਰ ਦਾ ਕੋਡ ਪੜ੍ਹਨਾ, ਡੀਬੱਗ ਕਰਨਾ (ਇਹ ਪਤਾ ਲਗਾਉਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਿ ਕੋਈ ਪ੍ਰੋਗਰਾਮ ਗਲਤ ਕਿਉਂ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਠੀਕ ਕਰਨਾ), ਟੈਸਟ ਲਿਖਣਾ, ਦਸਤਾਵੇਜ਼ ਤਿਆਰ ਕਰਨਾ, ਕੋਡ ਦੀ ਸਮੀਖਿਆ ਕਰਨਾ, ਅਤੇ ਮੀਟਿੰਗਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋਣਾ। ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿਚ, ਅਸਲ "ਇੰਜੀਨੀਅਰਿੰਗ ਨਿਰਣੇ" ਲਈ ਸਮਰਪਿਤ ਸਮਾਂ, ਯਾਨੀ ਕਿ ਕੀ ਕੋਈ ਹੱਲ ਸਹੀ, ਸੁਰੱਖਿਅਤ ਅਤੇ ਟਿਕਾਊ ਹੈ, ਦੁਹਰਾਉਣ ਵਾਲੇ ਕੰਮ ਦੇ ਅਧੀਨ ਕੁਚਲਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਆਰਟੀਫੀਸ਼ੀਅਲ ਇੰਟੈਲੀਜੈਂਸ (ਛੋਟੇ ਲਈ AI; ਸੌਫਟਵੇਅਰ ਜੋ ਟੈਕਸਟ ਅਤੇ ਕੋਡ 'ਤੇ ਇੱਕ ਵੱਡੇ ਭਾਸ਼ਾ ਮਾਡਲ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ) ਖੇਡ ਵਿੱਚ ਆਉਂਦਾ ਹੈ। AI ਤੁਹਾਡੇ ਲਈ ਫੈਸਲਾ ਨਹੀਂ ਲੈਂਦਾ; ਇਹ ਤੁਹਾਨੂੰ ਫੈਸਲੇ ਲਈ ਤਿਆਰ ਕਰਦਾ ਹੈ, ਇੱਕ ਕੋਡ ਪਿੰਜਰ ਬਣਾਉਂਦਾ ਹੈ, ਬੱਗ ਨੂੰ ਘੱਟ ਕਰਦਾ ਹੈ ਅਤੇ ਤੁਹਾਡੇ ਸਾਹਮਣੇ ਇੱਕ ਕੰਮ ਕੀਤਾ ਡਰਾਫਟ ਰੱਖਦਾ ਹੈ। ਇਸ ਮੌਡਿਊਲ ਦੌਰਾਨ ਅਸੀਂ AI ਨੂੰ "ਆਟੋਮੈਟਿਕ ਪ੍ਰੋਗਰਾਮਰ" ਵਜੋਂ ਨਹੀਂ, ਸਗੋਂ ਇੱਕ ਅਨੁਸ਼ਾਸਿਤ ਜੋੜਾ ਪ੍ਰੋਗਰਾਮਿੰਗ ਪਾਰਟਨਰ ਵਜੋਂ ਰੱਖਾਂਗੇ ਜਿਸਦਾ ਆਉਟਪੁੱਟ ਹਰ ਵਾਰ ਕੰਪਾਇਲ, ਟੈਸਟ ਅਤੇ ਸਮੀਖਿਆ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
ਇਸ ਪਹਿਲੀ ਇਕਾਈ ਵਿੱਚ, ਅਸੀਂ ਤਿੰਨ ਗੱਲਾਂ ਸਪਸ਼ਟ ਕਰਦੇ ਹਾਂ: ਸਾਫਟਵੇਅਰ ਵਿਕਾਸ ਜੀਵਨ ਚੱਕਰ ਦੇ ਕਿਹੜੇ ਪੜਾਵਾਂ 'ਤੇ (ਇੱਕ ਸੌਫਟਵੇਅਰ ਵਿਚਾਰ ਤੋਂ ਉਤਪਾਦਨ ਤੱਕ ਦੇ ਪੜਾਅ: ਵਿਸ਼ਲੇਸ਼ਣ, ਡਿਜ਼ਾਈਨ, ਕੋਡਿੰਗ, ਟੈਸਟਿੰਗ, ਤੈਨਾਤੀ, ਰੱਖ-ਰਖਾਅ) ਕੀ AI ਅਸਲ ਮੁੱਲ ਜੋੜਦਾ ਹੈ; ਕਿਹੜੇ ਫੈਸਲੇ ਸਖਤੀ ਨਾਲ ਇੰਜੀਨੀਅਰ ਦੇ ਕੋਲ ਰਹਿਣੇ ਚਾਹੀਦੇ ਹਨ; ਅਤੇ ਇਹ ਕਰਦੇ ਸਮੇਂ ਤੁਹਾਨੂੰ ਕਿਸ ਤਸਦੀਕ ਅਤੇ ਗੁਪਤਤਾ ਅਨੁਸ਼ਾਸਨ ਦੀ ਪਾਲਣਾ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ। ਇਸ ਛੱਤ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸਥਾਪਿਤ ਕੀਤੇ ਬਿਨਾਂ, ਅਗਲੀਆਂ ਇਕਾਈਆਂ 'ਤੇ ਤਕਨੀਕਾਂ ਖ਼ਤਰਨਾਕ ਬਣ ਸਕਦੀਆਂ ਹਨ; ਕਿਉਂਕਿ ਸੌਫਟਵੇਅਰ ਵਿੱਚ ਇੱਕ ਗਲਤੀ ਇੱਕੋ ਸਮੇਂ ਲੱਖਾਂ ਉਪਭੋਗਤਾਵਾਂ ਤੱਕ ਪਹੁੰਚਦੀ ਹੈ ਅਤੇ ਇੱਕ ਸੁਰੱਖਿਆ ਕਮਜ਼ੋਰੀ ਵਿੱਚ ਬਦਲ ਸਕਦੀ ਹੈ।
ਸੰਕਲਪ: ਹੇਲੁਸੀਨੇਸ਼ਨ: AI ਦੀ ਇੱਕ ਵਿਧੀ, ਲਾਇਬ੍ਰੇਰੀ, API, ਜਾਂ ਵਿਵਹਾਰ ਜੋ ਅਸਲ ਵਿੱਚ ਮੌਜੂਦ ਨਹੀਂ ਹੈ, ਦਾ ਠੋਸ ਨਿਰਮਾਣ। ਸੰਦਰਭ: ਇਨਪੁਟ ਜੋ ਤੁਸੀਂ AI ਨੂੰ ਦਿੰਦੇ ਹੋ (ਕੋਡ, ਗਲਤੀ ਸੁਨੇਹਾ, ਲੋੜ, ਰੁਕਾਵਟਾਂ)। ਤਸਦੀਕ: ਇੱਕ ਸੁਤੰਤਰ ਤਰੀਕੇ ਨਾਲ ਆਉਟਪੁੱਟ ਦੀ ਜਾਂਚ ਕਰਨਾ (ਸੰਕਲਨ, ਟੈਸਟਿੰਗ, ਦਸਤਾਵੇਜ਼)। ਇਹ ਤਿੰਨੇ ਸੰਕਲਪ ਪੂਰੇ ਮੋਡੀਊਲ ਦੀ ਰੀੜ੍ਹ ਦੀ ਹੱਡੀ ਹਨ।
ਕਿਹੜੇ ਕਾਰੋਬਾਰਾਂ ਵਿੱਚ AI ਐਕਸਲੇਟਰ ਹੈ, ਕਿਹੜੇ ਕਾਰੋਬਾਰਾਂ ਵਿੱਚ ਇਹ ਜੋਖਮ ਭਰਿਆ ਹੈ?
ਸਾੱਫਟਵੇਅਰ ਨੌਕਰੀਆਂ ਨਤੀਜਿਆਂ ਦੇ ਰੂਪ ਵਿੱਚ ਦੋ-ਪੱਖੀ ਸਪੈਕਟ੍ਰਮ 'ਤੇ ਆਉਂਦੀਆਂ ਹਨ। ਇੱਕ ਸਿਰੇ 'ਤੇ ਉਲਟਾ, ਘੱਟ ਜੋਖਮ ਵਾਲਾ ਤਿਆਰੀ ਦਾ ਕੰਮ ਹੁੰਦਾ ਹੈ; ਦੂਜੇ ਸਿਰੇ 'ਤੇ, ਵਾਪਸ ਆਉਣ ਵਾਲੇ ਮੁਸ਼ਕਲ ਕੰਮ ਹਨ ਜੋ ਉਤਪਾਦਨ ਦੇ ਵਾਤਾਵਰਣ ਵਿੱਚ ਦਾਖਲ ਹੁੰਦੇ ਹਨ ਅਤੇ ਡੇਟਾ ਦੇ ਨੁਕਸਾਨ, ਸੁਰੱਖਿਆ ਕਮਜ਼ੋਰੀਆਂ ਜਾਂ ਰੁਕਾਵਟਾਂ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦੇ ਹਨ। AI ਦਾ ਮੁੱਲ ਇਸ ਗੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਇਸ ਸਪੈਕਟ੍ਰਮ 'ਤੇ ਕਿੱਥੇ ਖੜ੍ਹੇ ਹੋ।
ਕਾਰੋਬਾਰ ਦੀ ਕਿਸਮ
AI ਯੋਗਦਾਨ
ਇੰਜੀਨੀਅਰ ਦੀ ਭੂਮਿਕਾ
ਕੋਡ ਪਿੰਜਰ / ਬਾਇਲਰਪਲੇਟ
ਦੁਹਰਾਉਣ ਵਾਲੀ ਬਣਤਰ ਦੀ ਤੇਜ਼ ਪੀੜ੍ਹੀ
ਤਰਕ ਅਤੇ ਕਿਨਾਰੇ ਸਥਿਤੀ ਨਿਯੰਤਰਣ
ਡੀਬੱਗਿੰਗ
ਕਲਪਨਾ ਅਤੇ ਸੰਭਵ ਕਾਰਨ ਸੂਚੀ
ਪ੍ਰਜਨਨ ਅਤੇ ਮੂਲ ਕਾਰਨ ਦੀ ਪੁਸ਼ਟੀ
ਲਿਖਣ ਦੇ ਟੈਸਟ
ਟੈਸਟ ਡਰਾਫਟ ਅਤੇ ਦ੍ਰਿਸ਼ ਰਚਨਾ
ਅਰਥਪੂਰਨ ਦਾਅਵਾ ਅਤੇ ਸਕੋਪ ਜਾਂਚ
ਰੀਫੈਕਟਰਿੰਗ
ਰੀਫੈਕਟਰਿੰਗ ਪ੍ਰਸਤਾਵ
ਟੈਸਟਿੰਗ ਦੁਆਰਾ ਵਿਵਹਾਰ ਨੂੰ ਕਾਇਮ ਰੱਖਣਾ
ਦਸਤਾਵੇਜ਼ੀਕਰਨ
ਪਹਿਲਾ ਡਰਾਫਟ ਅਤੇ ਬਣਤਰ
ਕੋਡ ਦੇ ਵਿਰੁੱਧ ਸ਼ੁੱਧਤਾ ਦੀ ਜਾਂਚ
ਆਰਕੀਟੈਕਚਰਲ/ਸੁਰੱਖਿਆ ਫੈਸਲਾ
ਵਿਕਲਪਾਂ ਅਤੇ ਫ਼ਾਇਦੇ ਅਤੇ ਨੁਕਸਾਨਾਂ ਦੀ ਸੂਚੀ
ਅੰਤਿਮ ਫੈਸਲਾ ਅਤੇ ਜ਼ਿੰਮੇਵਾਰੀ
ਨਿਯਮ ਸਧਾਰਨ ਹੈ: AI ਆਉਟਪੁੱਟ ਦਾ ਖਤਰਾ ਉਸ ਨੁਕਸਾਨ ਦੇ ਬਰਾਬਰ ਹੁੰਦਾ ਹੈ ਜੇਕਰ ਉਹ ਆਉਟਪੁੱਟ ਗਲਤੀ ਕਰਦੀ ਹੈ। ਇੱਕ ਵੇਰੀਏਬਲ ਨਾਮ ਦਾ ਗਲਤ ਸੁਝਾਅ ਦੇਣਾ ਨੁਕਸਾਨਦੇਹ ਹੈ; ਗਲਤ ਪ੍ਰਮਾਣਿਕਤਾ (ਇਹ ਜਾਂਚ ਕਰਨਾ ਕਿ ਉਪਭੋਗਤਾ ਅਸਲ ਵਿੱਚ ਉਹ ਹੈ ਜਿਸਦਾ ਉਹ ਦਾਅਵਾ ਕਰਦੇ ਹਨ) ਪੂਰੇ ਸਿਸਟਮ ਨੂੰ ਕਮਜ਼ੋਰ ਬਣਾਉਂਦਾ ਹੈ। ਇਸ ਲਈ ਆਉਟਪੁੱਟ ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਪੁੱਛਣ ਵਾਲਾ ਪਹਿਲਾ ਸਵਾਲ ਇਹ ਹੈ: "ਜੇ ਇਹ ਗਲਤ ਹੈ ਤਾਂ ਕੀ ਹੁੰਦਾ ਹੈ ਅਤੇ ਕੌਣ ਇਸਨੂੰ ਨੋਟਿਸ ਕਰਦਾ ਹੈ ਅਤੇ ਕਦੋਂ?"
ਸਾਵਧਾਨ: AI ਤਰਕਸ਼ੀਲ ਅਤੇ ਭਰੋਸੇਮੰਦ ਕੋਡ ਪੈਦਾ ਕਰਦਾ ਹੈ। ਪ੍ਰਵਾਹ ਸ਼ੁੱਧਤਾ ਦੀ ਕੋਈ ਗਰੰਟੀ ਨਹੀਂ ਹੈ। ਇੱਕ ਭਾਸ਼ਾ ਮਾਡਲ ਭਰੋਸੇਯੋਗ ਤੌਰ 'ਤੇ ਇੱਕ ਫੰਕਸ਼ਨ ਨਾਮ ਪੈਦਾ ਕਰ ਸਕਦਾ ਹੈ ਜੋ ਅਸਲ ਵਿੱਚ ਮੌਜੂਦ ਨਹੀਂ ਹੈ, ਇੱਕ ਗਲਤ ਪੈਰਾਮੀਟਰ ਕ੍ਰਮ, ਜਾਂ ਇੱਕ ਅਸੁਰੱਖਿਅਤ ਪੈਟਰਨ ਵੀ. ਸੌਫਟਵੇਅਰ ਵਿੱਚ, ਇਹ ਕਾਗਜ਼ 'ਤੇ ਨਹੀਂ ਰਹਿੰਦਾ; ਇਹ ਕੰਪਾਇਲ ਕਰਦਾ ਹੈ, ਚਲਾਉਂਦਾ ਹੈ, ਅਤੇ ਉਤਪਾਦਨ ਵਿੱਚ ਵਿਸਫੋਟ ਕਰਦਾ ਹੈ।
ਫੈਸਲੇ ਜੋ ਇੰਜੀਨੀਅਰ 'ਤੇ ਛੱਡ ਦਿੱਤੇ ਜਾਣੇ ਚਾਹੀਦੇ ਹਨ
ਕੁਝ ਫੈਸਲੇ ਕਦੇ ਵੀ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਵੈਚਲਿਤ ਨਹੀਂ ਹੋਣੇ ਚਾਹੀਦੇ; ਤਕਨੀਕੀ, ਕਾਨੂੰਨੀ ਅਤੇ ਨੈਤਿਕ ਖਤਰੇ ਹਨ:
- ਉਤਪਾਦਨ ਲਈ ਪ੍ਰਵਾਨਗੀ: ਉਤਪਾਦਨ ਵਿੱਚ ਇੱਕ ਕੋਡ ਨੂੰ ਜਾਰੀ ਕਰਨਾ ਅਤੇ ਇਸਦੇ ਲਈ ਜ਼ਿੰਮੇਵਾਰੀ।
- ਸੁਰੱਖਿਆ ਅਤੇ ਆਰਕੀਟੈਕਚਰ: ਮਹਿੰਗੇ ਫੈਸਲੇ ਜਿਵੇਂ ਪ੍ਰਮਾਣਿਕਤਾ, ਅਧਿਕਾਰ, ਐਨਕ੍ਰਿਪਸ਼ਨ ਅਤੇ ਡੇਟਾ ਮਾਡਲ।
- ਲਾਇਸੈਂਸ ਅਤੇ ਕਾਪੀਰਾਈਟ: ਵਪਾਰਕ ਉਤਪਾਦ ਅਤੇ ਲਾਇਸੈਂਸ ਦੀ ਪਾਲਣਾ ਵਿੱਚ ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਦੀ ਵਰਤੋਂਯੋਗਤਾ।
- ਗੁਪਤ ਡੇਟਾ ਨਾਲ ਕੰਮ ਕਰਨਾ: ਗਾਹਕ ਡੇਟਾ, ਸਰੋਤ ਕੋਡ ਦੇ ਭੇਦ ਅਤੇ ਪਛਾਣ ਜਾਣਕਾਰੀ ਨਾਲ ਲੈਣ-ਦੇਣ।
ਚੇਤਾਵਨੀ: ਭਾਵੇਂ AI ਕਹਿੰਦਾ ਹੈ ਕਿ "ਇਹ ਕੋਡ ਸੁਰੱਖਿਅਤ ਹੈ ਅਤੇ ਉਤਪਾਦਨ ਲਈ ਤਿਆਰ ਹੈ", ਸੁਰੱਖਿਆ ਜਾਂਚ, ਕੋਡ ਸਮੀਖਿਆ ਅਤੇ ਅਸਲ ਲੋਡ ਦੇ ਅਧੀਨ ਪ੍ਰਮਾਣਿਕਤਾ ਦੇ ਬਿਨਾਂ ਇਸਨੂੰ ਸਵੀਕਾਰ ਕਰਨਾ ਅਸਵੀਕਾਰਨਯੋਗ ਹੈ। ਸੁਰੱਖਿਆ-ਨਾਜ਼ੁਕ ਕਾਰਜਾਂ ਵਿੱਚ, AI ਆਉਟਪੁੱਟ ਕਦੇ ਵੀ ਸਮਰੱਥ ਇੰਜੀਨੀਅਰ ਤੋਂ ਪ੍ਰਵਾਨਗੀ ਦਾ ਬਦਲ ਨਹੀਂ ਹੁੰਦਾ; ਕੋਈ ਵੀ ਆਉਟਪੁੱਟ ਜੋ ਕਿਸੇ ਫੈਸਲੇ ਵੱਲ ਲੈ ਜਾਂਦਾ ਹੈ, ਨੂੰ ਲਾਗੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਅਧਿਕਾਰਤ ਇੰਜੀਨੀਅਰ ਦੁਆਰਾ ਸੁਤੰਤਰ ਤੌਰ 'ਤੇ ਤਸਦੀਕ ਅਤੇ ਪ੍ਰਵਾਨਗੀ ਦਿੱਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ।
ਤਸਦੀਕ ਅਨੁਸ਼ਾਸਨ: ਤਿੰਨ-ਲੇਅਰ ਕੰਟਰੋਲ
ਅੱਖਾਂ ਬੰਦ ਕਰਨ ਦੀ ਬਜਾਏ ਇੱਕ ਸੀਨੀਅਰ ਸਮੀਖਿਅਕ ਵਾਂਗ AI ਆਉਟਪੁੱਟ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਨਿਯੰਤਰਣ ਦੀਆਂ ਤਿੰਨ ਪਰਤਾਂ ਨੂੰ ਲਾਗੂ ਕਰੋ। ਇਹ ਬੁਨਿਆਦੀ ਪ੍ਰਤੀਬਿੰਬ ਹੈ ਜੋ ਅਸੀਂ ਪੂਰੇ ਮੋਡੀਊਲ ਵਿੱਚ ਦੁਹਰਾਵਾਂਗੇ।
- ਸੰਕਲਨ ਅਤੇ ਸਥਿਰ ਜਾਂਚ: ਕੀ ਕੋਡ ਅਸਲ ਵਿੱਚ ਕੰਪਾਇਲ/ਚਲਦਾ ਹੈ? ਕੀ ਇੱਥੇ ਕਿਸਮ ਦੀਆਂ ਤਰੁੱਟੀਆਂ, ਨਾ ਵਰਤੇ ਵੇਰੀਏਬਲ, ਗੈਰ-ਮੌਜੂਦ API ਹਨ? ਸਥਿਰ ਵਿਸ਼ਲੇਸ਼ਣ ਟੂਲ (ਉਹ ਟੂਲ ਜੋ ਕੋਡ ਨੂੰ ਚਲਾਏ ਬਿਨਾਂ ਜਾਂਚਦਾ ਹੈ) ਕੀ ਕਹਿੰਦਾ ਹੈ?
- ਸੁਤੰਤਰ ਪ੍ਰਜਨਨ (ਟੈਸਟਿੰਗ): ਛੋਟੇ, ਜਾਣੇ-ਪਛਾਣੇ ਇਨਪੁਟਸ ਨਾਲ ਕੋਡ ਚਲਾਓ ਅਤੇ ਦੇਖੋ ਕਿ ਕੀ ਤੁਹਾਨੂੰ ਉਮੀਦ ਕੀਤੀ ਆਉਟਪੁੱਟ ਮਿਲਦੀ ਹੈ। ਕਿਨਾਰੇ ਦੇ ਕੇਸ ਅਜ਼ਮਾਓ (ਨਲ, ਜ਼ੀਰੋ, ਨਕਾਰਾਤਮਕ, ਵਿਸ਼ਾਲ)।
- ਸਰੋਤ ਤਸਦੀਕ: ਹਰੇਕ API, ਲਾਇਬ੍ਰੇਰੀ ਸੰਸਕਰਣ, ਅਤੇ ਭਾਸ਼ਾ ਵਿਸ਼ੇਸ਼ਤਾ ਜੋ AI ਦੁਆਰਾ ਵਰਤੀ ਜਾਂਦੀ ਹੈ, ਨੂੰ ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼ਾਂ ਤੋਂ ਪ੍ਰਮਾਣਿਤ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।
ਪੁਸ਼ਟੀਕਰਨ ਪ੍ਰੋਂਪਟ (ਆਉਟਪੁੱਟ ਦੀ ਜਾਂਚ ਕਰਨਾ ਸੌਖਾ ਬਣਾਉਂਦਾ ਹੈ): "ਸਾਰੀਆਂ ਬਾਹਰੀ ਲਾਇਬ੍ਰੇਰੀਆਂ, ਵਿਧੀਆਂ ਅਤੇ ਭਾਸ਼ਾ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਸੂਚੀ ਬਣਾਓ ਜੋ ਤੁਸੀਂ ਆਪਣੇ ਕੋਡ ਵਿੱਚ ਵਰਤਦੇ ਹੋ। ਹਰੇਕ ਲਈ, ਇਹ ਦੱਸੋ ਕਿ ਇਹ ਕਿਸ ਸੰਸਕਰਣ ਵਿੱਚ ਉਪਲਬਧ ਹੈ ਅਤੇ ਇਸਨੂੰ 'ਦਸਤਾਵੇਜ਼ਾਂ ਤੋਂ ਤਸਦੀਕ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ' ਲੇਬਲ ਕਰੋ। ਕੋਈ ਵੀ API ਨਾ ਬਣਾਓ ਜਿਸ ਬਾਰੇ ਤੁਹਾਨੂੰ ਯਕੀਨ ਨਹੀਂ ਹੈ; ਜੇਕਰ ਤੁਸੀਂ ਯਕੀਨੀ ਨਹੀਂ ਹੋ, ਤਾਂ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ 'ਸੂਚੀਬੱਧ ਕੇਸਾਂ ਦੀ ਸੂਚੀ ਨਹੀਂ ਹੈ' ਦੇ ਰੂਪ ਵਿੱਚ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਲਿਖੋ।
ਆਪਣੇ ਖੁਦ ਦੇ ਕੋਡ ਪ੍ਰੋਂਪਟ ਦੀ ਆਲੋਚਨਾ ਕਰੋ: "ਤੁਹਾਡੇ ਵੱਲੋਂ ਹੁਣੇ ਲਿਖੇ ਗਏ ਕੋਡ ਨੂੰ ਗੰਭੀਰਤਾ ਨਾਲ ਦੇਖੋ, ਜਿਵੇਂ ਕਿ ਇੱਕ ਸੀਨੀਅਰ ਇੰਜੀਨੀਅਰ ਜਿਸਨੇ ਤੁਹਾਨੂੰ ਕੰਮ 'ਤੇ ਰੱਖਿਆ ਹੈ। ਇਹਨਾਂ ਤਿੰਨ ਸਿਰਲੇਖਾਂ ਦੇ ਤਹਿਤ ਠੋਸ ਆਈਟਮਾਂ ਦਿਓ: (1) ਤਰਕ/ਕਿਨਾਰੇ ਦੇ ਕੇਸ ਦੀਆਂ ਤਰੁੱਟੀਆਂ, (2) ਸੁਰੱਖਿਆ ਜੋਖਮ, (3) ਪ੍ਰਦਰਸ਼ਨ ਜਾਂ ਪੜ੍ਹਨਯੋਗਤਾ ਸਮੱਸਿਆਵਾਂ। ਹਰੇਕ ਆਈਟਮ ਲਈ, 'ਸਮੱਸਿਆ ਕਿਉਂ ਹੈ' ਅਤੇ 'ਸੁਝਾਏ ਗਏ ਕੋਈ ਸਮੱਸਿਆ ਨਹੀਂ ਹੈ', ਕਹੋ 'ਕੋਈ ਸਮੱਸਿਆ ਨਹੀਂ ਹੈ' ਲਿਖੋ। ਇਸ ਨੂੰ ਸਜਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਨਾ ਕਰੋ।"
ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ / ਮਜ਼ਬੂਤ ਪ੍ਰੋਂਪਟ
ਕਮਜ਼ੋਰ:"ਮੈਨੂੰ ਇੱਕ ਉਪਭੋਗਤਾ ਪ੍ਰਮਾਣੀਕਰਨ ਫੰਕਸ਼ਨ ਲਿਖੋ।"(ਨਤੀਜਾ: ਅਸਪਸ਼ਟ ਕਿਹੜੀ ਭਾਸ਼ਾ, ਕਿਹੜਾ ਨਿਯਮ, ਕਿਹੜਾ ਤਰੁੱਟੀ ਵਿਵਹਾਰ; ਆਮ ਕੋਡ, ਅਕਸਰ ਅਸੁਰੱਖਿਅਤ ਜਾਂ ਸੰਦਰਭ ਤੋਂ ਬਾਹਰ।)STRONG:"ਪਾਈਥਨ 3.11 ਲਈ ਇੱਕ ਈਮੇਲ ਪ੍ਰਮਾਣਿਕਤਾ ਫੰਕਸ਼ਨ ਲਿਖੋ। ਇੰਪੁੱਟ: ਸਤਰ। ਆਉਟਪੁੱਟ: ਸਹੀ ਜੇਕਰ ਵੈਧ ਨਹੀਂ, ਕੋਈ ਗਲਤ ਨਹੀਂ; False. ਪਾਲਣਾ ਦੀ ਲੋੜ ਹੈ, ਬੁਨਿਆਦੀ ਫਾਰਮੈਟ ਫੰਕਸ਼ਨ ਦੇ ਹੇਠਾਂ ਇੱਕ 5-ਨਮੂਨਾ ਟੈਸਟ ਨਾ ਵਰਤੋ: ਵੈਧ, ਖਾਲੀ, ਕੋਈ '@', ਸਿਰਫ਼ ਖਾਲੀ ਥਾਂਵਾਂ ਵਾਲੇ।
ਅੰਤਰ ਪ੍ਰਸੰਗ ਵਿੱਚ ਹੈ। ਸ਼ਕਤੀਸ਼ਾਲੀ ਪ੍ਰੋਂਪਟ; ਇਸ ਵਿੱਚ ਭਾਸ਼ਾ, ਸੰਸਕਰਣ, ਇਨਪੁਟ-ਆਉਟਪੁੱਟ ਕੰਟਰੈਕਟ, ਰੁਕਾਵਟਾਂ, ਅਤੇ ਟੈਸਟ ਦੀ ਉਮੀਦ ਸ਼ਾਮਲ ਹੈ। ਇਹ ਇਕੱਲਾ ਅਨੁਸ਼ਾਸਨ ਭੁਲੇਖੇ ਅਤੇ ਅਸੁਰੱਖਿਅਤ ਕੋਡ ਦੇ ਜੋਖਮ ਨੂੰ ਬਹੁਤ ਘਟਾਉਂਦਾ ਹੈ।
ਮਿੰਨੀ ਕੇਸ
ਕੇਸ 1 - ਵਿਵਾਦਿਤ ਢੰਗ। ਇੱਕ ਡਿਵੈਲਪਰ AI ਤੋਂ ਸੁਣਦਾ ਹੈ ਕਿ ਇੱਕ ਡੇਟ ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ date.addBusinessDays(5) ਨਾਮਕ ਇੱਕ ਤਰੀਕਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਭਰੋਸੇਮੰਦ ਤਰੀਕੇ ਨਾਲ ਸਮਝਾਇਆ ਗਿਆ ਹੈ। ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਦੇਖਦੇ ਹੋਏ, ਉਹ ਦੇਖਦਾ ਹੈ ਕਿ ਅਜਿਹਾ ਕੋਈ ਤਰੀਕਾ ਨਹੀਂ ਹੈ, ਸਹੀ ਤਰੀਕਾ ਮੈਨੂਅਲ ਲੂਪ ਹੈ। 10-ਮਿੰਟ ਦੀ ਤਸਦੀਕ ਨਾਲ ਉਤਪਾਦਨ ਵਿੱਚ ਜਾਣ ਤੋਂ ਪਹਿਲਾਂ ਭਰਮ ਨੂੰ ਕੈਪਚਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
ਕੇਸ 2 - ਕਿਨਾਰੇ ਦੀ ਸਥਿਤੀ ਦਾ ਨੁਕਸਾਨ। AI ਇੱਕ "ਔਸਤ ਦੀ ਗਣਨਾ ਕਰੋ" ਫੰਕਸ਼ਨ ਪੈਦਾ ਕਰਦਾ ਹੈ; ਇਹ ਉਦੋਂ ਕੰਮ ਕਰਦਾ ਹੈ ਜਦੋਂ ਡੇਟਾ ਦੀਆਂ 1,000 ਕਤਾਰਾਂ ਨਾਲ ਜਾਂਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਹਾਲਾਂਕਿ, ਜਦੋਂ ਸੂਚੀ ਖਾਲੀ ਹੁੰਦੀ ਹੈ, ਇਹ ਜ਼ੀਰੋ ਗਲਤੀ ਨਾਲ ਵੰਡ ਦਿੰਦੀ ਹੈ। ਕਿਉਂਕਿ ਇੰਜੀਨੀਅਰ ਨੇ ਖਾਲੀ ਇਨਪੁਟ ਟੈਸਟ ਜੋੜਿਆ ਹੈ, ਉਹ ਲਾਈਵ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਗਲਤੀ ਨੂੰ ਦੇਖਦਾ ਅਤੇ ਠੀਕ ਕਰਦਾ ਹੈ। ਇੱਕ ਸਿੰਗਲ ਐਜ ਕੰਡੀਸ਼ਨ ਟੈਸਟ ਸਵੇਰੇ 3 ਵਜੇ ਉਤਪਾਦਨ ਅਲਾਰਮ ਨੂੰ ਰੋਕਦਾ ਹੈ।
ਕੇਸ 3 - ਗੋਪਨੀਯਤਾ ਜੋਖਮ। ਇੱਕ ਮਾਹਰ ਇੱਕ ਜਨਤਕ ਟੂਲ ਵਿੱਚ ਇੱਕ ਅਸਲ ਡਾਟਾਬੇਸ ਕਨੈਕਸ਼ਨ ਸਤਰ ਅਤੇ API ਕੁੰਜੀ ਵਾਲੀ ਇੱਕ ਫਾਈਲ ਪੇਸਟ ਕਰਨ ਵਾਲਾ ਹੈ। ਸੰਸਥਾ ਦੀ ਨੀਤੀ ਨੂੰ ਯਾਦ ਕਰਦਾ ਹੈ; ਇਹ ਭੇਦ ਨੂੰ <REDACTED> ਨਾਲ ਬਦਲਦਾ ਹੈ, ਕੋਡ ਨੂੰ ਪ੍ਰਤੀਨਿਧੀ ਉਦਾਹਰਨ ਲਈ ਘਟਾਉਂਦਾ ਹੈ, ਅਤੇ ਇਸਦੀ ਮੰਗ ਕਰਦਾ ਹੈ। ਇਸ ਤਰ੍ਹਾਂ ਉਸ ਨੂੰ 5 ਮਿੰਟਾਂ ਵਿਚ ਮਦਦ ਮਿਲ ਜਾਂਦੀ ਹੈ ਪਰ ਉਸ ਦੀ ਪਛਾਣ ਦੀ ਜਾਣਕਾਰੀ ਸਾਹਮਣੇ ਨਹੀਂ ਆਉਂਦੀ।
ਗੁਪਤ ਕੋਡ ਅਤੇ ਪਛਾਣ ਜਾਣਕਾਰੀ ਨਾਲ ਕੰਮ ਕਰਨ ਦਾ ਸਿਧਾਂਤ
ਸੌਫਟਵੇਅਰ ਦਾ ਸਭ ਤੋਂ ਸੰਵੇਦਨਸ਼ੀਲ ਹਿੱਸਾ; ਸਰੋਤ ਕੋਡ ਦੇ ਭੇਦ, ਪਛਾਣ ਜਾਣਕਾਰੀ (API ਕੁੰਜੀ, ਪਾਸਵਰਡ, ਟੋਕਨ) ਅਤੇ ਗਾਹਕ/ਨਿੱਜੀ ਡਾਟਾ। ਬੁਨਿਆਦੀ ਸਿਧਾਂਤ: ਸਾਂਝਾ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਸਾਫ਼ ਕਰੋ, ਜੇ ਸੰਭਵ ਹੋਵੇ ਤਾਂ ਇੱਕ ਪ੍ਰਤੀਨਿਧੀ ਉਦਾਹਰਨ ਦੇ ਨਾਲ ਸਮੱਸਿਆ ਦਾ ਸਾਰ ਹੀ ਪੁੱਛੋ।
ਅਗਿਆਤ ਪ੍ਰੋਂਪਟ ਪੈਟਰਨ: "ਹੇਠ ਦਿੱਤੇ ਫੰਕਸ਼ਨ ਵਿੱਚ ਇੱਕ ਤਰੁੱਟੀ ਹੈ। ਮੈਂ ਅਸਲ ਵਪਾਰਕ ਤਰਕ ਅਤੇ ਲੁਕਵੇਂ ਸਥਿਰਾਂਕਾਂ ਨੂੰ ਪ੍ਰਤੀਨਿਧੀ ਮੁੱਲਾਂ (API ਕੁੰਜੀ, ਸਾਰਣੀ ਦੇ ਨਾਮ, ਫੀਲਡ ਨੇਮਜੈਨਰਿਕ) ਨਾਲ ਬਦਲ ਦਿੱਤਾ ਹੈ। ਸਮੱਸਿਆ: ਮੈਨੂੰ ਇਨਪੁਟ X ਵਿੱਚ Y ਗਲਤੀ ਮਿਲਦੀ ਹੈ। ਬੱਸ ਇਸ ਪ੍ਰਤੀਨਿਧੀ ਕੋਡ ਵਿੱਚ ਤਰਕ ਗਲਤੀ ਲੱਭੋ ਅਤੇ ਸੁਧਾਰੇ ਗਏ ਕੋਡ ਦੀ ਵਿਆਖਿਆ ਕਰੋ। [ਪ੍ਰਤੀਨਿਧੀ ਕੋਡ]"
ਸੰਕੇਤ: ਜੇਕਰ ਸ਼ੱਕ ਹੈ, ਤਾਂ ਇਹ ਟੈਸਟ ਲਓ: "ਜੇ ਮੈਂ ਇਸਨੂੰ ਫੋਰਮ ਵਿੱਚ ਜਨਤਕ ਤੌਰ 'ਤੇ ਲਿਖਿਆ ਤਾਂ ਕੀ ਮੇਰੀ ਸੰਸਥਾ ਮੁਸੀਬਤ ਵਿੱਚ ਪੈ ਜਾਵੇਗੀ?" ਭਾਵੇਂ ਜਵਾਬ ਅਸਪਸ਼ਟ ਹੈ, ਪਹਿਲਾਂ ਇਸਨੂੰ ਸਾਫ਼ ਕਰੋ। ਰੀਸੈੱਟ ਕਰਨਾ ਹਮੇਸ਼ਾ ਬਾਅਦ ਵਿੱਚ ਲੀਕ ਦਾ ਪਿੱਛਾ ਕਰਨ ਨਾਲੋਂ ਸਸਤਾ ਹੁੰਦਾ ਹੈ।
ਆਮ ਗਲਤੀਆਂ
- ਕੰਪਾਇਲ/ਟੈਸਟਿੰਗ ਤੋਂ ਬਿਨਾਂ ਆਉਟਪੁੱਟ ਦੀ ਵਰਤੋਂ ਕਰਨਾ। "ਏਆਈ ਨੇ ਲਿਖਿਆ" ਇੱਕ ਜਾਇਜ਼ ਨਹੀਂ ਹੈ; ਕੋਡ ਦੇ ਹਰੇਕ ਟੁਕੜੇ ਨੂੰ ਚਲਾ ਕੇ ਪ੍ਰਮਾਣਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
- ਬਿਨਾਂ ਪ੍ਰਸੰਗ ਦੇ ਬੇਨਤੀਆਂ ਕਰਨਾ। ਜੇਕਰ ਭਾਸ਼ਾ, ਸੰਸਕਰਣ, ਇਨਪੁਟ-ਆਉਟਪੁੱਟ ਅਤੇ ਰੁਕਾਵਟਾਂ ਨਹੀਂ ਦਿੱਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਤਾਂ ਕੋਡ ਆਮ ਅਤੇ ਅਕਸਰ ਅਸੁਰੱਖਿਅਤ ਬਣ ਜਾਂਦਾ ਹੈ।
- ਬਿਨਾਂ ਸੋਚੇ ਸਮਝੇ ਗੁਪਤ ਜਾਣਕਾਰੀ ਸਾਂਝੀ ਕਰਨੀ। API ਕੁੰਜੀ, ਪਾਸਵਰਡ ਅਤੇ ਗਾਹਕ ਡੇਟਾ ਨੂੰ ਸਾਫ਼ ਕੀਤੇ ਬਿਨਾਂ ਜਾਰੀ ਨਹੀਂ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।
- ਸਟੀਕਤਾ ਦੇ ਨਾਲ ਸਟੀਕ ਭਾਸ਼ਾ ਨੂੰ ਉਲਝਾਉਣਾ। AI ਜਿੰਨਾ ਜ਼ਿਆਦਾ ਆਤਮ-ਵਿਸ਼ਵਾਸ ਨਾਲ ਬੋਲਦਾ ਹੈ, ਤੁਹਾਨੂੰ ਓਨਾ ਹੀ ਸਾਵਧਾਨ ਰਹਿਣਾ ਚਾਹੀਦਾ ਹੈ; ਭਰੋਸੇਮੰਦ ਟੋਨ ਸਬੂਤ ਨਹੀਂ ਹੈ.
- AI ਨੂੰ ਫੈਸਲਾ ਸੌਂਪਣਾ। ਉਤਪਾਦਨ, ਸੁਰੱਖਿਆ ਅਤੇ ਆਰਕੀਟੈਕਚਰ ਵਿੱਚ ਪਾਉਣ ਦਾ ਫੈਸਲਾ ਇੰਜੀਨੀਅਰ ਕੋਲ ਰਹਿੰਦਾ ਹੈ; AI ਸਿਰਫ ਸਮੱਗਰੀ ਪੈਦਾ ਕਰਦਾ ਹੈ।
ਸੰਖੇਪ ਵਿੱਚ
AI ਸਾਫਟਵੇਅਰ ਕੰਮ ਦੇ ਦੁਹਰਾਉਣ ਵਾਲੇ ਅਤੇ ਸਮਾਂ ਬਰਬਾਦ ਕਰਨ ਵਾਲੇ ਹਿੱਸਿਆਂ ਨੂੰ ਤੇਜ਼ ਕਰਦਾ ਹੈ: ਪਿੰਜਰ ਕੋਡ, ਟੈਸਟ ਡਰਾਫਟਿੰਗ, ਬੱਗ ਸੰਕੁਚਿਤ, ਦਸਤਾਵੇਜ਼। ਹਾਲਾਂਕਿ, ਫੈਸਲਾ ਅਤੇ ਜ਼ਿੰਮੇਵਾਰੀ ਇੰਜੀਨੀਅਰ ਦੀ ਰਹਿੰਦੀ ਹੈ। ਹਰੇਕ ਆਉਟਪੁੱਟ ਨੂੰ ਨਿਯੰਤਰਣ ਦੀਆਂ ਤਿੰਨ ਪਰਤਾਂ ਨੂੰ ਪਾਸ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ (ਕੰਪਾਈਲ/ਸਟੈਟਿਕ, ਟੈਸਟਿੰਗ, ਸਰੋਤ)। ਸੰਦਰਭ ਦੇ ਨਾਲ ਪ੍ਰੋਂਪਟ ਲਿਖਣਾ ਅਤੇ ਲੁਕਵੀਂ ਜਾਣਕਾਰੀ ਨੂੰ ਸਾਫ਼ ਕਰਨਾ ਦੋ ਮੁੱਖ ਆਦਤਾਂ ਹਨ ਜੋ ਅਸੀਂ ਇਸ ਮੋਡੀਊਲ ਦੀ ਹਰੇਕ ਇਕਾਈ ਵਿੱਚ ਦੁਹਰਾਵਾਂਗੇ। ਜਦੋਂ ਤੁਸੀਂ ਅਨੁਸ਼ਾਸਨ ਨਾਲ ਏਆਈ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਗਤੀ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹੋ; ਜਦੋਂ ਤੁਸੀਂ ਇਸਨੂੰ ਅਨੁਸ਼ਾਸਨ ਦੇ ਬਿਨਾਂ ਵਰਤਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਉਤਪਾਦਨ ਵਿੱਚ ਗਲਤੀਆਂ ਅਤੇ ਕਮਜ਼ੋਰੀਆਂ ਲੈ ਜਾਂਦੇ ਹੋ।
ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਕੰਮ
ਆਪਣੇ ਖੁਦ ਦੇ ਕੰਮ ਜਾਂ ਕਿਸੇ ਕਾਲਪਨਿਕ ਪ੍ਰੋਜੈਕਟ ਤੋਂ ਇੱਕ ਛੋਟਾ ਕੋਡਿੰਗ ਕਾਰਜ ਚੁਣੋ (ਉਦਾਹਰਨ ਲਈ ਇੱਕ ਪ੍ਰਮਾਣਿਕਤਾ ਫੰਕਸ਼ਨ)। ਪਹਿਲਾਂ ਇੱਕ ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ ਲਿਖੋ ਅਤੇ ਆਉਟਪੁੱਟ ਪ੍ਰਾਪਤ ਕਰੋ। ਫਿਰ ਇਸ ਯੂਨਿਟ ਤੋਂ ਸ਼ਕਤੀਸ਼ਾਲੀ ਪ੍ਰੋਂਪਟ ਪੈਟਰਨ ਲਾਗੂ ਕਰੋ: ਭਾਸ਼ਾ/ਵਰਜਨ, ਇਨਪੁਟ-ਆਉਟਪੁੱਟ ਇਕਰਾਰਨਾਮਾ, ਰੁਕਾਵਟਾਂ, ਅਤੇ ਟੈਸਟ ਉਮੀਦ ਸ਼ਾਮਲ ਕਰੋ। ਦੋ ਪ੍ਰਿੰਟਆਉਟਸ ਨੂੰ ਨਾਲ-ਨਾਲ ਰੱਖੋ ਅਤੇ ਅੰਤਰ ਲਿਖੋ। ਫਿਰ ਮਜਬੂਤ ਆਉਟਪੁੱਟ ਨੂੰ ਕੰਪਾਇਲ ਕਰੋ ਅਤੇ ਇਸਨੂੰ ਘੱਟੋ-ਘੱਟ ਤਿੰਨ ਕਿਨਾਰਿਆਂ ਵਾਲੇ ਕੇਸਾਂ (ਨਲ, ਜ਼ੀਰੋ/ਨੈਗੇਟਿਵ, ਅਚਾਨਕ ਫਾਰਮੈਟ) ਨਾਲ ਟੈਸਟ ਕਰੋ ਅਤੇ ਨੋਟ ਕਰੋ ਕਿ ਤੁਸੀਂ ਕਿਸ ਟੈਸਟ ਵਿੱਚ ਕੀ ਲੱਭਦੇ ਹੋ।
ਚੈੱਕਲਿਸਟ
- [ ] ਮੈਂ ਪ੍ਰੋਂਪਟ ਵਿੱਚ ਭਾਸ਼ਾ, ਸੰਸਕਰਣ ਅਤੇ ਇਨਪੁਟ-ਆਉਟਪੁੱਟ ਇਕਰਾਰਨਾਮਾ ਸ਼ਾਮਲ ਕੀਤਾ ਹੈ।
- [ ] ਮੈਂ ਲਿਖਿਆ "ਇਸ ਨੂੰ ਨਾ ਬਣਾਓ, ਮੈਨੂੰ ਦੱਸੋ ਜੇ ਤੁਹਾਨੂੰ ਯਕੀਨ ਨਹੀਂ ਹੈ" ਅਤੇ ਦਾਇਰੇ ਦੀ ਰੁਕਾਵਟ।
- [ ] ਮੈਂ ਕੋਡ ਨੂੰ ਕੰਪਾਇਲ/ਰਨ ਕੀਤਾ, ਸਥਿਰ ਚੇਤਾਵਨੀਆਂ ਲਈ ਜਾਂਚ ਕੀਤੀ।
- [ ] ਮੈਂ ਘੱਟੋ-ਘੱਟ ਤਿੰਨ ਕਿਨਾਰਿਆਂ ਦੇ ਕੇਸਾਂ ਨਾਲ ਟੈਸਟ ਕੀਤਾ।
- [ ] ਮੈਂ ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼ਾਂ ਤੋਂ ਵਰਤੇ API ਦੀ ਪੁਸ਼ਟੀ ਕੀਤੀ ਹੈ।
- [ ] ਮੈਂ ਕਿਸੇ ਵੀ ਗੁਪਤ ਕੋਡ/ਪ੍ਰਮਾਣ ਪੱਤਰ ਜਾਂ ਵਰਤੇ ਹੋਏ ਐਂਟਰਪ੍ਰਾਈਜ਼ ਟੂਲ ਨੂੰ ਕਲੀਅਰ ਕੀਤਾ ਹੈ।
- [ ] ਮੈਂ ਪੁਸ਼ਟੀ ਕੀਤੀ ਕਿ ਉਤਪਾਦਨ ਅਤੇ ਸੁਰੱਖਿਆ ਵਿੱਚ ਪਾਉਣ ਦਾ ਫੈਸਲਾ ਮਨੁੱਖ ਦੇ ਕੋਲ ਰਹਿੰਦਾ ਹੈ।