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

ਅਜਿਹਾ ਇਸ ਲਈ ਹੁੰਦਾ ਹੈ ਕਿਉਂਕਿ ਵੱਡੇ ਭਾਸ਼ਾ ਮਾਡਲ ਸੰਖਿਆਵਾਂ ਬਾਰੇ ਉਸ ਤਰ੍ਹਾਂ ਤਰਕ ਨਹੀਂ ਕਰਦੇ ਜਿਵੇਂ ਇਨਸਾਨ ਕਰਦੇ ਹਨ। ਉਹ ਟੋਕਨ (tokens) ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਦੇ ਹਨ। ਇੱਕ ਟੋਕਨ ਇੱਕ ਪੂਰਾ ਸ਼ਬਦ, ਸ਼ਬਦ ਦਾ ਹਿੱਸਾ, ਜਾਂ ਇੱਕ ਸਿੰਗਲ ਅੰਕ ਹੋ ਸਕਦਾ ਹੈ। ਜਦੋਂ ਮਾਡਲ “strawberry” ਦੇਖਦਾ ਹੈ, ਤਾਂ ਉਹ ਅੱਠ ਅਲੱਗ-ਅਲੱਗ ਅੱਖਰਾਂ ਨੂੰ ਇੱਕ ਲਾਈਨ ਵਿੱਚ ਨਹੀਂ ਦੇਖਦਾ। ਉਹ ਕੁਝ ਟੁਕੜੇ (chunks) ਦੇਖਦਾ ਹੈ। ਉਸਨੂੰ ਅੱਖਰਾਂ ਨੂੰ ਗਿਣਨਾ ਨਹੀਂ ਸਿਖਾਇਆ ਗਿਆ, ਸਿਰਫ਼ ਇਹ ਭਵਿੱਖਬਾਣੀ ਕਰਨੀ ਸਿਖਾਈ ਗਈ ਹੈ ਕਿ ਅਗਲਾ ਟੈਕਸਟ ਦਾ ਟੁਕੜਾ ਕਿਹੜਾ ਹੋਵੇਗਾ। ਇਹੀ ਸੀਮਾ ਅੰਕਗਣਿਤ 'ਤੇ ਵੀ ਲਾਗੂ ਹੁੰਦੀ ਹੈ। ਮਾਡਲ ਕੋਲ ਕੋਈ ਅੰਦਰੂਨੀ ਕੈਲਕੁਲੇਟਰ ਨਹੀਂ ਹੁੰਦਾ। ਇਸ ਵਿੱਚ ਕੈਰੀ ਲੌਜਿਕ (carry logic) ਦੀ ਕਮੀ ਹੁੰਦੀ ਹੈ। ਇਸ ਕੋਲ ਸਥਾਨਕ ਮੁੱਲ (place value) ਦੀ ਕੋਈ ਅਸਲ ਸਮਝ ਨਹੀਂ ਹੁੰਦੀ। ਜਦੋਂ ਇਹ 148 ਨੂੰ 279 ਨਾਲ ਗੁਣਾ ਕਰਦਾ ਹੈ, ਤਾਂ ਇਹ ਗੁਣਾ ਨਹੀਂ ਕਰ ਰਿਹਾ ਹੁੰਦਾ। ਇਹ ਟ੍ਰੇਨਿੰਗ ਦੌਰਾਨ ਦੇਖੇ ਗਏ ਸਮਾਨ ਪ੍ਰਗਟਾਵਾਂ ਨਾਲ ਪੈਟਰਨ-ਮੈਚਿੰਗ ਕਰ ਰਿਹਾ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਅੰਦਾਜ਼ਾ ਲਗਾ ਰਿਹਾ ਹੁੰਦਾ ਹੈ ਕਿ ਅੰਕਾਂ ਦਾ ਕਿਹੜਾ ਕ੍ਰਮ ਅਗਲਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਛੋਟੀਆਂ ਜੋੜਾਂ ਲਈ ਪੈਟਰਨ ਕੰਮ ਕਰਨ ਲਈ ਕਾਫ਼ੀ ਮਜ਼ਬੂਤ ਹੁੰਦਾ ਹੈ। ਪਰ ਕਿਸੇ ਵੀ ਅਜਿਹੀ ਚੀਜ਼ ਲਈ ਜਿਸ ਵਿੱਚ ਅਸਲ ਸਟੀਕਤਾ ਦੀ ਲੋੜ ਹੋਵੇ, ਅੰਦਾਜ਼ਾ ਅੰਤ ਵਿੱਚ ਗਲਤ ਹੋ ਜਾਂਦਾ ਹੈ।

ਦੋ ਕੰਮ, ਇੱਕ ਬੋਟ

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

