AI ਨਾਲ ਕੋਡਿੰਗ ਅਤੇ ਪੇਅਰ ਪ੍ਰੋਗਰਾਮਿੰਗ

ਲਾਭ:

• ਸਪਸ਼ਟ ਇਨਪੁਟ-ਆਉਟਪੁੱਟ ਅਤੇ ਰੁਕਾਵਟ ਪਰਿਭਾਸ਼ਾਵਾਂ ਦੇ ਨਾਲ AI ਵਿੱਚ ਫੰਕਸ਼ਨ, ਕਲਾਸਾਂ ਅਤੇ ਮੋਡੀਊਲ ਲਿਖਣ ਦੀ ਸਮਰੱਥਾ
• AI ਨੂੰ ਇੱਕ ਜੋੜਾ ਪ੍ਰੋਗਰਾਮਿੰਗ ਪਾਰਟਨਰ ਵਜੋਂ ਵਰਤਣ ਦੀ ਸਮਰੱਥਾ ਅਤੇ ਕਦਮ-ਦਰ-ਕਦਮ, ਛੋਟੇ, ਪ੍ਰਮਾਣਿਤ ਹਿੱਸਿਆਂ ਵਿੱਚ ਤਰੱਕੀ
• ਏਆਈ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਨੂੰ ਕੰਪਾਇਲ ਕਰਕੇ ਅਤੇ ਇਸ ਨੂੰ ਛੋਟੀਆਂ ਉਦਾਹਰਣਾਂ ਨਾਲ ਚਲਾ ਕੇ ਤਰਕ ਅਤੇ ਕਿਨਾਰੇ ਦੇ ਕੇਸ ਦੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਫੜਨ ਦੀ ਸਮਰੱਥਾ

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

ਇਸ ਯੂਨਿਟ ਵਿੱਚ ਤੁਸੀਂ ਸਿੱਖੋਗੇ ਕਿ ਸਪਸ਼ਟ ਇਨਪੁਟ-ਆਉਟਪੁੱਟ ਇਕਰਾਰਨਾਮੇ ਨਾਲ ਫੰਕਸ਼ਨਾਂ, ਕਲਾਸਾਂ ਅਤੇ ਮੋਡਿਊਲਾਂ ਨੂੰ ਕਿਵੇਂ ਛਾਪਣਾ ਹੈ; ਕਦਮ-ਦਰ-ਕਦਮ ਏਆਈ ਦੀ ਅਗਵਾਈ ਕਿਵੇਂ ਕਰੀਏ; ਅਤੇ ਅਸੀਂ ਦੇਖਾਂਗੇ ਕਿ ਛੋਟੇ ਉਦਾਹਰਣਾਂ ਦੇ ਨਾਲ ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਨੂੰ ਚਲਾ ਕੇ ਤਰਕ ਅਤੇ ਕਿਨਾਰੇ ਦੇ ਕੇਸ ਦੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਕਿਵੇਂ ਫੜਨਾ ਹੈ। ਟੀਚਾ ਗਤੀ ਨਹੀਂ ਹੈ, ਪਰ ਪ੍ਰਮਾਣਿਤ ਗਤੀ ਹੈ.

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

ਨੈੱਟ ਕੰਟਰੈਕਟ ਦੇ ਨਾਲ ਪ੍ਰਿੰਟਿੰਗ ਕੋਡ

ਗੁਣਵੱਤਾ ਕੋਡ ਦਾ ਆਧਾਰ ਕੰਮ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ "ਤੁਸੀਂ ਕੀ ਚਾਹੁੰਦੇ ਹੋ" ਨੂੰ ਬਿਲਕੁਲ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਹੈ। AI ਨੂੰ ਇੱਕ ਫੰਕਸ਼ਨ ਲਿਖਣ ਵੇਲੇ, ਇਸਨੂੰ ਪੰਜ ਚੀਜ਼ਾਂ ਦਿਓ: ਭਾਸ਼ਾ ਅਤੇ ਸੰਸਕਰਣ, ਇਨਪੁਟ ਕਿਸਮ ਅਤੇ ਅਰਥ, ਆਉਟਪੁੱਟ, ਗਲਤੀ ਦੀਆਂ ਸਥਿਤੀਆਂ, ਅਤੇ ਰੁਕਾਵਟਾਂ (ਕਾਰਗੁਜ਼ਾਰੀ, ਬਾਹਰੀ ਲਾਇਬ੍ਰੇਰੀ ਪਾਬੰਦੀ, ਸ਼ੈਲੀ)। ਇਹ AI ਨੂੰ ਅਨੁਮਾਨ ਲਗਾਉਣ ਤੋਂ ਰੋਕਦਾ ਹੈ।

