ਅਡਾ ਲਵਲੇਸ ਦੀਆਂ ਨੋਟਾਂ Analytical Engine ਲਈ ਇਕ ਦੁਹਰਾਏ ਜਾਣ ਵਾਲੇ ਅਲਗੋਰਿਦਮ ਦਾ ਵੇਰਵਾ ਦਿੰਦੀਆਂ ਹਨ। ਵੇਖੋ ਕਿ ਉਸਦੇ ਪ੍ਰਾਰੰਭਕ ਵਿਚਾਰ ਅਧੁਨਿਕ ਪ੍ਰੋਗਰਾਮ ਡਿਜ਼ਾਈਨ ਅਤੇ ਸੋਚ ਨਾਲ ਕਿਵੇਂ ਮੇਲ ਖਾਂਦੇ ਹਨ।
ਤੁਸੀਂ ਸ਼ਾਇਦ ਸਿਰਫ਼ ਸਿਰਲੇਖ ਵਾਲੀ ਗੱਲ ਸੁਣੀ ਹੋਵੇਗੀ: ਅਡਾ ਲਵਲੇਸ ਨੇ “ਪਹਿਲਾ ਅਲਗੋਰਿਦਮ” ਲਿਖਿਆ — ਹਦਾਇਤਾਂ ਦੀ ਇੱਕ ਲੜੀ ਜੋ Charles Babbage ਦੇ Analytical Engine ਲਈ ਨਿਰਧਾਰਤ ਕੀਤੀ ਗਈ। ਲੋਕ ਅਜੇ ਵੀ ਇਸਨੂੰ ਉਦਾਹਰਨ ਵਜੋਂ ਦਿੰਦੇ ਹਨ ਕਿਉਂਕਿ ਇਹ ਪਹਿਲੇ ਆਰੰਭਕ ਦੌਰ ਦੀ ਸਾਫ਼-ਸਪਸ਼ਟ ਨਮੂਨਾ ਹੈ ਜੋ ਅਸੀਂ ਅੱਜ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਕਹਿੰਦੇ ਹਾਂ—ਮਕਸਦ ਨੂੰ ਇਨ੍ਹੀ ਪਕੀਆਂ ਕਦਮਾਂ ਵਿੱਚ ਤੋੜਨਾ ਜੋ ਮਸ਼ੀਨ ਅਨੁਸਾਰ ਚਲ ਸਕਣ।
ਇਹ ਲੇਖ Engine ਦੀਆਂ ਗੀਅਰਾਂ ਨੂੰ ਦੁਬਾਰਾ ਬਣਾਉਣ ਜਾਂ ਹਰ ਇਤਿਹਾਸਕ ਦਾਅਵੇ ਨੂੰ ਸਾਬਤ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਨਹੀਂ ਕਰਦਾ। ਬਲਕਿ, ਇਹ Lovelace ਦੇ ਕੰਮ ਵਿੱਚ ਮੌਜੂਦ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਵਿਚਾਰਾਂ 'ਤੇ ਕੇਂਦ੍ਰਿਤ ਹੈ: ਗਣਿਤੀ ਸਮੱਸਿਆ ਨੂੰ ਚਲਾਇਆ ਜੋਗ ਬਣਾਉਣਾ, ਡੇਟਾ ਦੀ ਪੇਸ਼ਕਸ਼, ਅਤੇ ਕਿਸੇ ਹੋਰ (ਜਾਂ ਮਸ਼ੀਨ) ਲਈ ਵਿਧੀ ਨੂੰ ਇੰਝ ਲਿਖਣਾ ਕਿ ਉਹ ਚਲਾ ਸਕੇ।
Lovelace ਦੀਆਂ ਮਸ਼ਹੂਰ “Notes” ਗਣਿਤ ਅਤੇ ਸਾਫਟਵੇਅਰ ਡਿਜ਼ਾਈਨ ਦਰਮਿਆਨ ਇੱਕ ਪੂਲ ਵਾਂਗ ਲੱਗਦੀਆਂ ਹਨ। ਹਾਲਾਂਕਿ ਮਸ਼ੀਨ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਕਲਪਨਾਤਮਕ ਸੀ, ਉਸ ਸੋਚ ਨੂੰ ਕੋਈ ਵੀ ਜਾਣਦਾ ਹੈ ਜਿਸਨੇ ਕਦੇ ਕੰਪਿਊਟਰ ਨੂੰ ਕਿਸੇ ਕੰਮ ਨੂੰ ਭਰੋਸੇਯੋਗ ਤਰੀਕੇ ਨਾਲ ਕਰਵਾਇਆ ।
ਅਸੀਂ ਆਉਂਦੇ ਹਿੱਸਿਆਂ ਵਿੱਚ ਇਹਨਾਂ ਗੱਲਾਂ 'ਤੇ ਨਜ਼ਰ ਰੱਖਾਂਗੇ:
ਅੰਤ 'ਤੇ ਮਨੋਰਥ ਸਧਾਰਨ ਹੈ: Lovelace ਦੇ “ਪਹਿਲੇ ਅਲਗੋਰਿਦਮ” ਨੂੰ ਇੱਕ ਮਿਊਜ਼ੀਅਮ-ਟੁਕੜੇ ਵਜੋਂ ਨਹੀਂ ਵੇਖਣਾ, ਸਗੋਂ ਗਣਨਾਤਮਕ ਸੋਚ ਲਈ ਇੱਕ ਸ਼ੁਰੂਆਤੀ ਟੈਂਪਲੇਟ ਵਜੋਂ ਵੇਖਣਾ ਜੋ ਅਜੇ ਵੀ ਪ੍ਰੋਗਰਾਮ ਡਿਜ਼ਾਈਨ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।
Augusta Ada King, Countess of Lovelace—ਜ਼ਿਆਦਾ ਜਾਣੀ ਜਾਂਦੀ ਹੈ ਅਡਾ ਲਵਲੇਸ—ਇੱਕ ਐਸੇ ਮਾਹੌਲ ਵਿੱਚ ਪਲੀ-ਬਢੀ ਜਿੱਥੇ ਕਵਿਤਾ ਅਤੇ ਗਣਿਤ ਮਿਲਦੇ ਸਨ। ਉਸਦੀ ਮਾਂ ਨੇ ਸਕੂਲਦਾਰ ਅਧਿਐਨ ਨੂੰ ਉਤਸ਼ਾਹਿਤ ਕੀਤਾ, ਅਤੇ ਅਡਾ ਜਲਦੀ ਹੀ ਵਿਗਿਆਨੀਆਂ ਅਤੇ ਵਾਦ-ਵਿਵਾਦਕਾਂ ਦੇ ਛੋਟੇ ਗਿਰੋਹ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋ ਗਈ। ਉਹ ਏਕਲਵੰਤੀ ਜੈਵ-ਉਤਕ੍ਰਿਸ਼ਟਤਾ ਨਹੀਂ ਸੀ; ਉਹ ਇੱਕ ਪ੍ਰਤਿਭਾਸ਼ਾਲੀ ਸਹਿਯੋਗੀ ਸੀ ਜਿਸਨੇ ਮਸ਼ੀਨਾਂ ਦੇ “ਮੁਆਇਨੇ” ਬਾਰੇ ਅਸਧਾਰਣ ਸਪਸ਼ਟ ਸਵਾਲ ਕੀਤੇ—ਸਿਰਫ਼ ਉਹ ਕੀਆ ਕਰ ਸਕਦੀਆਂ ਹਨ ਦੇ ਬਾਰੇ ਨਹੀਂ।
Charles Babbage ਉਸ ਸਮੇਂ mechanical calculation ਲਈ ਆਪਣੇ ਯੋਜਨਾਵਾਂ ਲਈ ਪਹਿਲਾਂ ਹੀ ਮਸ਼ਹੂਰ ਸੀ। ਉਹ ਸੋਚ ਵਿਚ ਹੀ ਹਾਰਡਵੇਅਰ ਡਿਜ਼ਾਇਨ ਕਰ ਸਕਦਾ ਸੀ: ਗੀਅਰ, ਸ਼ਾਫਟ, ਅਤੇ ਨੰਬਰ-ਚੱਕਰ ਇੱਕ ਪ੍ਰਣਾਲੀ ਵਜੋਂ। ਅਡਾ ਦੇ ਪਾਸ ਸਪਸ਼ਟ ਕਰਨ ਦੀ ਕਲਾ ਸੀ—ਕਠਿਨ ਤਕਨੀਕੀ ਖਿਆਲਾਂ ਨੂੰ ਸੰਰਚਿਤ ਅਤੇ ਸੰਚਾਰਯੋਗ ਸੰਕਲਪਾਂ ਵਿੱਚ ਤਰਜਮਾ ਕਰਨ ਦੀ।
ਉਹਨਾਂ ਦਾ ਸੰਬੰਧ ਇਸ ਲਈ ਕੰਮ ਕਰਦਾ ਸੀ ਕਿਉਂਕਿ ਉਹਨਾਂ ਦੀਆਂ ਤਾਕਤਾਂ ਵੱਖ-ਵੱਖ ਸਨ। ਬੈਬੇਜ ਇੰਜੀਨੀਅਰਿੰਗ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਨੂੰ ਅੱਗੇ ਵਧਾਉਂਦਾ; ਅਡਾ ਸੰਕਲਪਿਕ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਨੂੰ ਅੱਗੇ ਵਧਾਉਂਦੀ, ਖਾਸ ਕਰਕੇ ਇਸ ਵਿਚਾਰ ਨੂੰ ਕਿ ਮਸ਼ੀਨ ਇੱਕ ਅਦ੍ਰਿਸ਼ਟ-ਪੌਲ ਨੂੰ ਅਨੁਸਰਣ ਕਰ ਸਕਦੀ ਹੈ ਜੋ ਕਿਸੇ ਵਿਅਕਤੀ ਵੱਲੋਂ ਪਹਲਾਂ ਤਿਆਰ ਕੀਤੀ ਗਈ ਹੋਵੇ।
Babbage ਦਾ Analytical Engine ਸਿਰਫ਼ ਇੱਕ ਬਿਹਤਰ ਕੈਲਕੁਲੇਟਰ ਨਹੀਂ ਸੀ। ਕਾਗਜ਼ 'ਤੇ ਇਹ ਇੱਕ general-purpose ਮਸ਼ੀਨ ਦਾ ਖਾਕਾ ਦਿੰਦਾ ਸੀ: ਇੱਕ ਜੋ ਮੁੱਲ ਰੱਖ ਸਕਦਾ, ਕਾਰਵਾਈਆਂ ਕਰ ਸਕਦਾ, ਅਤੇ ਇੱਕ ਤਹਿ-ਕ੍ਰਮਿਤ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਕਦਮ-ਬਦ-ਕਦਮ ਚਲਾ ਸਕਦਾ। ਇਸਨੂੰ ਅਸੀਂ ਅਜੋਕੇ ਸਮੇਂ ਦੇ programmable computer ਦਾ ਪਹਿਲਾ ਰੂਪਕ ਸਮਝ ਸਕਦੇ ਹਾਂ—ਭਾਵੇਂ ਇਹ ਉਨ੍ਹਾਂ ਦੀ ਜ਼ਿੰਦਗੀ ਵਿੱਚ ਮੁਕੰਮਲ ਨਾ ਹੋ ਸਕੀ।
ਉਹ ਦਹਾਕਾ ਆਪਣੇ ਆਪ ਵਿੱਚ ਇੱਕ ਐਸਾ ਸਮਾਂ ਸੀ ਜਿੱਥੇ ਗਣਿਤ, ਉਦਯੋਗ ਅਤੇ ਆਟੋਮੇਸ਼ਨ ਇਕੱਠੇ ਹੋ ਰਹੇ ਸਨ। ਲੋਕਾਂ ਨੂੰ ਭਰੋਸੇਯੋਗ ਵਿਧੀਆਂ ਦੀ ਲੋੜ ਸੀ—ਟੇਬਲਾਂ, ਫਾਰਮੂਲਾਂ, ਅਤੇ ਦੁਹਰਾਉਯੋਗ ਪ੍ਰਕਿਰਿਆ—ਕਿਉਂਕਿ ਗਲਤੀਆਂ ਮਹਿੰਗੀਆਂ ਪੈਂਦੀਆਂ ਸਨ ਅਤੇ ਵਿਗਿਆਨ ਤੇਜ਼ੀ ਨਾਲ ਅੱਗੇ ਵੱਧ ਰਿਹਾ ਸੀ। ਇਸ ਪ੍ਰਸੰਗ ਵਿੱਚ, ਮਸ਼ੀਨ ਨੂੰ “ਹਦਾਇਤ ਦੇਣ” ਵਿੱਚ ਅਡਾ ਦੀ ਦਿਲਚਸਪੀ ਕੋਈ ਸਧਾਰਨ ਜਿਗਿਆਸਾ ਨਹੀਂ ਸੀ—ਇਹ ਮਨੁੱਖੀ ਤਰਕ ਨੂੰ ਦੁਹਰਾਉਯੋਗ, ਜਾਂਚਯੋਗ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿੱਚ ਬਦਲਣ ਦੀ ਇੱਕ ਟਾਇਮਲੀ ਜ਼ਰੂਰਤ ਦਾ ਜਵਾਬ ਸੀ।
ਅਡਾ ਲਵਲੇਸ ਇੱਕ ਅਲਗੋਰਿਦਮ ਵੇਖਾ ਸਕਣ ਤੋਂ ਪਹਿਲਾਂ, ਇਕ ਮਸ਼ੀਨ ਹੋਣੀ ਲਾਜ਼ਮੀ ਸੀ ਜੋ “ਪਰੋਗਰਾਮਿੰਗ” ਯੋਗ ਹੋਵੇ। Charles Babbage ਦਾ Analytical Engine ਇੱਕ ਐਸਾ ਜਨਰਲ-ਪਰਪਜ਼ ਕੈਲਕੁਲੇਟਰ ਸੋਚਿਆ ਗਿਆ ਸੀ: ਨਾ ਕਿ ਸਿਰਫ਼ ਕਿਸੇ ਇੱਕ ਫਾਰਮੂਲੇ ਲਈ, ਬਲਕਿ ਇਕ ਐਸੀ ਮਸ਼ੀਨ ਜੋ ਬਹੁਤ ਸਾਰੀਆਂ ਕ੍ਰਮਾਂ ਨੂੰ ਨਿਭਾ ਸਕੇ।
ਮੂਲ ਵਿਚਾਰ ਸਧਾਰਨ ਸੀ: ਜੇ ਤੁਸੀਂ ਕਿਸੇ ਸਮੱਸਿਆ ਨੂੰ ਛੋਟੇ ਅੰਕਗਣਿਤੀ ਕਦਮਾਂ (ਜੋੜ, ਘਟਾਅ, ਗੁਣਾ, ਭਾਗ) ਵਿੱਚ ਤੋੜ ਸਕਦੇ ਹੋ ਤਾਂ ਮਸ਼ੀਨ ਉਹ ਕਦਮ ਠੀਕ ਕ੍ਰਮ ਵਿੱਚ, ਜਿੰਨੀ ਵਾਰੀ ਲੋੜ ਹੋਵੇ, ਕਰ ਸਕਦੀ ਹੈ।
ਇਹ ਇੱਕ-ਵਾਰੀ ਗਣਨਾ ਤੋਂ ਦੁਬਾਰਾ-ਵਰਤੀਯੋਗ ਵਿਧੀ ਵੱਲ ਛਲਾਂਗ ਹੈ।
Babbage ਨੇ ਦੋ ਮੁੱਖ ਭਾਗ ਵੇਖਾਏ:
ਇਨਪੁਟ ਅਤੇ ਆਉਟਪੁੱਟ ਲਈ, Engine ਨੂੰ ਪੰਚਡ ਕਾਰਡ (ਜੋ ਜਾਕਾਰਡ ਲੂਮ ਤੋਂ ਪ੍ਰੇਰਿਤ ਸਨ) ਰਾਹੀਂ ਹਦਾਇਤਾਂ ਅਤੇ ਡੇਟਾ ਲੈਣ ਅਤੇ ਨਤੀਜੇ ਕੋਈ ਛਪੇ ਰੂਪ ਜਾਂ ਹੋਰ ਰਿਕਾਰਡ ਕੀਤਾ ਰੂਪ ਦੇਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਸੀ।
ਅਜੋਕੇ ਦ੍ਰਿਸ਼ਟੀ ਨਾਲ ਇਹ ਆਈਡੀਯਾ ਇੰਝ ਨਕਸ਼ੀ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ:
ਇਸ ਲਈ Analytical Engine ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ: ਇਹ ਉਹ ਵੰਡ ਦਿਖਾਉਂਦਾ ਹੈ ਜਿਸ 'ਤੇ ਅਸੀਂ ਅਜੇ ਵੀ ਨਿਰਭਰ ਹਾਂ—ਹਾਰਡਵੇਅਰ ਜੋ ਕਦਮ ਚਲਾਉਂਦਾ ਹੈ, ਅਤੇ ਪ੍ਰੋਗਰਾਮ ਜੋ ਦੱਸਦੇ ਹਨ ਕਿਹੜੇ ਕਦਮ ਚਲਾਉਣੇ ਹਨ।
ਜਦੋਂ ਲੋਕ ਅਡਾ ਲਵਲੇਸ ਅਤੇ ਪਹਿਲੇ ਅਲਗੋਰਿਦਮ ਬਾਰੇ ਗੱਲ ਕਰਦੇ ਹਨ, ਉਹ ਅਕਸਰ ਉਸ ਖਾਸ ਸੰਚੀ (Notes) ਵੱਲ Ishara ਕਰਦੇ ਹਨ ਜੋ ਉਸ ਨੇ Luigi Menabrea ਦੇ ਲੇਖ ਦੇ ਅੰਗਰੇਜ਼ੀ ਅਨੁਵਾਦ ਨਾਲ ਜੋੜੀ।
Menabrea ਨੇ ਮਸ਼ੀਨ ਦੀ ਧਾਰਣਾ ਦਰਸਾਈ। Lovelace ਹੋਰ ਅੱਗੇ ਗਈ: ਉਸਨੇ Engine ਨੂੰ ਇੱਕ ਅਜਿਹੀ ਚੀਜ਼ ਵਜੋਂ ਦੇਖਿਆ ਜਿਸ ਨੂੰ ਤੁਸੀਂ ਹਦਾਇਤ ਦੇ ਸਕਦੇ ਹੋ—ਸਿਰਫ਼ ਪ੍ਰਸ਼ੰਸਾ ਨਹੀਂ ਕਰ ਸਕਦੇ। ਇਹ ਬਦਲਾਅ ਹੀ ਕਾਰਨ ਹੈ ਕਿ ਇਹ Notes ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਇਤਿਹਾਸ ਵਿੱਚ ਇੰਨੀ ਮਹੱਤਵਪੂਰਣ ਹਨ। ਉਹ ਪਹਿਲੀ ਗਣਨਾਤਮਕ ਸੋਚ ਵਾਂਗ ਪੜ੍ਹਦੀਆਂ ਹਨ: ਇੱਕ ਲੱਖੀ ਨੂੰ ਸਹੀ-ਸਪਸ਼ਟ ਕਦਮਾਂ ਵਿੱਚ ਤੋੜਨਾ, ਪ੍ਰਤੀਨਿਧਿਤੀਆਂ ਚੁਣਨਾ, ਅਤੇ ਪੇਸ਼ਗੀ ਸੋਚ ਕੇ ਕਿ ਮਕੈਨਿਜ਼ਮ ਕਿਵੇਂ ਉਹਨਾਂ 'ਤੇ ਅਮਲ ਕਰੇਗਾ।
Lovelace ਦੀਆਂ Notes ਉਸ ਚੀਜ਼ ਨੂੰ ਵਿਆਖਿਆ ਕਰਦੀਆਂ ਹਨ ਜੋ ਅਸੀਂ ਹੁਣ ਪ੍ਰੋਗ੍ਰਾਮ ਡਿਜ਼ਾਈਨ ਕਹਾਂਗੇ। ਉਹ Engine ਦੇ ਹਿੱਸਿਆਂ (ਜਿਵੇਂ memory store ਅਤੇ processing “mill”) ਨੂੰ ਇਸ ਰੂਪ ਵਿੱਚ ਵੇਖਾਉਂਦੀਆਂ ਹਨ ਕਿ ਕਾਰਵਾਈਆਂ ਕਿਵੇਂ ਘੁੱਟੀਆਂ ਅਤੇ ਨਿਯੰਤਰਿਤ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਕੇਂਦਰੀ ਵਿਚਾਰ ਸਧਾਰਨ ਪਰ ਗਹਿਰਾ ਹੈ: ਜੇ Analytical Engine ਕਿਸੇ ਨਿਰਧਾਰਿਤ ਕ੍ਰਮ ਵਿੱਚ ਨਿਰਧਾਰਿਤ ਚਿੰਨ੍ਹਾਂ 'ਤੇ ਕਾਰਵਾਈ ਕਰ ਸਕਦਾ ਹੈ, ਤਾਂ “ਕਿਵੇਂ” ਉਸਨੂੰ ਇਕ ਐਸੇ ਰੂਪ ਵਿੱਚ ਲਿਖਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਜੋ ਮਸ਼ੀਨ ਚਲਾ ਸਕੇ।
ਇਥੇ ਉਸਦਾ ਕੰਮ ਆਧੁਨਿਕ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਨਾਲ ਇੱਕ ਰੂਪ ਲੈਂਦਾ ਹੈ। ਇਹ ਸਿਰਫ਼ ਸਿਧਾਂਤ ਨਹੀਂ; ਇਹ ਇੱਕ ਤਰੀਕਾ ਹੈ।
ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ gall, Notes ਵਿੱਚ ਇੱਕ ਕੰਮ ਕੀਤਾ ਉਦਾਹਰਨ ਇਕ ਟੇਬਲ ਰੂਪ ਵਿੱਚ ਹੈ। ਇਹ ਲਾਈਨ-ਦਰ-ਲਾਈਨ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਮਸ਼ੀਨ ਨੂੰ ਕੀ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ—ਕਿਹੜੇ ਮੁੱਲ ਕਿਸ ਸਥਾਨ ਤੇ ਹਨ, ਅਗਲੀ ਕਾਰਵਾਈ ਕੀ ਹੈ, ਅਤੇ ਨਤੀਜੇ ਕਿੱਥੇ ਰੱਖੇ ਜਾਣਗੇ।
ਉਹ ਟੇਬਲ ਫਾਰਮੈਟ ਅਜੋਕੇ ਪਿਊਡੋ ਕੋਡ, ਫਲੋਚਾਰਟ ਅਤੇ ਨਿਰਦੇਸ਼ ਸ਼ਡਿਊਲ ਦਾ ਪੂਰਵਜ ਹੈ: ਇੱਕ ਸਪਸ਼ਟ, ਜਾਂਚਯੋਗ ਯੋਜਨਾ ਜੋ ਤੁਸੀਂ ਬਿਨਾਂ ਅਨੁਮਾਨ ਦੇ ਪਾਲਣਾ ਕਰ ਸਕਦੇ ਹੋ। Chahe ਤੁਸੀਂ ਕਦੇ Analytical Engine ਬਣਾਉਂਦੇ ਹੋ ਜਾਂ ਨਹੀਂ, ਇਹ ਰ習習ਸ ਤੁਸੀਂ ਇਕ ਵਿਚਾਰ ਨੂੰ ਕਾਰਵਾਈਯੋਗ ਲੜੀ ਵਿੱਚ ਬਦਲਣ ਦੀ ਆਦਤ ਸਿਖਾਉਂਦੀ ਹੈ—ਜੋ ਅਜੇ ਵੀ ਸਾਫਟਵੇਅਰ ਲਿਖਣ ਦਾ ਕੇਂਦਰ ਹੈ।
ਇੱਕ ਅਲਗੋਰਿਦਮ ਆਮ ਬੋਲਚਾਲ ਵਿੱਚ ਇੱਕ ਦੁਹਰਾਯੋਗ ਤਰੀਕਾ ਹੁੰਦੀ ਹੈ: ਇੱਕ ਸਪਸ਼ਟ ਕਦਮਾਂ ਦੀ ਲੜੀ ਜੋ ਸ਼ੁਰੂਆਤੀ ਸਥਿਤੀ ਤੋਂ ਇੱਕ ਨਤੀਜੇ ਤੱਕ ਭਰੋਸੇਯੋਗ ਢੰਗ ਨਾਲ ਪਹੁੰਚਾਉਂਦੀ ਹੈ। ਇਹ ਇਕ ਰਸੋਈ ਦੀ ਰੀਸਪੀ ਵਾਂਗ ਹੈ ਜੋ ਅਨੁਮਾਨ 'ਤੇ ਨਿਰਭਰ ਨਹੀਂ—ਜੇ ਤੁਸੀਂ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰਦੇ ਹੋ, ਤਾਂ ਹਰ ਵਾਰੀ ਵਾਰ ਤੁਸੀਂ ਉਹੀ ਨਤੀਜਾ ਮਿਲੇਗਾ।
ਅਡਾ ਲਵਲੇਸ ਦੀ ਮਸ਼ਹੂਰ ਉਦਾਹਰਨ ਦਾ ਲਕਸ਼ ਬੇਰਨੌਲੀ ਨੰਬਰ ਨਿਕਾਲਣਾ ਸੀ—ਇੱਕ ਲੜੀ ਜੋ ਗਣਿਤ ਵਿੱਚ ਕਈ ਥਾਵਾਂ 'ਤੇ ਆਉਂਦੀ ਹੈ। ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਦੇ ਿਥਿਅਰ ਦਾ ਗਿਆਨ ਹੋਣ ਦੀ ਲੋੜ ਨਹੀਂ ਕਿ ਇਹ ਸਮਝਣ ਲਈ ਕਿ ਉਹ ਇੱਕ ਚੰਗਾ "ਟੈਸਟ ਕੇਸ" ਕਿਉਂ ਹਨ।
ਉਹ ਇਸ ਤਰੀਕੇ ਨਾਲ ਚੁਣੇ ਗਏ ਸਨ ਕਿ:\n\n- ਹਰ ਨਵਾਂ ਬੇਰਨੌਲੀ ਨੰਬਰ ਪਹਿਲਾਂ ਵਾਲਿਆਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ ਇੱਕ-बार ਕਦਮ ਕਾਫ਼ੀ ਨਹੀਂ।\n- ਗਣਨਾ ਵਿੱਚ ਕਈ ਕਾਰਵਾਈਆਂ ਸ਼ਾਮਲ ਹਨ (ਜੋੜ, ਘਟਾਅ, ਗੁਣਾ, ਭਾਗ)।\n- ਇੱਕ ਪਤਾ ਲੱਗੀ ਹੋਈ ਠੀਕ ਲੜੀ ਹੈ, ਇਸ ਲਈ ਨਤੀਜੇ ਦੀ ਜਾਂਚ ਹੋ ਸਕਦੀ ਹੈ।
ਇਹਨਾਂ ਗੁਣਾਂ ਨਾਲ, ਇਹ ਐਸਾ ਮੁੱਦਾ ਹੈ ਜੋ ਦਿੱਖਾਉਂਦਾ ਹੈ ਕਿ ਮਸ਼ੀਨ ਇਕ ਸਨਞੀਵਨਯੋਗ ਵਿਧੀ ਦੀ ਪਾਲਣਾ ਕਰ ਸਕਦੀ ਹੈ।
ਮੂਲ ਰੂਪ ਵਿੱਚ, ਅਲਗੋਰਿਦਮ ਵਿੱਚ ਉਹੀ ਢਾਂਚਾ ਹੈ ਜੋ ਅਸੀਂ ਅਜੇ ਵੀ ਪ੍ਰੋਗ੍ਰਾਮਾਂ 'ਚ ਵਰਤਦੇ ਹਾਂ:
ਇਸ ਦ੍ਰਿਸ਼ਟੀ ਨਾਲ, Lovelace ਸਿਰਫ਼ ਕੋਈ ਨੰਬਰ ਗਣਨਾ ਨਹੀਂ ਦਿਖਾ ਰਹੀ—ਉਹ ਦਿਖਾ ਰਹੀ ਸੀ ਕਿ ਕਿਸ ਤਰ੍ਹਾਂ ਇੱਕ ਬਹੁ-ਕਦਮੀ ਗਣਨਾ ਨੂੰ ਇਸ ਤਰੀਕੇ ਨਾਲ ਵਿਵਸਥਿਤ ਕੀਤਾ ਜਾਵੇ ਕਿ ਮਸ਼ੀਨ ਬਿਨਾਂ ਅਨੁਮਾਨ ਦੇ ਚਲਾ ਸਕੇ।
ਜਦ ਲੋਕ Lovelace ਦੇ ਬੇਰਨੌਲੀ ਅਲਗੋਰਿਦਮ ਬਾਰੇ ਗੱਲ ਕਰਦੇ ਹਨ, ਉਹ ਅਕਸਰ ਨਤੀਜੇ 'ਤੇ ਧਿਆਨ ਦੇਂਦੇ ਹਨ (“ਇੱਕ ਸ਼ੁਰੂਆਤੀ ਪ੍ਰੋਗ੍ਰਾਮ”) ਬਜਾਏ ਉਸ ਡਿਜ਼ਾਈਨ ਕੰਮ ਦੇ ਜੋ ਕਦਮਾਂ ਨੂੰ ਭਰੋਸੇਯੋਗ ਬਣਾਉਂਦਾ ਹੈ। ਅਸਲ ਕਾਰਜ ਸਿਰਫ਼ ਕਾਰਵਾਈਆਂ ਦੀ ਸੂਚੀ ਲਿਖਣਾ ਨਹੀਂ—ਉਹ ਉਨ੍ਹਾਂ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਸਾਜ਼ਣਾ ਹੈ ਕਿ ਮਸ਼ੀਨ ਉਨ੍ਹਾਂ 'ਤੇ ਬਿਨਾਂ ਬਦਲੀ ਦੇ ਚੱਲ ਸਕੇ।
“ਬੇਰਨੌਲੀ ਨੰਬਰ ਕੱਢੋ” ਨੂੰ ਇਕ ਹੀ ਟਾਸਕ ਵਜੋਂ ਦੇਖਣ ਦੀ ਬਜਾਏ, Notes ਨੇ ਇਸਨੂੰ ਛੋਟੇ-ਛੋਟੇ ਭਾਗਾਂ ਵਿੱਚ ਵੰਡਿਆ: ਦਰਮਿਆਨੀ ਮੁੱਲ ਕੱਢੋ, ਉਹਨਾਂ ਨੂੰ ਕੋਈ ਵਿਸ਼ੇਸ਼ ਫਾਰਮੂਲੇ ਵਿੱਚ ਜੋੜੋ, ਨਤੀਜੇ ਨੋਟ ਕਰੋ, ਫਿਰ ਅਗਲੇ ਕੇਸ 'ਤੇ ਜਾਵੋ।
ਡਿਕੰਪੋਜ਼ਿਸ਼ਨ ਇਸ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ ਹਰ ਉਪ-ਟਾਸਕ ਨੂੰ ਅਲੱਗ ਤੌਰ 'ਤੇ ਜਾਂਚਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਜੇ ਨਤੀਜਾ ਗਲਤ ਆਉਂਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ "ਪੂਰੇ ਅਲਗੋਰਿਦਮ" ਨੂੰ ਡੀਬਗ ਨਹੀ ਕਰਦੇ; ਤੁਸੀਂ ਇਕ ਹੀ ਹਿੱਸੇ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹੋ।
ਇੱਕ ਮਕੈਨਿਕਲ ਕੰਪਿਊਟਰ "ਦਿਮਾਗ਼ ਵਿੱਚ ਰਹਿਣਾ" ਨਹੀਂ ਜਾਣਦਾ। ਹਰ ਮੁੱਲ ਜੋ ਬਾਅਦ ਵਿੱਚ ਲੋੜੀਂਦਾ ਹੋਵੇ, ਉਸਨੂੰ ਕਿਸੇ ਥਾਂ ਰੱਖਣਾ ਪੈਂਦਾ ਹੈ, ਅਤੇ Notes ਇਸ ਗੱਲ 'ਚ ਬਹੁਤ ਧਿਆਨ ਰੱਖਦੀਆਂ ਹਨ। ਕੁਝ ਨੰਬਰ ਅਸਥਾਈ ਹੁੰਦੇ ਹਨ; ਕੁਝ ਅੰਤਮ ਨਤੀਜੇ ਹੁੰਦੇ ਹਨ ਜੋ ਆਗਲੇ ਕਦਮ ਲਈ ਟਿਕੇ ਰਹਿਣੇ ਚਾਹੀਦੇ ਹਨ।
ਇਹ ਪ੍ਰੋਗ੍ਰਾਮ ਸਟੇਟ ਬਾਰੇ ਸੋਚਣ ਦਾ ਪਹਿਲਾ ਰੂਪ ਹੈ:
ਕਦਮਾਂ ਦਾ ਕ੍ਰਮ ਇੱਕ ਸੁਰੱਖਿਆ ਨੁਹਾਰ ਹੈ। ਕੁਝ ਗਣਨ ਪਹਿਲਾਂ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ, ਨਾ ਕਿ ਬਣਾਵਟੀ ਕਾਰਨ, ਸਗੋਂ ਇਸ ਲਈ ਕਿ ਅਣਪੜ੍ਹੀ ਕੀਮਤ ਦਾ ਉਪਯੋਗ ਨਾ ਹੋਵੇ ਜਾਂ ਦੂਸਰੀ ਗਣਨਾ ਲਈ ਲੋੜੀਂਦਾ ਕੁਝ ਓਵਰਰਾਈਟ ਨਾ ਹੋ ਜਾਵੇ।
ਅਜੋਕੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, Lovelace ਕੰਟਰੋਲ ਫਲੋ ਇਸ ਤਰ੍ਹਾਂ ਡਿਜ਼ਾਇਨ ਕਰ ਰਹੀ ਹੈ ਕਿ ਪ੍ਰੋਗ੍ਰਾਮ ਦਾ ਰਸਤਾ ਸਾਫ਼ ਹੋਵੇ: A ਕਰ, ਫਿਰ B, ਫਿਰ C—ਕਿਉਂਕਿ B ਪਹਿਲਾਂ ਕਰਨ ਨਾਲ ਚੁੱਪਚਾਪ ਗਲਤ ਨਤੀਜਾ ਆ ਜਾਵੇਗਾ।
Lovelace ਦੀ ਕਦਮ-ਟੇਬਲ ਵਿੱਚ ਇੱਕ ਸਭ ਤੋਂ "ਆਧੁਨਿਕ" ਵਿਚਾਰ ਰਿਪੀਟੀਸ਼ਨ ਹੈ: ਇੱਕੋ ਹੁਕਮਾਂ ਦੀ ਲੜੀ ਨੂੰ ਕਈ ਵਾਰੀ ਕਰਨਾ, ਨਾ ਕਿ ਤੁਸੀਂ ਫਸੇ ਹੋ, ਪਰ ਕਿਉਂਕਿ ਦੁਹਰਾਉਂ ਨਾਲ ਨਤੀਜੇ ਤੇਜ਼ੀ ਨਾਲ ਮਿਲਦੇ ਹਨ।
ਪ੍ਰੋਗ੍ਰਾਮ ਵਿੱਚ ਰਿਪੀਟੀਸ਼ਨ ਮਤਲਬ ਹੈ: ਇੱਕ ਛੋਟੀ ਰੀਸਪੀ ਦੀ ਪਾਲਣਾ ਕਰੋ, ਜਾਂਚੋ ਕਿ ਕੀ ਤੁਸੀਂ ਖਤਮ ਹੋ ਗਏ ਹੋ, ਅਤੇ ਜੇ ਨਹੀਂ ਤਾਂ ਉਹੀ ਰੀਸਪੀ ਫਿਰ ਚਲਾਓ। ਮੁੱਖ ਗੱਲ ਇਹ ਹੈ ਕਿ ਹਰ ਵਾਰੀ ਕੁਝ ਬਦਲਦਾ ਹੈ—ਅਕਸਰ ਇੱਕ ਕਾਊੰਟਰ, ਟੇਬਲ ਵਿੱਚ ਸਥਿਤੀ, ਜਾਂ ਉਸ ਮੁੱਲ ਜੋ ਤੁਸੀਂ ਬਣਾਉਂਦੇ ਹੋ—ਤਾਂ ਜੋ ਪ੍ਰੋਗ੍ਰਾਮ ਮੰਜ਼ਿਲ ਦੀ ਵੱਲ ਵਧੇ।
Lovelace ਦੀ ਨੋਟੇਸ਼ਨ ਵਿੱਚ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਤੁਲਕ ਰੀਟਰਨ ਕਿਵੇਂ ਦਰਸਾਇਆ ਗਿਆ ਹੈ। ਉਹ ਇੱਕ ਪੈਟਰਨ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ ਅਤੇ ਦਿਖਾਉਂਦੀ ਹੈ ਕਦੋਂ ਮੁੜ ਪੁਰਾਣੇ ਕਦਮ 'ਤੇ ਆਉਣਾ ਹੈ। ਇਹੀ ਅਦਾ ਹੈ ਜੋ ਅਸੀਂ ਅੱਜ ਇਟਰੇਸ਼ਨ ਕਹਿੰਦੇ ਹਾਂ।
ਜੇ ਤੁਸੀਂ ਕੋਡ ਲਿਖਿਆ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਇਹ ਪੈਟਰਨ for ਲੂਪ ("ਇਸਨੂੰ N ਵਾਰ ਦੁਹਰਾਓ") ਜਾਂ while ਲੂਪ ("ਇੱਕ ਸ਼ਰਤ ਪੂਰੀ ਹੋਣ ਤੱਕ ਦੁਹਰਾਓ") ਵਜੋਂ ਦੇਖਿਆ ਹੋਵੇਗਾ। ਉਸ ਦੀ ਟੇਬਲ ਵੀ ਇਹੋ ਹੀ ਤੱਤ ਦਰਸਾਂਉਦੀ ਹੈ:
ਕਲਪਨਾ ਕਰੋ ਕਿ ਤੁਸੀਂ 1 ਤੋਂ 5 ਤੱਕ ਦੇ ਨੰਬਰਾਂ ਦਾ ਜੋੜ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ।\n\n- ਸ਼ੁਰੂ ਕਰੋ total = 0 ਨਾਲ\n- ਸ਼ੁਰੂ ਕਰੋ i = 1 ਨਾਲ\n- i ਨੂੰ total ਵਿੱਚ ਜੋੜੋ\n- i ਨੂੰ 1 ਨਾਲ ਵਧਾਓ\n- ਜੇ i ਅਜੇ ਵੀ 5 ਜਾਂ ਘੱਟ ਹੈ, ਤਾਂ ਜੋੜ ਅਤੇ ਵਧਾਉ ਦੇ ਕਦਮ ਨੂੰ ਦੁਹਰਾਓ\n\nਇਹ ਸਾਫ਼ ਸਧਾਰਨ ਇਟਰੇਸ਼ਨ ਹੈ: ਇੱਕ ਛੋਟਾ ਲੂਪ ਜੋ ਕਾਊੰਟਰ ਨੂੰ ਅੱਪਡੇਟ ਕਰਦਾ ਅਤੇ ਨਤੀਜੇ ਨੂੰ ਇਕਠਾ ਕਰਦਾ ਹੈ। Lovelace ਦਾ ਯੋਗਦਾਨ ਸਿਰਫ਼ ਜੋੜ-ਗਣਨਾ ਨਹੀਂ ਸੀ—ਉਸਨੇ ਦਿਖਾਇਆ ਕਿ ਦੁਹਰਾਉ ਢਾਂਚਾ ਐਸਾ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ ਕਿ ਮਸ਼ੀਨ (ਅਤੇ ਭਵਿੱਖ ਦੇ ਮਨੁੱਖ) ਵੀ ਭਰੋਸੇਯੋਗ ਤਰੀਕੇ ਨਾਲ ਚਲਾ ਸਕਣ।
ਕੋਈ ਵੀ ਪ੍ਰਕਿਰਿਆ ਤੁਹਾਡੇ ਮਨ ਵਿੱਚ ਤਰਕਸੰਗਤ ਹੋ ਸਕਦੀ ਹੈ, ਪਰ ਜੇ ਉਸਨੂੰ ਮਸ਼ੀਨ ਜਾਂ ਦੂਜੇ ਵਿਅਕਤੀ ਲਈ ਰਿਪ੍ਰਜ਼ੈਂਟ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਤਾਂ ਉਹ ਅਸੰਭਵ ਹੋ ਸਕਦੀ ਹੈ। ਇਥੇ ਵੈਰੀਏਬਲ ਅਤੇ ਨੋਟੇਸ਼ਨ ਜਰੂਰੀ ਬਣ ਜਾਂਦੇ ਹਨ।
ਵੈਰੀਏਬਲ ਇੱਕ ਲੇਬਲ ਕੀਤਾ ਡੱਬਾ ਹੈ। ਲੇਬਲ ਜ਼ਿੰਦਾਬਾਦ ਰਹਿੰਦਾ ਹੈ, ਪਰ ਡੱਬੇ ਦੇ ਅੰਦਰ ਜੋ ਕੁਝ ਹੈ ਉਹ ਬਦਲ ਸਕਦਾ ਹੈ।
ਜੇ ਤੁਸੀਂ ਇੱਕ ਲੜੀ ਕੱਢ ਰਹੇ ਹੋ ਤਾਂ ਤੁਹਾਡੇ ਕੋਲ ਹੋ ਸਕਦਾ ਹੈ:
ਇਨਾਂ ਡੱਬਿਆਂ ਦੇ ਬਿਨਾਂ ਤੁਹਾਨੂੰ ਹਰ ਚੀਜ਼ ਲੰਮੇ ਵਾਕਾਂ ਵਿੱਚ ਵੇਖਾਉਣੀ ਪੈਣੀ—ਜਿਵੇਂ “ਉਸ ਨੰਬਰ ਨੂੰ ਲਓ ਜੋ ਤੁਸੀਂ ਦੋ ਕਦਮ ਪਹਿਲਾਂ ਕੱਢਿਆ ਸੀ…”—ਜੋ ਜਲਦੀ ਗੁੰਝਲਦਾਰ ਬਣ ਜਾਂਦਾ ਹੈ।
Lovelace ਦੀਆਂ Notes ਵਿੱਚ ਜੋ ਨਿਸ਼ਾਨ ਅਤੇ ਲੇਬਲ ਹਨ ਉਹ ਸਿਰਫ਼ ਰਾਜਸੀ ਤੋਰ 'ਤੇ ਨਹੀਂ—ਉਹ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਚਲਾਉਣ ਯੋਗ ਬਣਾਉਣ ਲਈ ਹਨ। ਸਪਸ਼ਟ ਨੋਟੇਸ਼ਨ ਇਨ੍ਹਾਂ ਪ੍ਰਸ਼ਨਾਂ ਦਾ ਜਵਾਬ ਦਿੰਦੀ ਹੈ:
ਜਦੋਂ ਵਿਧੀਆਂ ਲੰਬੀਆਂ ਹੁੰਦੀਆਂ ਹਨ, ਇਹ ਛੋਟੀ-ਛੋਟੀ ਸਪਸ਼ਟੀਆਂ ਸਭ ਤੋਂ ਆਮ ਗਲਤੀ ਨੂੰ ਰੋਕਦੀਆਂ ਹਨ: ਇੱਕੋ-ਜਿਹੀਆਂ ਦਿੱਸ਼ਾਂ ਨੂੰ ਗਲਤ ਮਿਲਾ ਬਠਾਵਣਾ।
ਚੰਗੇ ਵੈਰੀਏਬਲ ਨਾਂ ਰੱਖਣਾ ਅਜੇ ਵੀ ਸਮੱਸਿਆ ਘਟਾਉਣ ਦਾ ਸਭ ਤੋਂ ਸਸਤਾ ਤਰੀਕਾ ਹੈ। x1, x2, x3 ਦੀ ਥਾਂ current_sum, term_index, next_term ਜ਼ਿਆਦਾ ਸਪਸ਼ਟ ਹਨ।
ਟਾਈਪ ਇੱਕ ਹੋਰ ਸੁਰੱਖਿਆ ਪਰਤ ਹੈ। ਇਹ ਨਿਰਧਾਰਿਤ ਕਰਨਾ ਕਿ ਕੁਝ ਪੂਰਨ ਸੰਖਿਆ, ਦਸ਼ਮਲਵ, ਲਿਸਟ ਜਾਂ ਰਿਕਾਰਡ ਹੈ, ਇੱਕ ਢਾਬਾ ਚੁਣਨ ਵਾਂਗ ਹੀ ਹੈ—ਕੁਝ ਗਲਤੀਆਂ ਅਸੰਭਵ ਜਾਂ ਆਸਾਨੀ ਨਾਲ ਪਕੜੀਆਂਆਂ ਜਾਂਦੀਆਂ ਹਨ।
ਵੈਰੀਏਬਲ ਅਤੇ ਨੋਟੇਸ਼ਨ “ਇਕ ਚਤੁਰ ਵਿਚਾਰ” ਨੂੰ ਅਜਿਹੇ ਕਦਮ ਬਣਾਉਂਦੇ ਹਨ ਜੋ ਕੋਈ ਵੀ (ਇਹਨਾਂ ਵਿੱਚ ਮਸ਼ੀਨ ਵੀ ਸ਼ਾਮਲ) ਦੁਬਾਰਾ ਠੀਕ ਤਰੀਕੇ ਨਾਲ ਕਰ ਸਕਦਾ ਹੈ।
ਅਬਸਟ੍ਰੈਕਸ਼ਨ ਮਤਲਬ ਹੈ ਜਰੂਰੀ ਗੱਲ 'ਤੇ ਧਿਆਨ ਦੇਣਾ ਅਤੇ ਉਹਨਾਂ ਛੋਟੀਆਂ ਵਿਬਰਣਾਂ ਨੂੰ ਛੁਪਾਉਣਾ ਜੋ ਹਰੇਕ ਵਾਰ ਨਹੀਂ ਦੇਖਣੀਆਂ। ਇਹ ਇਹ ਫਰਕ ਹੈ: “ਇਸ ਸੂਚੀ ਨੂੰ sort ਕਰੋ” ਕਹਿਣਾ ਅਤੇ ਹਰ ਤਬਦੀਲੀ-ਅਦਲਾ-ਬਦਲੀ ਦੀ ਵਿਵਰਣ ਦੇਣੀ। Lovelace ਦੀਆਂ Notes ਇਸ ਮਨੋਭਾਵ ਨੂੰ ਪਹਿਲਾਂ ਹੀ ਦਰਸਾਉਂਦੀਆਂ ਹਨ: ਉਹ ਇੱਕ ਵਿਧੀ ਨੂੰ ਇਸ ਰੂਪ ਵਿੱਚ ਪੇਸ਼ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੀਆਂ ਹਨ ਕਿ ਪਾਠਕ ਨੁਹੀਂ ਮਸ਼ੀਨ ਦੀ ਮਕੈਨਿਕਸ ਵਿੱਚ ਫਸੇ।
Notes ਦੀ ਇੱਕ ਅਦਭੁਤ ਖੂਬੀ ਇਹ ਹੈ ਕਿ ਉਹ ਮੂਲ ਵਿਚਾਰ ਨੂੰ ਮਸ਼ੀਨ ਦੇ ਭौਤਿਕ ਕੰਮ ਤੋਂ ਅਲੱਗ ਰੱਖਦੀਆਂ ਹਨ। Analytical Engine ਦੀ ਆਪਣੀ “ਕਿਵੇਂ” ਸੀ (ਗੀਅਰ, ਸੀਟ, ਮਿਲ), ਪਰ Notes “ਕੀ” ਉੱਤੇ ਜੋਰ ਦਿੰਦੀਆਂ ਹਨ: ਉਹ ਕਾਰਵਾਈਆਂ ਜਿਹੜੀਆਂ ਨਤੀਜੇ ਤੱਕ ਲੈ ਜਾਂਦੀਆਂ ਹਨ।
ਇਹ ਵੰਡ ਅਜੋਕੇ ਸਾਫਟਵੇਅਰ ਡਿਜ਼ਾਈਨ ਦੀ ਜੜ ਹੈ:
ਜਦੋਂ ਤੁਸੀਂ ਵਿਧੀ ਨੂੰ ਮਸ਼ੀਨ ਤੋਂ ਵੱਖ ਵਖ ਕਰ ਕੇ ਵਰਨਨ ਕਰ ਸਕਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਗਣਨਾ ਨੂੰ ਪੋਰਟੇਬਲ ਸਮਝ ਰਹੇ ਹੋ—ਵੱਖ-ਵੱਖ ਹਾਰਡਵੇਅਰ ਜਾਂ ਲੋਕਾਂ ਦੁਆਰਾ ਮੁੜ-ਲਾਗੂ ਕਰਨਯੋਗ।
Notes ਦੀਆਂ ਟੇਬਲਾਂ ਪਹਿਲਾ “ਪ੍ਰੋਸੀਜਰ” ਦੀ ਤਰ੍ਹਾਂ ਲੱਗਦੀਆਂ ਹਨ: ਹਰੇਕ ਸਮੇਤ ਨਿਰਦੇਸ਼ਾਂ ਦੀ ਇੱਕ ਪੜੀ ਜੋ ਦੁਬਾਰਾ-ਦੁਬਾਰਾ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਆਧੁਨਿਕ ਕੋਡ ਇਸਨੂੰ ਫੰਕਸ਼ਨ, ਮੋਜੂਲ ਅਤੇ ਦੁਬਾਰਾ ਵਰਤੋਂਯੋਗ ਕੰਪੋਨੈਂਟਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਦਰਜ ਕਰਦਾ ਹੈ।
ਇੱਕ ਚੰਗਾ ਫੰਕਸ਼ਨ Lovelace ਦੀ ਪੇਸ਼ਕਸ਼ ਵਾਂਗ ਕਰਦਾ ਹੈ:
ਅਬਸਟ੍ਰੈਕਸ਼ਨ ਦਾ ਮਤਲਬ ਅਨਿਸ਼ਚਿਤ ਹੋਣਾ ਨਹੀਂ—ਇਹ ਵਰਤੋਂਯੋਗ ਹੋਣ ਦਾ ਮਤਲਬ ਹੈ। ਜਦੋਂ ਕੋਈ ਵਿਧੀ ਸਾਫ਼-ਸੁਥਰੀ ਤਰੀਕੇ ਨਾਲ ਦਰਸਾਈ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਉਸਨੂੰ ਵੱਖ-ਵੱਖ ਸੰਦਰਭਾਂ ਵਿੱਚ ਫਿਰ ਵਰਤ ਸਕਦੇ ਹੋ ਅਤੇ ਵੱਡੇ ਸਿਸਟਮ ਬਣਾ ਸਕਦੇ ਹੋ ਬਿਨਾਂ ਡਿੱਗਣ ਦੇ।
ਅਡਾ ਲਵਲੇਸ ਨੇ ਸਿਰਫ਼ ਦਿਖਾਇਆ ਕਿ Analytical Engine ਕੀ ਕਰ ਸਕਦੀ ਹੈ—ਉਸਨੇ ਵੀ ਇਹ ਦਿਖਾਇਆ ਕਿ ਕਿਸ ਤਰ੍ਹਾਂ ਇਕ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਨਾ-ਉਲਝਣਯੋਗ ਤਰੀਕੇ ਨਾਲ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ ਤਾਂ ਕਿ ਹੋਰ ਕੋਈ (ਜਾਂ ਮਸ਼ੀਨ) ਉਸਨੂੰ ਚਲਾ ਸਕੇ। ਇਹੀ ਉਸਦੀ Notes ਦੀ ਖਾਮੋਸ਼ ਤਾਕਤ ਹੈ: ਉਹ ਵਿਆਖਿਆ ਨੂੰ ਕੰਮ ਦਾ ਇੱਕ ਹਿੱਸਾ ਮੰਨਦੀ ਹੈ, ਨਾ ਕਿ ਸਿਰਫ਼ ਸ਼ਿੰਗਾਰ।
ਉਸਦੀ ਪੇਸ਼ਕਸ਼ ਅਜੇ ਵੀ ਆਧੁਨਿਕ ਮਹਿਸੂਸ ਹੁੰਦੀ ਹੈ ਕਿਉਂਕਿ ਉਸਨੇ ਸੰਰਚਿਤ, ਕਦਮ-ਦਰ-ਕਦਮ ਟੇਬਲ ਵਰਤੀ। ਟੇਬਲ ਤੁਹਾਨੂੰ ਉਹ ਫੈਸਲੇ ਲੈਣ 'ਤੇ ਮਜਬੂਰ ਕਰਦੀ ਜੋ ਢਿੱਲੀ ਗੱਲਬਾਤ ਛੁਪਾ ਸਕਦੀ:
ਇਹ ਅਸਪਸ਼ਟਤਾ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ, ਬਿਲਕੁਲ ਉਸੇ ਤਰ੍ਹਾਂ ਜਿਵੇਂ ਅੱਜ ਦੇ ਪਿਊਡੋ ਕੋਡ ਦਾ ਉਦੇਸ਼। ਤੁਸੀਂ ਇਕ ਪੈਰਾ ਪੜ੍ਹ ਸਕਦੇ ਹੋ ਅਤੇ ਸੋਚ ਸਕਦੇ ਹੋ ਕਿ ਤੁਹਾਨੂੰ ਸਮਝ ਆ ਗਈ—ਪਰ ਜਦੋਂ ਤੁਸੀਂ ਉਸਨੂੰ ਚਲਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋ ਤਾਂ ਅਸਲ ਰਸਤਾ ਟੇਬਲ ਹੀ ਦਿਖਾਉਂਦੀ ਹੈ।
Lovelace ਦੀਆਂ Notes ਤਿੰਨ ਚੀਜ਼ਾਂ ਮਿਲਾ ਦਿੰਦੀਆਂ ਹਨ ਜੋ ਅਸੀਂ ਅੱਜ ਵੀ ਇਕੱਠੇ ਰੱਖਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਾਂ:
ਇਹ ਆਧੁਨਿਕ comments, docstrings, ਅਤੇ READMEs ਨਾਲ ਵਧੀਆ ਤਰੀਕੇ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। README ਉਦੇਸ਼ ਅਤੇ ਸੰਦਰਭ ਸਪਸ਼ਟ ਕਰਦਾ ਹੈ। ਇਨਲਾਈਨ ਟਿੱਪਣੀਆਂ ਮੁਸ਼ਕਲ ਕਦਮਾਂ ਨੂੰ ਸਾਫ਼ ਕਰਦੀਆਂ ਹਨ। Docstrings ਇਨਪੁਟ/ਆਉਟਪੁਟ ਅਤੇ ਕਿਨ੍ਹਾ ਤੇਲ-ਕੇਸਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੀਆਂ ਹਨ। ਜਦੋਂ ਇਹਨਾਂ ਵਿਚੋਂ ਕੋਈ ਘੱਟ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਉਪਭੋਗਤਾ ਅਨੁਮਾਨ ਕਰਦਾ ਹੈ—ਅਤੇ ਅਨੁਮਾਨ ਹੀ Bugs ਦਾ ਗੜ੍ਹਾ ਹੈ।
ਜਦੋਂ ਤੁਸੀਂ ਕਿਸੇ ਪ੍ਰਕਿਰਿਆ (ਕੋਡ ਹੋਵੇ ਜਾਂ ਨਹੀਂ) ਦੀ ਦਸਤਾਵੇਜ਼ੀਕਰਨ ਕਰਦੇ ਹੋ, ਤਾਂ ਇਸ ਤਰ੍ਹਾਂ ਲਿਖੋ ਜਿਵੇਂ ਕੋਈ ਹੋਰ ਇਸਨੂੰ ਤੁਹਾਡੇ ਬਿਨਾਂ ਦੁਹਰਾਏਗਾ:\n\n- ਇਨਪੁਟ ਅਤੇ ਆਉਟਪੁਟ ਬਿਆਨ ਕਰੋ ਸਧਾਰਨ ਜ਼ਬਾਨ ਵਿੱਚ ("ਦਿੱਤੇ X ਤੋਂ Y ਉਤਪੰਨ ਕਰੋ")\n- ਧਾਰਨਾਵਾਂ ਲਿਖੋ (ਯੂਨਿਟ, ਕ੍ਰਮ, ਰਾਉਂਡਿੰਗ ਨਿਯਮ)\n- ਕਦਮਾਂ ਨੂੰ ਨੰਬਰਵਾਰ ਲਿਖੋ ਜਾਂ ਇਕ ਛੋਟੇ ਟੇਬਲ ਵਿੱਚ ਰਾਜ ਕਰੋ\n- ਦਰਮਿਆਨੀ ਮੁੱਲਾਂ ਨੂੰ ਨਾਂ ਦਿਓ ਅਤੇ ਨਾਂ ਸੰਗਤ ਰੱਖੋ\n- ਇਕ ਛੋਟਾ ਕੰਮ ਕੀਤਾ ਉਦਾਹਰਨ ਸ਼ਾਮਲ ਕਰੋ ਜੋ ਕੋਈ ਹੱਥ-ਹੱਥ ਚੈੱਕ ਕਰ ਸਕੇ
ਇਹ ਵਧੇਰੇ ਕੰਮ ਨਹੀਂ—ਇਹ ਉਹੀ ਤਰੀਕਾ ਹੈ ਜਿਸ ਨਾਲ ਇੱਕ ਵਿਧੀ ਦੁਬਾਰਾ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ।
ਅਡਾ ਲਵਲੇਸ ਨੂੰ ਅਕਸਰ ਇੱਕ ਨਮੂਨੇ ਰੂਪ ਵਿੱਚ "ਪਹਿਲੀ ਪ੍ਰੋਗ੍ਰਾਮਰ" ਦੇ ਟੈਗ ਨਾਲ ਪੇਸ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਇੱਕ ਸਹੀ ਸਰਲ-ਸੰਕੇਤ ਹੋ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਗਲਤੀਆਂ ਨੂੰ ਵੀ ਸਧਾ ਨਹੀਂ ਕਰਦਾ। ਵਾਦ-ਵਿਵਾਦ ਸਿਰਫ਼ ਮਾਣ-ਸਥਾਨ ਦਾ ਨਹੀਂ—ਇਹ ਇਸ 'ਤੇ ਹੈ ਕਿ ਅਸੀਂ "ਪ੍ਰੋਗ੍ਰਾਮ", "ਕੰਪਿਊਟਰ" ਅਤੇ "ਰਚਨ" ਤੋਂ ਕੀ ਅਰਥ ਲੈਂਦੇ ਹਾਂ।
ਜੇ "ਪ੍ਰੋਗ੍ਰਾਮਰ" ਦਾ ਮਤਲਬ ਹੈ ਕੋਈ ਜਿਸਨੇ ਇੱਕ general-purpose ਮਸ਼ੀਨ ਲਈ ਹਦਾਇਤਾਂ ਲਿਖੀਆਂ, ਤਾਂ Lovelace ਦਾ ਦਾਅਵਾ ਮਜ਼ਬੂਤ ਹੈ। ਉਸ ਦੀਆਂ Notes ਵਿੱਚ ਉਸਨੇ ਬੇਰਨੌਲੀ ਨੰਬਰ ਰਾਹੀਂ ਇੱਕ ਕਦਮ-ਦਰ-ਕਦਮ ਵਿਧੀ ਦਰਸਾਈ—ਅਸਲ ਵਿੱਚ ਇੱਕ ਯੋਜਨਾ ਕਿ Engine ਕਿਸ ਤਰ੍ਹਾਂ ਇਕ ਗੈਰ-ਤ੍ਰਿਵਿਆਨ ਗਣਨਾ ਕਰ ਸਕਦੀ ਹੈ।
ਪਰ ਇਤਿਹਾਸਕਾਰ ਇਸ ਲੇਬਲ 'ਤੇ ਵਾਦ ਕਰਦੇ ਹਨ ਕਿਉਂਕਿ:\n\n- Analytical Engine ਪੂਰਾ ਨਹੀਂ ਹੋਇਆ, ਇਸ ਲਈ ਪ੍ਰੋਗ੍ਰਾਮ ਫੌਰ ਰੂਪ ਵਿੱਚ ਚਲਾਕੇ ਆਜ਼ਮਾਇਆ ਨਹੀਂ ਜਾ ਸਕਿਆ।\n- ਕਈ ਹਿੱਸੇ ਸਹਿਯੋਗੀ ਕੰਮ (ਖਾਸ ਕਰਕੇ Babbage) ਦੇ ਪ੍ਰੇਰਕ ਹੋ ਸਕਦੇ ਹਨ।\n- ਪਹਿਲਾਂ ਵੀ ਕੁਝ ਆਟੋਮੇਟਿਕ ਕੈਲਕੁਲੇਸ਼ਨ ਸੀ, ਪਰ ਉਹ ਇਸ ਜਨਰਲ-ਪਰਪਜ਼ ਅਰਥ ਵਿੱਚ ਠੀਕ ਨਹੀਂ ਬੈਠਦੇ।
ਇਹ ਗੱਲ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ "ਕੰਪਿਊਟਿੰਗ ਵਿਚਾਰ ਦੀ ਖੋਜ" ਅਤੇ "ਚਲਦੀ ਹੋਈ ਮਸ਼ੀਨ ਬਣਾਉਣਾ" ਵਿੱਚ ਫਰਕ ਹੈ। Babbage ਦੀ ਵੱਡੀ ਯੋਗਦਾਨ ਆਰਕੀਟੈਕਚਰ ਸੀ: ਇੱਕ ਪ੍ਰਸਤਾਵਿਤ ਮਸ਼ੀਨ ਜਿਸ ਵਿੱਚ store, mill ਅਤੇ ਪੰਚਡ ਕਾਰਡ ਰਾਹੀਂ ਨਿਯੰਤਰਣ ਸੀ। Lovelace ਦੀ ਯੋਗਦਾਨ ਵਿਆਖਿਆਤਮਕ ਅਤੇ ਪ੍ਰਗਟਨਾਤਮਕ ਸੀ: ਉਸਨੇ ਦਰਸਾਇਆ ਕਿ ਅਜਿਹੀ ਮਸ਼ੀਨ ਕੀ ਦਰਸਾ ਸਕਦੀ ਹੈ ਅਤੇ ਕਿਸ ਤਰ੍ਹਾਂ ਵਿਧੀ ਲਿੱਖੀ ਜਾ ਸਕਦੀ ਹੈ।
ਇੱਕ ਪ੍ਰੋਗ੍ਰਾਮ ਉਹਨਾਂ ਦਾ ਪ੍ਰੋਗ੍ਰਾਮ ਹੀ ਰਹਿੰਦਾ ਹੈ ਭਾਵੇਂ ਹਾਰਡਵੇਅਰ ਤਿਆਰ ਨਾ ਹੋਵੇ—ਇਹ ਉਸੇ ਤਰ੍ਹਾਂ ਹੈ ਜਿਵੇਂ ਅਸੀਂ ਕਿਸੇ ਅਧਾਰ 'ਤੇ ਸੁਫਟਵੇਅਰ ਲਿਖਦੇ ਹਾਂ ਜਦੋਂ ਚਿੱਪ ਅਜੇ ਤਿਆਰ ਨਾ ਹੋਵੇ।
ਇਸ ਦੌਰ ਨੂੰ ਇਕ ਸਹਿਯੋਗੀ ਯੁੱਗ ਵਜੋਂ ਵੇਖਣਾ ਹੀ ਸਭ ਤੋਂ ਮਦਦਗਾਰ ਰਸਤਾ ਹੈ:
ਜੋ ਗੱਲ ਅਸੀਂ ਯਕੀਨੀ ਤੌਰ 'ਤੇ ਕਹਿ ਸਕਦੇ ਹਾਂ: Lovelace ਦੀਆਂ Notes ਨੇ ਇਹ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕੀਤੀ ਕਿ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਕੀ ਹੈ—ਸਿਰਫ਼ ਗਣਨਾ ਨਹੀਂ, ਬਲਕਿ ਕ੍ਰਮਾਂ ਦੀ ਸੂਚੀ ਜੋ ਮਸ਼ੀਨ ਅਨੁਸਾਰ ਚੱਲ ਸਕੇ।
Lovelace ਦੀਆਂ Notes ਇਸ ਲਈ ਅਹੰਕਾਰਪੂਰਕ ਨਹੀਂ ਕਿ ਉਹ ਉਤਪਾਤਕ ਯੂਜ਼ ਤਕਨੀਕ ਦਿਖਾਉਂਦੀਆਂ—ਬਲਕਿ ਉਹ ਇਸ ਲਈ ਅਹੰਕਾਰਪੂਰਕ ਹਨ ਕਿਉਂਕਿ ਉਹ ਦਿਖਾਉਂਦੀਆਂ ਹਨ ਕਿ ਕਿਸ ਤਰ੍ਹਾਂ ਇੱਕ ਵਿਚਾਰ ਨੂੰ ਮਸ਼ੀਨ-ਚਲਾਏ ਜਾਣਯੋਗ ਯੋਜਨਾ ਵਿੱਚ ਬਦਲਣਾ ਹੈ। ਚਾਹੇ ਤੁਸੀਂ ਕਦੇ ਪੰਚਡ ਕਾਰਡ ਨੂੰ ਨਾ ਛੂਹੋ, ਮੁੱਖ ਸਬਕ ਅਜੇ ਵੀ ਅਜੋਕੇ ਪ੍ਰੋਗ੍ਰਾਮ ਡਿਜ਼ਾਈਨ ਨਾਲ ਗੂੰਥੇ ਹੋਏ ਹਨ: ਕੰਮ ਨੂੰ ਸਪਸ਼ਟ ਢਾਂਚਾ ਦਿਓ, ਚੀਜ਼ਾਂ ਨੂੰ ਨਾਮ ਦਿਓ, ਦੋਹਰਾਉ ਦੀ ਰਣਨੀਤੀ ਬਣਾਓ, ਅਤੇ ਦੁਬਾਰਾ ਵਰਤੋਂਯੋਗ ਹਿੱਸੇ ਬਣਾਓ।
ਢਾਂਚਾ ਚਲਾਕੀ ਉੱਤੇ ਭਾਰੀ। ਜਦੋਂ ਕੰਮ ਨੂੰ ਐਸੇ ਕਿਸੇ ਵੀ ਤਰੀਕੇ ਨਾਲ ਟੁਕੜਿਆਂ 'ਚ ਤਬਦੀਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਦਾ ਸਾਫ਼ ਮਕਸਦ ਹੋਵੇ, ਤਾਂ ਪ੍ਰੋਗ੍ਰਾਮ ਬਣਾਉਣਾ ਤੇ ਸੰਭਾਲਣਾ ਆਸਾਨ ਹੁੰਦਾ ਹੈ। Lovelace ਦੀ ਕੁਸ਼ਲਤਾ ਤੁਹਾਨੂੰ ਵਿਸਥਾਰ ਤੋਂ ਪਹਿਲਾਂ ਹੱਲ ਦੀ ਸ਼ਕਲ ਡਿਜ਼ਾਈਨ ਕਰਨ ਲਈ ਪ੍ਰੇਰਿਤ ਕਰਦੀ ਹੈ।
ਸਪਸ਼ਟਤਾ ਇੱਕ ਫੀਚਰ ਹੈ। ਉਸ ਦੀਆਂ ਟੇਬਲਾਂ ਅਤੇ ਵਿਆਖਿਆਵਾਂ ਸਜਾਵਟ ਨਹੀਂ—ਉਹ ਪ੍ਰੋਗ੍ਰਾਮ ਦਾ हिस्सा ਹਨ। ਜੇ ਭਵਿੱਖ-ਤੁਸੀ (ਜਾਂ ਟੀਮ ਮੈਂਬਰ) ਤੁਰੰਤ ਤਰਕ ਸਮਝ ਸਕਦੇ ਹਨ, ਤਾਂ ਪ੍ਰੋਗ੍ਰਾਮ ਭਰੋਸੇਯੋਗ ਬਣ ਜਾਂਦਾ ਹੈ।
ਇਟਰੇਸ਼ਨ ਇਕ ਸੰਦ ਹੈ, ਚਾਲ trick ਨਹੀਂ। ਦੁਹਰਾਉ (ਲੂਪ) ਇੱਕ ਢੰਗ ਹੈ ਵਿਧੀ ਨੂੰ ਵਿਆਪਕ ਕਰਨ ਦਾ। ਮੁੱਖ ਗੱਲ ਇਹ ਹੈ ਕਿ ਕੀ ਦੁਹਰਾਇਆ ਜਾਂਦਾ ਹੈ, ਹਰ ਵਾਰੀ ਕੀ ਬਦਲਦਾ ਹੈ, ਅਤੇ ਕਦੋਂ ਰੁਕਣਾ ਹੈ।
ਅਬਸਟ੍ਰੈਕਸ਼ਨ ਦੁਬਾਰਾ ਵਰਤੋਂ ਯੋਗ ਬਣਾਉਂਦੀ ਹੈ। ਜੇ ਕਿਸੇ ਕਦਮ ਦੀ ਲੜੀ ਇਕ ਵਾਰੀ ਕੰਮ ਕਰਦੀ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਉਸ ਨੂੰ ਵੱਖ ਵੱਖ ਇਨਪੁਟਸ ਨਾਲ ਦੁਬਾਰਾ ਵਰਤ ਸਕਦੇ ਹੋ। ਇਹ ਫੰਕਸ਼ਨਾਂ, ਮੋਡਿਊਲਾਂ, ਲਾਇਬ੍ਰੇਰੀਜ਼ ਦੀ ਸ਼ੁਰੂਆਤ ਹੈ।
ਜੇ ਤੁਸੀਂ ਕਦੇ "ਵੇਰਣ ਦੇ ਕੇ ਤਿਆਰ ਕਰੋ" ਵਰਗੇ ਵਰਕਫਲੋ ਵਰਤੇ ਹਨ—ਜਿੱਥੇ ਪਹਿਲਾਂ ਲੋੜਾਂ ਲਿਖੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਯੋਜਨਾ 'ਤੇ ਵਿਆਪਕ ਸੋਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਫਿਰ ਕੰਮ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ—ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ Lovelace ਦੀਆਂ Notes ਦੀ ਰੂਹ ਨੂੰ ਦੁਹਰਾ ਰਹੇ ਹੋ। ਪ੍ਰਕਿਰਿਆ ਸਪਸ਼ਟ ਬਣਾਓ, ਸਟੇਟ ਰੱਖਣ ਵਾਲੀਆਂ ਚੀਜ਼ਾਂ ਸਾਫ਼ ਰੱਖੋ, ਅਤੇ ਅੰਦਾਜ਼ਾ-ਪੂਰਕ ਰੂਪ ਵਿੱਚ ਪਹਿਲਾਂ ਨੋਟ ਕਰੋ ਤਾਂਕਿ ਜਨਰੇਸ਼ਨ ਜਾਂ ਬਦਲਾਅ ਤੋਂ ਪਹਿਲਾਂ ਨੋਟ ਲਾਕ ਹੋ ਜਾਵੇ।
ਇਸੇ ਕਾਰਨ vibe-coding ਪਲੇਟਫਾਰਮਾਂ ਜਿਵੇਂ Koder.ai ਇਸ ਕਹਾਣੀ ਵਿੱਚ ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ ਆਉਂਦੀਆਂ ਹਨ। Koder.ai ਤੁਹਾਨੂੰ web, backend, ਅਤੇ mobile ਐਪਸ chat ਇੰਟਰਫੇਸ ਰਾਹੀਂ ਬਣਾਉਣ ਦਿੰਦੀ ਹੈ, ਪਰ ਇੱਕੋ ਹੀ ਮੁਢਲਾ ਅਸੂਲ ਲਾਗੂ ਹੁੰਦਾ ਹੈ: ਤੁਸੀਂ ਬਿਹਤਰ ਨਤੀਜੇ ਤਦ ਹੀ ਪਾਉਂਦੇ ਹੋ ਜਦੋਂ ਤੁਸੀਂ ਇਨਪੁਟ/ਆਉਟਪੁਟ, ਨਾਂ ਰੱਖਣਾ, ਅਤੇ ਕਦਮ-ਦਰ-ਕਦਮ ਸੰਰਚਨਾ ਨੂੰ ਸਪਸ਼ਟ ਕਰਦੇ ਹੋ (Planning Mode ਤੁਹਾਡੇ “Notes” ਨੂੰ ਜਨਰੇਸ਼ਨ ਤੋਂ ਪਹਿਲਾਂ ਲਾਕ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ)। ਟੂਲ ਨਵਾਂ ਹੈ; ਅਨੁਸ਼ਾਸਨ ਨਵਾਂ ਨਹੀਂ।
ਕੋਡ ਲਿਖਣ ਤੋਂ ਪਹਿਲਾਂ—ਜਾਂ ਜਦੋਂ ਕੁਝ ਗੁੰਝਲਦਾਰ ਮਹਿਸੂਸ ਹੋ ਰਿਹਾ ਹੋ—ਇਸ ਤੇਜ਼ ਪਾਸ ਦੀ ਵਰਤੋਂ ਕਰੋ:\n\n1. ਮਕਸਦ: ਕੀ ਤੁਸੀਂ ਇੱਕ ਵਾਕ ਵਿੱਚ ਕਹਿ ਸਕਦੇ ਹੋ ਕਿ ਪ੍ਰੋਗ੍ਰਾਮ ਕੀ ਉਤਪਾਦਨ ਕਰੇਗਾ?\n2. ਇਨਪੁਟ/ਆਉਟਪੁਟ: ਕੀ ਜਾਂਦਾ ਹੈ, ਕੀ ਆਉਂਦਾ ਹੈ, ਅਤੇ ਕਿਸ ਫਾਰਮੈਟ ਵਿੱਚ?\n3. ਡਿਕੰਪੋਜ਼: 3–7 ਮੁੱਖ ਕਦਮ ਕਿਹੜੇ ਹਨ? (ਜੇ 20 ਹੋਣ ਤਾਂ ਉਨ੍ਹਾਂ ਨੂੰ ਗਰੁੱਪ ਕਰੋ)\n4. ਨਾਂ ਰੱਖੋ: ਮੁੱਖ ਮੁੱਲਾਂ ਨੂੰ ਦੀਆਂ ਇੱਕੋ ਜਿਹੀਆਂ ਨਾਂ ਦਿਓ।\n5. ਦુਹਰਾਉ ਖੋਜੋ: ਕਿਹੜਾ ਕਦਮ ਦੁਹਰਾਇਆ ਜਾਂਦਾ ਹੈ? ਹਰ ਵਾਰੀ ਕੀ ਬਦਲਦਾ ਹੈ?\n6. ਰੋਕਣ ਦੀ ਸ਼ਰਤ: ਹਰ ਲੂਪ ਜਾਂ ਪ੍ਰਕਿਰਿਆ ਕਿਵੇਂ ਖਤਮ ਹੁੰਦੀ ਹੈ? ਅਨੰਤ ਕੰਮ ਕਿਵੇਂ ਰੋਕਦੇ ਹੋ?\n7. ਦੁਬਾਰਾ ਵਰਤੋਂਯੋਗ ਬਲਾਕ: ਕਿਹੜੇ ਕਦਮ ਕਿਸੇ ਹੋਰ ਥਾਂ ਫੰਕਸ਼ਨ ਬਣ ਸਕਦੇ ਹਨ?\n8. ਵਰਣਨ ਕਰੋ: ਕੀ ਕੋਈ ਪਾਠਕ ਤੁਹਾਡੇ ਟਿੱਪਣੀਆਂ ਜਾਂ ਡੋਕਸ ਦੇ ਆਧਾਰ 'ਤੇ ਯੋਜਨਾ ਸਮਝ ਸਕਦਾ ਹੈ?
ਜੇ ਤੁਸੀਂ “Notes-first” ਸ਼ੈਲੀ ਨੂੰ ਮਜ਼ਬੂਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ ਇਹ ਮਦਦਗਾਰ ਹੋਵੇਗਾ:\n\n- /blog/how-to-write-better-requirements\n- /blog/pseudocode-examples\n\nਇਹ ਆਦਤਾਂ ਮਿਲ ਕੇ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਨੂੰ “ਚੱਲਣਯੋਗ ਬਣਾਓ” ਤੋਂ “ਸਮਝਉਣਯੋਗ ਬਣਾਓ” ਵਿੱਚ ਤਬਦੀਲ ਕਰਦੀਆਂ ਹਨ—ਉਹੀ ਬਦਲਾਅ ਜਿਸ ਵੱਲ Lovelace ਦੀਆਂ Notes ਪਹਿਲਾਂ ਹੀ ਇਸ਼ਾਰੇ ਕਰ ਰਹੀਆਂ ਸਨ।
ਅਡਾ ਲਵਲੇਸ ਦੀ “ਪਹਿਲੀ算法” ਉਸ ਰਸਟੀਪ ਦੀ ਤਰ੍ਹਾਂ ਹੈ ਜੋ ਉਸ ਨੇ ਆਪਣੇ Notes ਵਿੱਚ ਦਿੱਤੀ—ਉਹ ਹਦਾਇਤਾਂ ਜਿਹੜੀਆਂ Charles Babbage ਦੇ Analytical Engine ਵੱਲੋਂ ਚਲਾਈ ਜਾ ਸਕਦੀਆਂ ਸਨ। ਇਹ ਇਸ ਲਈ ਮਸ਼ਹੂਰ ਹੈ ਕਿਉਂਕਿ ਇਹ ਗਣਨਾ ਨੂੰ ਸਟੋਰ ਕੀਤੀਆਂ ਕੀਮਤਾਂ 'ਤੇ ਨਿਰਧਾਰਤ ਕਦਮਾਂ ਦੀ ਯੋਜਨਾ ਵਜੋਂ ਵੇਖਦੀ ਹੈ—ਇਹ ਅਜਮਾਨੇ ਬਾਵਜੂਦ ਅਧੁਨਿਕ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਨਾਲ ਬਹੁਤ ਮੇਲ ਖਾਂਦੀ ਹੈ।
ਇਹ ਲੇਖ Lovelace ਦੇ ਕੰਮ ਵਿੱਚ ਮੌਜੂਦ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਵਿਚਾਰਾਂ ਤੇ ਧਿਆਨ ਕੇਂਦ੍ਰਿਤ ਕਰਦਾ ਹੈ—ਕਿਵੇਂ ਇੱਕ ਢੰਗ ਨੂੰ ਐਸੀ ਰੀਤ ਨਾਲ ਲਿਖਿਆ ਜਾਵੇ ਕਿ ਉਹ ਕਰਨਯੋਗ, ਜਾਂਚਯੋਗ ਅਤੇ ਸਮਝਯੋਗ ਹੋਵੇ—ਨ ਕਿ Engine ਦੀ ਮਕੈਨਿਕਲ ਰੀਕਨਸਟਰੱਕਸ਼ਨ ਜਾਂ ਹਰ ਇਤਿਹਾਸਕ ਦਾਅਵਿਆਂ ਦਾ ਨਿਰਣੇਸ਼ ਕਰਨ ਲਈ।
Analytical Engine ਇੱਕ ਸੁਝਾਇਆ ਗਿਆ general-purpose ਮਸ਼ੀਨ ਸੀ ਜਿਸਦਾ ਮਕਸਦ ਸੀ:
ਇਹ ਵੱਖ-ਵੱਖ ਭਾਗਾਂ ਨੇ ਕਿਸੇ ਮਸ਼ੀਨ ਦਾ ਚਲਾਉਣ (ਹਾਰਡਵੇਅਰ) ਅਤੇ ਕਦਮਾਂ ਦੀ ਵਿਆਖਿਆ (ਪ੍ਰੋਗਰਾਮ) ਨੂੰ ਅਲੱਗ ਕਰ ਦਿੱਤਾ—ਉਹੀ ਵੰਡ ਜਿਹੜੀ ਅਧੁਨਿਕ ਕੰਪਿਊਟਰਾਂ 'ਚ ਹੈ।
ਬੇਰਨੌਲੀ ਨੰਬਰ ਉਸੇ ਤਰ੍ਹਾਂ ਦੇ ਇੱਕ ਕ੍ਰਮ ਹਨ ਜੋ ਗਣਿਤ ਦੇ ਕਈ ਹਿੱਸਿਆਂ ਵਿੱਚ ਆਉਂਦੇ ਹਨ। ਉਹ ਚੰਗਾ ਉਦਾਹਰਨ ਇਸ ਲਈ ਹਨ ਕਿ:
ਇਹ ਗਿਣਤੀ ਮਸ਼ੀਨ 'ਤੇ ਇੱਕ ਬਣਾਈ ਹੋਈ ਵਿਧੀ ਦੀ ਜਾਂਚ ਲਈ ਪਰਯਾਪਤ ਪੇਚੀਦਾ ਪਰ ਲਿਖਣਯੋਗ ਰੂਪ ਵਿੱਚ ਹੈ।
ਇੱਕ ਕਦਮ-ਟੇਬਲ ਤੁਹਾਨੂੰ ਇਹ ਗੱਲਾਂ ਨਿਰਧਾਰਤ ਕਰਨ 'ਤੇ ਮਜ਼ਬੂਰ ਕਰਦੀ ਹੈ:
ਇਹੀ Precision ਅਸਲ ਵਿੱਚ ਆਧੁਨਿਕ ਪਿਊਡੋ ਕੋਡ ਵਾਂਗ ਹੈ ਜੋ ਦੂਜੇ ਪਾਠਕ ਨੂੰ ਬਿਨਾਂ ਅਨੁਮਾਨ ਲਾਏ ਕਾਰਵਾਈ ਕਰਨ ਦੀ ਯੋਗਤਾ ਦਿੰਦਾ ਹੈ।
ਰਿਪੀਟੀਸ਼ਨ ਦਾ ਸੀਧਾ ਅਰਥ ਇਤਰਾਰ: ਇੱਕ ਛੋਟੀ ਵਿਧੀ ਨੂੰ ਦੁਹਰਾਉ, ਜਾਂਚੋ ਕਿ ਕੀ ਖਤਮ ਹੋ ਗਿਆ, ਅਤੇ ਜੇ ਨਹੀਂ ਤਾਂ ਉਸੇ ਵਿਧੀ ਨੂੰ ਦੁਬਾਰਾ ਚਲਾਓ। ਇਕ ਕੁੰਜੀ ਗੱਲ ਇਹ ਹੈ ਕਿ ਹਰ ਵਾਰ ਕੁਝ ਬਦਲਦਾ ਹੈ—ਜਿਵੇਂ ਗਿਣਤੀ ਜਾਂ ਅਧੂਰਾ ਨਤੀਜਾ—ਤਾਕਿ ਪ੍ਰੋਗਰਾਮ ਅਗਲੇ ਕਦਮ ਵੱਲ ਵਧੇ।
ਅਜੋਕੇ ਕੋਡ ਵਿੱਚ ਇਹ for ਜਾਂ while ਲੂਪ ਵਾਂਗ ਹੁੰਦਾ ਹੈ: ਇੱਕ ਕਾਊੰਟਰ, ਇੱਕ ਬਦਲਦੀ ਹੋਈ ਕੀਮਤ, ਅਤੇ ਇੱਕ ਰੋਕਣ ਦੀ ਸ਼ਰਤ।
ਕਿਸੇ ਵੀ ਵਿਧੀ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਮਾਤਰਾਵਾਂ ਦੀ ਸੂਚਨਾ ਲਈ ਸਪੱਸ਼ਟ ਤਰੀਕੇ ਹੋਣੇ ਲਾਜ਼ਮੀ ਹਨ—ਇਹੋ ਜਿੱਥੇ ਵੈਰੀਏਬਲ ਅਤੇ ਨੋਟੇਸ਼ਨ ਕੰਮ ਆਉਂਦੇ ਹਨ।
ਵੈਰੀਏਬਲ ਇਕ ਲੇਬਲ ਕੀਤਾ ਹੋਇਆ ਡੱਬਾ ਸਮਝੋ: ਨਾਂ ਪੱਕਾ ਰਹਿੰਦਾ ਹੈ, ਪਰ ਅੰਦਰ ਰਿਹਾ ਮੂੱਲ ਬਦਲ ਸਕਦਾ ਹੈ। ਸਾਫ਼ ਨਾਂ-ਹੀਣੇ (ਜਿਵੇਂ current_sum, term_index) ਬਹੁਤ ਜ਼ਿਆਦਾ ਮਦਦਗਾਰ ਹੁੰਦੇ ਹਨ।
ਇਹਨਾਂ ਨੋਟੇਸ਼ਨਾਂ ਨਾਲ ਹੀ ਇੱਕ ਮਨੁੱਖੀ ਵਿਚਾਰ ਨੂੰ ਮਸ਼ੀਨ-ਚਲਾਏ ਜਾਣਯੋਗ ਕਦਮਾਂ ਵਿੱਚ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ।
ਅਬਸਟ੍ਰੈਕਸ਼ਨ ਦਾ ਮਤਲਬ ਹੈ ਜਰੂਰੀ ਗੱਲ 'ਤੇ ਧਿਆਨ ਦੇਣਾ ਅਤੇ ਉਹਨਾਂ ਛੋਟੀਆਂ ਵਿਵਰਣਾਂ ਨੂੰ ਲੁਕਾਉਣਾ ਜੋ ਹਮੇਸ਼ਾ ਲੋੜੀਂਦੇ ਨਹੀਂ। Lovelace ਦੀਆਂ Notes ਇਹ ਦਿਖਾਉਂਦੀਆਂ ਹਨ ਕਿ ਵਿਧੀ (algorithm) ਨੂੰ ਮਸ਼ੀਨ ਦਿਆਂ ਮਕੈਨਿਕਸ ਤੋਂ ਵੱਖ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ—ਇਕੋ ਜਿਹੀ ਵਿਧੀ ਵੱਖ-ਵੱਖ ਹਾਰਡਵੇਅਰ 'ਤੇ ਦੁਬਾਰਾ ਲਾਗੂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।
ਇਹੀ ਦਾਰੂਨ ਹੈ ਕਿ ਅਜੋਕੇ ਫੰਕਸ਼ਨ ਤੇ ਮੋਢਿਊਲਜ਼ ਕਿਵੇਂ ਬਣਦੇ ਹਨ: ਇਕ ਵਾਰ ਤਿਆਰ ਕੀਤੀ ਵਿਧੀ ਨਾਂ ਰੱਖੋ, ਇਨਪੁਟ ਲਵੋ, ਨਤੀਜਾ ਦਿਓ, ਅਤੇ ਅੰਦਰਲੀ ਵਿਸਥਾਰ ਲੁਕਾਓ।
ਲੋਵਲੇਸ ਨੂੰ ਆਮ ਤੌਰ 'ਤੇ “ਪਹਿਲੀ ਪ੍ਰੋਗ੍ਰਾਮਰ” ਕਹਿਣਾ ਆਸਾਨ ਸਰਲ-ਸੰਕੇਤ ਹੈ, ਪਰ ਇਹ ਵਿਰੋਧਾਂ ਨੂੰ ਘਟਾ ਨਹੀਂ ਕਰਦਾ। ਲੋਗ ਮੁੱਖ ਤੌਰ 'ਤੇ ਇਸ ਲਈ ਤਕਰਾਰ ਕਰਦੇ ਹਨ ਕਿਉਂਕਿ:
ਇੱਕ ਸੁਧਾਰਤ ਨਿਸ਼ਕਰਸ਼ ਇਹ ਹੈ ਕਿ Lovelace ਦੀਆਂ Notes ਨੇ ਇਸ ਗੱਲ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕੀਤੀ ਕਿ “ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ” ਕੀ ਹੈ—ਸਿਰਫ ਗਣਨਾ ਨਹੀਂ, ਬਲਕਿ ਸਪੱਸ਼ਟ ਵਿਧੀ ਜੋ ਮਸ਼ੀਨ ਅਨੁਸਾਰ ਚਲ ਸਕਦੀ ਹੈ।
ਇੱਕ ਸਧਾਰਨ ਡਿਜ਼ਾਈਨ ਚੈਕਲਿਸਟ ਜੋ ਤੁਸੀਂ ਕੋਡ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਵਰਤ ਸਕਦੇ ਹੋ:
For related guides, see /blog/how-to-write-better-requirements and /blog/pseudocode-examples.