ਪ੍ਰੋਗਰਾਮ-ਏਡਡ ਲੈਂਗੂਏਜ ਮਾਡਲਜ਼, ਜਾਂ PAL, ਕੰਮ ਨੂੰ ਵੰਡ ਕੇ ਇਸਦਾ ਹੱਲ ਕਰਦੇ ਹਨ। ਮਾਡਲ ਤੋਂ ਜਵਾਬ ਮੰਗਣ ਦੀ ਬਜਾਏ, ਤੁਸੀਂ ਇਸਨੂੰ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਮੰਗਦੇ ਹੋ।

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

ਅਭਿਆਸ ਵਿੱਚ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਰੀਜ਼ਨਿੰਗ (Executable Reasoning)

PAL ਨੂੰ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਰੀਜ਼ਨਿੰਗ ਵਜੋਂ ਸਮਝੋ। ਜੇਕਰ ਕੋਈ ਸਕ੍ਰਿਪਟ ਕਿਸੇ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰ ਸਕਦੀ ਹੈ, ਤਾਂ ਮਾਡਲ ਨੂੰ ਸਕ੍ਰਿਪਟ ਲਿਖਣ ਦਿਓ।

ਇੱਕ ਖਾਸ ਉਦਾਹਰਣ ਲਓ। ਤੁਹਾਨੂੰ 8.5 ਪ੍ਰਤੀਸ਼ਤ ਦੀ ਸਾਲਾਨਾ ਵਿਆਜ ਦਰ 'ਤੇ, ਤਿਮਾਹੀ ਚੱਕਰਵਰਤੀ (compounded quarterly), ਸੱਤ ਸਾਲਾਂ ਲਈ ਰੱਖੇ ਗਏ ₹50,000 ਦੇ ਫਿਕਸਡ ਡਿਪਾਜ਼ਿਟ 'ਤੇ ਮੈਚਿਓਰਿਟੀ ਰਕਮ ਦੀ ਗਣਨਾ ਕਰਨੀ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਸਿੱਧਾ ਕਿਸੇ ਭਾਸ਼ਾ ਮਾਡਲ ਨੂੰ ਪੁੱਛਦੇ ਹੋ, ਤਾਂ ਇਹ ਇੱਕ ਫਾਰਮੂਲਾ ਲਿਖ ਸਕਦਾ ਹੈ, ਮੁੱਲ ਭਰ ਸਕਦਾ ਹੈ, ਅਤੇ ਚੇਨ ਆਫ ਥੌਟ (chain of thought) ਵਿੱਚ ਨਤੀਜਾ ਕੱਢ ਸਕਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਜੇਕਰ ਤੁਸੀਂ ਧਿਆਨ ਨਾਲ ਦੇਖੋਗੇ, ਤਾਂ ਤੁਹਾਨੂੰ ਪਤਾ ਲੱਗ ਸਕਦਾ ਹੈ ਕਿ ਇਸਨੇ ਦਰ ਨੂੰ ਗਲਤ ਤਰੀਕੇ ਨਾਲ ਵੰਡ ਕੇ ਤਿਮਾਹੀ ਚੱਕਰਵਰਤੀ ਵਿਆਜ ਨੂੰ ਗਲਤ ਸੰਭਾਲਿਆ ਹੈ, ਜਾਂ ਇਸਨੇ ਕਿਸੇ ਵਿਚਕਾਰਲੇ ਕਦਮ ਨੂੰ ਰੌਂਡ (round) ਕਰ ਦਿੱਤਾ ਅਤੇ ਗਲਤੀ ਨੂੰ ਅੱਗੇ ਵਧਾ ਦਿੱਤਾ। ਜਵਾਬ ਵਾਜਬ ਲੱਗਦਾ ਹੈ ਪਰ ਇਹ ਸੈਂਕੜੇ ਰੁਪਏ ਦਾ ਗਲਤ ਹੁੰਦਾ ਹੈ।

PAL ਦੇ ਨਾਲ, ਤਾਲਮੇਲ ਬਦਲ ਜਾਂਦਾ ਹੈ। ਤੁਸੀਂ ਮਾਡਲ ਨੂੰ ਅਜਿਹਾ Python ਕੋਡ ਤਿਆਰ ਕਰਨ ਦਾ ਨਿਰਦੇਸ਼ ਦਿੰਦੇ ਹੋ ਜੋ principal = 50000, rate = 0.085, time = 7, ਅਤੇ n = 4 ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ, ਫਿਰ amount = principal * (1 + rate/n) ** (n * time) ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ। ਮਾਡਲ ਕੋਡ ਜਾਰੀ ਕਰਦਾ ਹੈ। ਇੱਕ Python runtime ਇਸਨੂੰ ਚਲਾਉਂਦਾ ਹੈ। ਤੁਹਾਨੂੰ ਹਰ ਵਾਰ, ਆਖਰੀ ਦਸ਼ਮਲਵ ਤੱਕ, ਬਿਲਕੁਲ ਸਹੀ ਅੰਕ ਮਿਲਦਾ ਹੈ। ਗੁਣਾ ਵਿੱਚ ਕੋਈ ਅੰਦਾਜ਼ਾ ਨਹੀਂ, ਕੋਈ ਭੁਲੇਖੇ ਵਾਲਾ ਬਾਕੀ (remainder) ਨਹੀਂ, ਕੋਈ ਭਰੋਸੇਮੰਦ ਰੌਂਡਿੰਗ ਗਲਤੀ ਨਹੀਂ।