1. ਇਕਰਾਰਨਾਮਾ ਲਿਖੋ. ਇਨਪੁਟ, ਆਉਟਪੁੱਟ, ਗਲਤੀ, ਰੁਕਾਵਟ।
2. ਇੱਕ ਛੋਟੀ ਯੂਨਿਟ ਲਈ ਪੁੱਛੋ. ਇੱਕ ਸਿੰਗਲ ਜ਼ਿੰਮੇਵਾਰੀ ਦੇ ਨਾਲ ਇੱਕ ਫੰਕਸ਼ਨ; ਇਹ ਕੋਈ ਬਹੁਤ ਵੱਡਾ ਮੋਡੀਊਲ ਨਹੀਂ ਹੈ।
3. ਇੱਕ ਟੈਸਟ ਬਲਾਕ ਦੀ ਬੇਨਤੀ ਕਰੋ। ਕੋਡ ਦੇ ਅੱਗੇ ਕੁਝ ਨਮੂਨਾ ਦੌੜਾਂ/ਟੈਸਟਾਂ ਸ਼ਾਮਲ ਕਰੋ।
4. ਕੰਪਾਇਲ ਅਤੇ ਚਲਾਓ. ਇਸ ਨੂੰ ਕਿਨਾਰੇ ਦੇ ਕੇਸਾਂ ਨਾਲ ਅਜ਼ਮਾਓ, ਅੱਖਾਂ ਦੁਆਰਾ ਆਉਟਪੁੱਟ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ।
5. ਅਗਲੇ ਪੜਾਅ 'ਤੇ ਜਾਓ। ਇੱਕ ਵਾਰ ਇੱਕ ਟੁਕੜੇ ਦੀ ਪੁਸ਼ਟੀ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਇਸ 'ਤੇ ਨਿਰਮਾਣ ਕਰੋ.

ਕੰਟਰੈਕਟਡ ਫੰਕਸ਼ਨ ਪ੍ਰੋਂਪਟ: "TypeScript 5 ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਲਿਖੋ। ਉਦੇਸ਼: ਇੱਕ ਸ਼ਾਪਿੰਗ ਕਾਰਟ ਵਿੱਚ ਆਈਟਮਾਂ ਦੀ ਕੁੱਲ ਮਾਤਰਾ ਦੀ ਗਣਨਾ ਕਰੋ। ਇਨਪੁਟ: { ਕੀਮਤ: ਸੰਖਿਆ, ਮਾਤਰਾ: ਸੰਖਿਆ [] ਐਰੇ। ਆਉਟਪੁੱਟ: ਸੰਖਿਆ (ਕੁੱਲ) ਨਿਯਮ: ਥ੍ਰੋ ਐਰਰ ਜੇਕਰ ਮਾਤਰਾ ਜਾਂ ਕੀਮਤ ਨਕਾਰਾਤਮਕ ਹੈ; ਖਾਲੀ ਸਥਾਨਾਂ ਲਈ ਗੋਲ ਰੇ 0 ਨੂੰ ਵਾਪਸ ਕਰੋ। ਬਾਹਰੀ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਨਾ ਕਰੋ ਫੰਕਸ਼ਨ ਦੇ ਹੇਠਾਂ 5 ਟੈਸਟ ਕੇਸ ਸ਼ਾਮਲ ਕਰੋ (ਆਮ, ਖਾਲੀ, ਨਕਾਰਾਤਮਕ ਮਾਤਰਾ, ਦਸ਼ਮਲਵ ਕੀਮਤ, ਸਿੰਗਲ ਆਈਟਮ)।

ਇੱਕ ਜੋੜੇ ਦੇ ਰੂਪ ਵਿੱਚ AI ਦਾ ਮਾਰਗਦਰਸ਼ਨ

ਜੋੜਾ ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿੱਚ ਚੰਗੀ ਤਰੱਕੀ ਇੱਕ ਵੱਡੀ ਬੇਨਤੀ ਦੀ ਬਜਾਏ ਇੱਕ ਸੰਵਾਦ ਹੈ। ਪਹਿਲਾਂ, ਪਿੰਜਰ ਦੀ ਬੇਨਤੀ ਕਰੋ ਅਤੇ ਇਸਨੂੰ ਚਲਾਓ; ਫਿਰ ਕਿਨਾਰੇ ਦੀ ਸਥਿਤੀ ਜੋੜੋ; ਫਿਰ ਇੱਕ ਬੱਗ ਫਿਕਸ ਕਰੋ। ਇਹ ਪਹੁੰਚ ਕੋਡ ਨੂੰ ਸਮਝਣ ਯੋਗ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ ਹਰ ਕਦਮ 'ਤੇ ਨਿਯੰਤਰਣ ਵਿੱਚ ਰੱਖਦਾ ਹੈ।

ਇਨਕਰੀਮੈਂਟਲ ਪ੍ਰਗਤੀ ਪ੍ਰੋਂਪਟ: "ਅਸੀਂ ਇੱਕ ਰੀਡਰ ਲਿਖਾਂਗੇ ਜੋ ਇੱਕ CSV ਫਾਈਲ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ ਅਤੇ ਲਾਈਨਾਂ ਨੂੰ ਇੱਕ ਵਸਤੂ ਵਿੱਚ ਬਦਲਦਾ ਹੈ। ਚਲੋ STEP BY STEP, ਮੇਰੇ ਹਰ ਕਦਮ ਦੀ ਪੁਸ਼ਟੀ ਕੀਤੇ ਬਿਨਾਂ ਅਗਲੇ ਪੜਾਅ 'ਤੇ ਚੱਲਦੇ ਹਾਂ। ਕਦਮ 1: ਸਿਰਫ਼ ਉਹ ਪਿੰਜਰ ਲਿਖੋ ਜੋ ਫਾਈਲ ਨੂੰ ਲਾਈਨਾਂ ਵਿੱਚ ਵੰਡਦਾ ਹੈ ਅਤੇ ਸਿਰਲੇਖ ਲਾਈਨ ਨੂੰ ਵੱਖ ਕਰਦਾ ਹੈ। ਇਸ ਨੂੰ ਹਾਲੇ ਵੀ ਹੱਥਾਂ ਦੀ ਵਿਆਖਿਆ ਨਾ ਕਰੋ, ਜਾਂ ਛੋਟੇ ਰੂਪਾਂ ਦੀ ਵਿਆਖਿਆ ਨਾ ਕਰੋ।"

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

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

ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ / ਮਜ਼ਬੂਤ ​​ਪ੍ਰੋਂਪਟ

ਕਮਜ਼ੋਰ: "ਇੱਕ ਛਾਂਟੀ ਫੰਕਸ਼ਨ ਲਿਖੋ।" (ਨਤੀਜਾ: ਕਿਹੜੀ ਭਾਸ਼ਾ, ਕੀ ਛਾਂਟਿਆ ਜਾ ਰਿਹਾ ਹੈ, ਕੀ ਇਹ ਸਥਿਰ ਹੈ, ਪ੍ਰਦਰਸ਼ਨ ਦੀ ਰੁਕਾਵਟ ਕੀ ਹੈ, ਕੋਡ ਜੋ ਅਸਪਸ਼ਟ ਹੈ ਅਤੇ ਸ਼ਾਇਦ ਲੋੜਾਂ ਨੂੰ ਪੂਰਾ ਨਹੀਂ ਕਰਦਾ ਹੈ।) STRONG:"ਜਾਵਾ 17 ਲਈ, ਇੱਕ ਅਜਿਹਾ ਤਰੀਕਾ ਲਿਖੋ ਜੋ ਇੱਕ ਸੂਚੀ<Employee> ਵਸਤੂ ਨੂੰ ਪਹਿਲਾਂ ਵਿਭਾਗ ਦੁਆਰਾ ਛਾਂਟਦਾ ਹੈ (ਅੱਖਰ ਅਨੁਸਾਰ (ਅਸਲ ਨੂੰ NPLACE) ਦੇ ਕੇ, ਫਿਰ REDOC ਕਰਕੇ)। ਸੂਚੀ ਵਿੱਚ, null ਵਿਭਾਗ ਨੂੰ 4 ਨਮੂਨਿਆਂ ਦੇ ਨਾਲ ਇੱਕ ਮੁੱਖ ਟੈਸਟ ਬਲਾਕ ਨੂੰ ਸਪਸ਼ਟ ਕਰੋ।