ਇਹੀ ਪੈਟਰਨ ਤਾਰੀਖ ਦੀ ਗਣਨਾ 'ਤੇ ਵੀ ਲਾਗੂ ਹੁੰਦਾ ਹੈ। ਕਿਸੇ ਮਾਡਲ ਨੂੰ ਪੁੱਛੋ ਕਿ ਅੱਜ ਤੋਂ ਬਿਲਕੁਲ 120 ਕਾਰੋਬਾਰੀ ਦਿਨਾਂ ਬਾਅਦ (ਸ਼ਨੀਵਾਰ ਅਤੇ ਐਤਵਾਰ ਨੂੰ ਛੱਡ ਕੇ) ਕਿਹੜੀ ਤਾਰੀਖ ਆਉਂਦੀ ਹੈ। ਇੱਕ ਸਿਰਫ ਟੈਕਸਟ ਵਾਲਾ ਮਾਡਲ ਅੱਗੇ ਗਿਣਨਾ ਸ਼ੁਰੂ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਕਿਸੇ ਸ਼ਨੀਵਾਰ 'ਤੇ ਗਲਤੀ ਕਰ ਸਕਦਾ ਹੈ। PAL ਪਹੁੰਚ ਮਾਡਲ ਨੂੰ datetime ਅਤੇ calendar ਲੌਜਿਕ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਸਕ੍ਰਿਪਟ ਲਿਖਣ ਲਈ ਕਹਿੰਦੀ ਹੈ, ਫਿਰ ਇੰਟਰਪ੍ਰੇਟਰ ਨੂੰ ਬਿਲਕੁਲ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਚਲਾਉਣ ਦਿੰਦੀ ਹੈ। ਡੇਟਾ ਮੈਨੀਪੂਲੇਸ਼ਨ ਵੀ ਇਸੇ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦੀ ਹੈ। ਜੇਕਰ ਤੁਹਾਨੂੰ ਕਿਸੇ ਗੁੰਝਲਦਾਰ CSV ਨੂੰ ਪਾਰਸ ਕਰਨ ਦੀ, ਨੇਸਟਡ JSON ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਦੀ, ਜਾਂ ਤੇਜ਼ ਅੰਕੜਾ ਵਿਗਿਆਨਕ ਤਬਦੀਲੀ (statistical

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

Verifiability. ਜਦੋਂ ਕੋਡ ਮਾਡਲ ਤੁਹਾਨੂੰ ਤਰਕ ਦੇ ਤਿੰਨ ਪੈਰੇ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਇੱਕ ਗਲਤ ਨੰਬਰ ਲੱਭਣ ਲਈ ਹਰ ਵਾਕ ਨੂੰ ਪੜ੍ਹਨਾ ਪੈਂਦਾ ਹੈ। ਜਦੋਂ ਇਹ ਤੁਹਾਨੂੰ ਦਸ-ਲਾਈਨਾਂ ਦਾ ਸਕ੍ਰਿਪਟ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਕੋਡ ਦੀ ਸਮੀਖਿਆ ਕਰ ਸਕਦੇ ਹੋ। ਤੁਸੀਂ ਇੰਟਰਪ੍ਰੀਟਰ ਦੁਆਰਾ ਚਲਾਏ ਜਾਣ ਤੋਂ ਪਹਿਲਾਂ ਇਹ ਪੁਸ਼ਟੀ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਕੰਪਾਊਂਡ-ਇੰਟਰੈਸਟ ਫਾਰਮੂਲਾ ਸਹੀ ਹੈ। ਤੁਸੀਂ ਵੇਰੀਏਬਲ ਦੇ ਨਾਮਾਂ ਦੀ ਜਾਂਚ ਕਰ ਸਕਦੇ ਹੋ, off-by-one ਗਲਤੀਆਂ ਨੂੰ ਫੜ ਸਕਦੇ ਹੋ, ਅਤੇ ਇੱਥੋਂ ਤੱਕ ਕਿ ਹੱਲ ਦਾ version-control ਵੀ ਕਰ ਸਕਦੇ ਹੋ। ਛੁਪੀਆਂ ਗਲਤੀਆਂ ਦੀ ਸੰਭਾਵਨਾ ਬਹੁਤ ਜ਼ਿਆਦਾ ਘਟ ਜਾਂਦੀ ਹੈ।

Reliability. ਮਾਡਲ ਆਪਣੇ ਨਿਰਧਾਰਤ ਕੰਮ ਤੱਕ ਸੀਮਤ ਰਹਿੰਦਾ ਹੈ। ਇਹ ਉਹੀ ਕਰਦਾ ਹੈ ਜਿਸ ਲਈ ਇਸਨੂੰ ਬਣਾਇਆ ਗਿਆ ਸੀ: ਸੰਰਚਨਾ, ਅਰਥ (semantics), ਅਤੇ ਸਮੱਸਿਆ ਦੇ ਵਿਸ਼ਲੇਸ਼ਣ (problem decomposition) ਬਾਰੇ ਤਰਕ ਕਰਨਾ। ਮਸ਼ੀਨ ਉਹ ਕਰਦੀ ਹੈ ਜਿਸ ਲਈ ਇਸਨੂੰ ਬਣਾਇਆ ਗਿਆ ਸੀ: ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਗਣਨਾ ਕਰਨਾ। ਕਾਰਜਾਂ ਦਾ ਇਹ ਵੱਖਕਰਨ (separation of concerns) ਹੀ ਉਹ ਤਰੀਕਾ ਹੈ ਜਿਸ ਨਾਲ ਭਰੋਸੇਯੋਗ ਸਾਫਟਵੇਅਰ ਤਿਆਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਕੰਪੋਜ਼ੀਸ਼ਨ (Composition) ਮੋਨੋਲਿਥਿਕ ਡਿਜ਼ਾਈਨ ਨਾਲੋਂ ਬਿਹਤਰ ਹੈ।

ਇਸਨੂੰ ਅਣਭਰੋਸੇਯੋਗ ਕੋਡ ਵਾਂਗ ਚਲਾਓ

ਇੱਕ ਚੇਤਾਵਨੀ ਦੀ ਲੋੜ ਹੈ। ਤਿਆਰ ਕੀਤੇ ਗਏ ਕੋਡ ਨੂੰ ਅਣਭਰੋਸੇਯੋਗ ਇਨਪੁਟ ਵਜੋਂ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਮਾਡਲ ਇੱਕ ਅਜਿਹੀ ਸਕ੍ਰਿਪਟ ਲਿਖ ਸਕਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਅਨੰਤ ਲੂਪ (infinite loop), ਕੋਈ ਬੇਲੋੜੀ ਨੈੱਟਵਰਕ ਰਿਕਵੈਸਟ, ਜਾਂ ਕੋਈ ਫਾਈਲਸਿਸਟਮ ਆਪਰੇਸ਼ਨ ਹੋਵੇ ਜੋ ਤੁਸੀਂ ਨਹੀਂ ਮੰਗਿਆ ਸੀ। ਹਮੇਸ਼ਾ ਇਹਨਾਂ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਇੱਕ ਅਲੱਗ ਸੈਂਡਬਾਕਸ (isolated sandbox) ਦੇ ਅੰਦਰ ਚਲਾਓ। ਸੀਮਤ ਅਧਿਕਾਰਾਂ ਵਾਲੇ ਕੰਟੇਨਰਾਂ, ਬਿਨਾਂ ਨੈੱਟਵਰਕ ਐਕਸੈਸ ਵਾਲੇ ਸਰਵਰਲੈੱਸ ਫੰਕਸ਼ਨਾਂ, ਜਾਂ ਸੀਮਤ CPU ਸਮੇਂ ਅਤੇ ਬਿਨਾਂ ਕਿਸੇ ਸਥਾਈ ਸਟੋਰੇਜ ਵਾਲੇ ਸਖ਼ਤ ਨਿਯੰਤਰਿਤ ਵਾਤਾਵਰਣਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਸੁਰੱਖਿਆ ਇੱਥੇ ਕੋਈ ਫੁੱਟਨੋਟ ਨਹੀਂ ਹੈ। ਇਹ ਸਿਸਟਮ ਡਿਜ਼ਾਈਨ ਦਾ ਹਿੱਸਾ ਹੈ।

ਜਿੱਥੇ PAL ਸ਼ਾਨਦਾਰ ਕੰਮ ਕਰਦਾ ਹੈ, ਅਤੇ ਜਿੱਥੇ ਇਹ ਰੁਕ ਜਾਂਦਾ ਹੈ

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

ਹਾਲਾਂਕਿ, ਇਹ ਗਲਤ ਤਰਕ (bad logic) ਨੂੰ ਠੀਕ ਨਹੀਂ ਕਰਦਾ। ਜੇਕਰ ਮਾਡਲ ਗਲਤ ਫਾਰਮੂਲਾ ਚੁਣਦਾ ਹੈ,