ਸ਼ਕਤੀਸ਼ਾਲੀ ਪ੍ਰੋਂਪਟ; ਕ੍ਰਮਬੱਧ ਮਾਪਦੰਡ (ਦੋ-ਪੱਧਰ), ਸਾਈਡ ਇਫੈਕਟ ਨਿਯਮ (ਅਸਲ ਦੀ ਥਾਂ), ਖਾਲੀ ਵਿਵਹਾਰ, ਅਤੇ ਟੈਸਟ ਦੀ ਉਮੀਦ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ। ਇਹਨਾਂ ਵੇਰਵਿਆਂ ਤੋਂ ਬਿਨਾਂ, AI ਇੱਕ ਪ੍ਰਸ਼ੰਸਾਯੋਗ ਪਰ ਗਲਤ ਹੱਲ ਪੈਦਾ ਕਰਦਾ ਹੈ; ਉਦਾਹਰਨ ਲਈ ਇਹ ਮੂਲ ਸੂਚੀ ਨੂੰ ਵਿਗਾੜ ਸਕਦਾ ਹੈ ਅਤੇ ਇਸ ਨਾਲ ਕਿਤੇ ਹੋਰ ਇੱਕ ਚੁੱਪ ਗਲਤੀ ਹੋ ਸਕਦੀ ਹੈ।

ਕਿਨਾਰੇ ਦੇ ਕੇਸਾਂ ਅਤੇ ਛੋਟੇ ਨਮੂਨਿਆਂ ਨਾਲ ਪ੍ਰਮਾਣਿਕਤਾ

ਕੋਡ ਜੋ ਖੁਸ਼ਹਾਲ ਦ੍ਰਿਸ਼ ਵਿੱਚ ਕੰਮ ਕਰਦਾ ਹੈ ਉਹ ਸਹੀ ਕੋਡ ਨਹੀਂ ਹੈ। ਪੈਦਾ ਕੀਤੇ ਹਰੇਕ ਫੰਕਸ਼ਨ ਨੂੰ ਸੁਚੇਤ ਤੌਰ 'ਤੇ ਮਜਬੂਰ ਕਰੋ:

ਕਿਨਾਰੇ ਦੇ ਕੇਸ ਦੀ ਕਿਸਮ

ਨਮੂਨਾ ਇੰਪੁੱਟ

ਉਮੀਦ ਕੀਤੀ ਵਿਵਹਾਰ

ਖਾਲੀ ਇੰਪੁੱਟ

ਖਾਲੀ ਐਰੇ/ਸਟ੍ਰਿੰਗ

ਕੋਈ ਗਲਤੀ ਨਹੀਂ, ਤਰਕਪੂਰਨ ਖਾਲੀ ਨਤੀਜਾ

ਜ਼ੀਰੋ/ਨੈਗੇਟਿਵ

0, -1

ਪਰਿਭਾਸ਼ਿਤ ਅਤੇ ਸਹੀ ਵਿਵਹਾਰ

ਮਹਾਨ ਮੁੱਲ

ਲੱਖਾਂ ਰਿਕਾਰਡ

ਓਵਰਫਲੋ/ਪ੍ਰਦਰਸ਼ਨ ਨਿਯੰਤਰਣ

null/ਅਪਰਿਭਾਸ਼ਿਤ

ਗੁੰਮ ਜਗ੍ਹਾ

ਨਿਯੰਤਰਿਤ ਗਲਤੀ ਜਾਂ ਡਿਫੌਲਟ

ਡੁਪਲੀਕੇਟ/ਅਸਾਧਾਰਨ

ਦੁਹਰਾਉਣ ਵਾਲਾ, ਉਲਟਾ ਕ੍ਰਮ

ਸਹੀ ਨਤੀਜਾ

ਮਿੰਨੀ ਕੇਸ

ਕੇਸ 1 - ਚੁੱਪ ਰਾਊਂਡਿੰਗ ਗਲਤੀ। AI ਇੱਕ ਫੰਕਸ਼ਨ ਲਿਖਦਾ ਹੈ ਜੋ ਦਸ਼ਮਲਵ (ਫਲੋਟ) ਕਿਸਮਾਂ ਨਾਲ ਪੈਸਾ ਇਕੱਠਾ ਕਰਦਾ ਹੈ; 0.1 + 0.2 0.3000000000000004 ਦਿੰਦਾ ਹੈ। ਗਲਤੀ ਉਦੋਂ ਹੱਲ ਹੋ ਜਾਂਦੀ ਹੈ ਜਦੋਂ ਇੰਜੀਨੀਅਰ ਨਿਯਮ ਜੋੜਦਾ ਹੈ "2 ਅੰਕਾਂ ਤੱਕ ਗੋਲ ਕਰੋ ਅਤੇ ਪੂਰੇ ਪੈਸੇ ਦੀ ਵਰਤੋਂ ਕਰੋ"। ਇੱਕ 3-ਲਾਈਨ ਨਿਯਮ ਮਹੀਨਾਵਾਰ ਮੇਲ-ਮਿਲਾਪ ਵਿੱਚ ਹਜ਼ਾਰਾਂ ਪੈੱਨੀਆਂ ਦੇ ਅੰਤਰ ਨੂੰ ਰੋਕਦਾ ਹੈ।

ਕੇਸ 2 - ਸਾਈਡ ਇਫੈਕਟ ਟਰੈਪ। AI ਇੱਕ ਢੰਗ ਲਿਖਦਾ ਹੈ ਜੋ ਇੱਕ ਸੂਚੀ ਨੂੰ "ਕ੍ਰਮਬੱਧ" ਕਰਦਾ ਹੈ, ਪਰ ਅਸਲ ਸੂਚੀ ਨੂੰ ਥਾਂ 'ਤੇ ਸੋਧਦਾ ਹੈ। ਅਚਾਨਕ ਵਿਵਹਾਰ ਵਾਪਰਦਾ ਹੈ ਕਿਉਂਕਿ ਇੱਕ ਹੋਰ ਮੋਡੀਊਲ ਉਸੇ ਸੂਚੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਜੇਕਰ "ਮੂਲ ਬਦਲੋ" ਪਾਬੰਦੀ ਪ੍ਰੋਂਪਟ ਵਿੱਚ ਸੀ, ਤਾਂ ਗਲਤੀ ਕਦੇ ਨਹੀਂ ਵਾਪਰੇਗੀ; ਕੋਡ ਸਮੀਖਿਆ ਵਿੱਚ ਫਸ ਜਾਂਦਾ ਹੈ ਅਤੇ 2 ਘੰਟਿਆਂ ਦੀ ਡੀਬਗਿੰਗ ਨੂੰ ਰੋਕਦਾ ਹੈ।

ਕੇਸ 3 - ਕਦਮ ਦਰ ਕਦਮ ਕਮਾਈਆਂ। ਇੱਕ ਡਿਵੈਲਪਰ ਇੱਕ ਵਾਰ ਵਿੱਚ ਇੱਕ 150-ਲਾਈਨ ਆਯਾਤ ਮੋਡੀਊਲ ਛਾਪਦਾ ਹੈ; ਜਦੋਂ ਉਸਨੂੰ ਕੋਈ ਗਲਤੀ ਮਿਲਦੀ ਹੈ, ਤਾਂ ਉਹ ਇਹ ਨਹੀਂ ਲੱਭ ਸਕਦਾ ਕਿ ਇਹ ਕਿੱਥੋਂ ਆਈ ਹੈ। ਇੱਕ ਹੋਰ ਡਿਵੈਲਪਰ ਉਸੇ ਕੰਮ ਨੂੰ 5 ਛੋਟੇ ਕਦਮਾਂ ਵਿੱਚ ਵੰਡਦਾ ਹੈ, 2 ਮਿੰਟਾਂ ਵਿੱਚ ਹਰੇਕ ਕਦਮ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ ਅਤੇ ਤੀਜੇ ਪੜਾਅ ਵਿੱਚ ਤੁਰੰਤ ਗਲਤੀ ਨੂੰ ਫੜ ਲੈਂਦਾ ਹੈ।

ਆਮ ਗਲਤੀਆਂ

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

ਸੰਖੇਪ ਵਿੱਚ

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

ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਕੰਮ

ਇੱਕ ਛੋਟਾ ਪਰ ਅਸਲ ਫੰਕਸ਼ਨ ਚੁਣੋ (ਜਿਵੇਂ ਕਿ ਕੁੱਲ ਟੋਕਰੀ, ਮਿਤੀ ਅੰਤਰ, ਟੈਕਸਟ ਪਾਰਸਿੰਗ)। ਕੰਟਰੈਕਟਡ ਫੰਕਸ਼ਨ ਪ੍ਰੋਂਪਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਿੰਟ ਕਰੋ; ਇਸਦੇ ਅੱਗੇ ਘੱਟੋ-ਘੱਟ 5 ਟੈਸਟ ਦ੍ਰਿਸ਼ ਸ਼ਾਮਲ ਕਰੋ। ਕੋਡ ਚਲਾਓ ਅਤੇ ਟੇਬਲ ਨੂੰ ਗਾਈਡ ਦੇ ਤੌਰ 'ਤੇ ਵਰਤਦੇ ਹੋਏ, 5 ਕਿਨਾਰੇ ਦੇ ਕੇਸਾਂ ਨੂੰ ਸੁਚੇਤ ਤੌਰ 'ਤੇ ਅਜ਼ਮਾਓ। ਘੱਟੋ-ਘੱਟ ਇੱਕ ਕਿਨਾਰੇ ਵਾਲੇ ਕੇਸ ਵਿੱਚ ਇੱਕ ਬੱਗ ਲੱਭੋ (ਜੇ ਨਹੀਂ, ਫੰਕਸ਼ਨ ਨੂੰ ਮਜਬੂਰ ਕਰਨ ਲਈ ਇੱਕ ਨਵਾਂ ਇਨਪੁਟ ਡਿਜ਼ਾਈਨ ਕਰੋ), ਇਸਨੂੰ AI ਨਾਲ ਠੀਕ ਕਰੋ, ਅਤੇ ਦੁਬਾਰਾ ਜਾਂਚ ਕਰਕੇ ਪੁਸ਼ਟੀ ਕਰੋ ਕਿ ਫਿਕਸ ਕੰਮ ਕਰਦਾ ਹੈ।

ਚੈੱਕਲਿਸਟ

• [ ] ਮੈਂ ਇੱਕ ਇਕਰਾਰਨਾਮਾ ਲਿਖਿਆ ਹੈ ਜਿਸ ਵਿੱਚ ਇਨਪੁਟ, ਆਉਟਪੁੱਟ, ਤਰੁੱਟੀਆਂ ਅਤੇ ਰੁਕਾਵਟਾਂ ਸ਼ਾਮਲ ਹਨ।
• [ ] ਮੈਂ ਇੱਕ ਵੱਡੇ ਬਲਾਕ ਦੀ ਬਜਾਏ ਛੋਟੇ ਕਦਮਾਂ ਵਿੱਚ ਕੋਡ ਤਿਆਰ ਕੀਤਾ ਹੈ।
• [ ] ਮੈਂ ਕੋਡ ਦੇ ਅੱਗੇ ਇੱਕ ਟੈਸਟ/ਨਮੂਨਾ ਰਨ ਬਲਾਕ ਜੋੜਿਆ ਹੈ।
• [ ] ਮੈਂ ਸੁਚੇਤ ਤੌਰ 'ਤੇ ਘੱਟੋ-ਘੱਟ 5 ਕਿਨਾਰਿਆਂ ਦੇ ਕੇਸਾਂ ਦੀ ਜਾਂਚ ਕੀਤੀ ਹੈ।
• [ ] ਮੈਂ ਏਆਈ ਨੂੰ ਕੋਡ ਦੀ ਵਿਆਖਿਆ ਕੀਤੀ ਅਤੇ ਇਸ ਦੀਆਂ ਧਾਰਨਾਵਾਂ ਦੀ ਸਮੀਖਿਆ ਕੀਤੀ।
• [ ] ਮੈਂ ਮਿਲੀ ਗਲਤੀ ਨੂੰ ਠੀਕ ਕੀਤਾ ਹੈ ਅਤੇ ਦੁਬਾਰਾ ਜਾਂਚ ਕਰਕੇ ਠੀਕ ਕਰਨ ਦੀ ਪੁਸ਼ਟੀ ਕੀਤੀ ਹੈ।