“strawberry” ಎಂಬ ಪದದಲ್ಲಿ ಎಷ್ಟು ಅಕ್ಷರಗಳಿವೆ ಎಂದು ಒಂದು language model ಅನ್ನು ಕೇಳಿ. ಅದು ತಪ್ಪಾಗಿ ಹೇಳುವ ಸಾಧ್ಯತೆ ಹೆಚ್ಚಿದೆ. ಅದು ಹತ್ತು ಎಂದು ಹೇಳಬಹುದು ಅಥವಾ ಹನ್ನೊಂದು ಎಂದು ಊಹಿಸಬಹುದು. ಅದು ತನ್ನ ಮೇಲೆ ತಾನೇ ಸಂಪೂರ್ಣ ನಂಬಿಕೆಯಿಂದ ಹೇಳಿದರೂ, ಅದು ತಪ್ಪಾಗಿರುತ್ತದೆ. ಅದೇ ಮಾದರಿಯನ್ನು ಸಾಲದ ಮೇಲೆ ಚಕ್ರಬಡ್ಡಿಯನ್ನು (compound interest) ಲೆಕ್ಕಹಾಕಲು, ಅಥವಾ ಎರಡು ದೊಡ್ಡ ಸಂಖ್ಯೆಗಳನ್ನು ಕೂಡಿಸಲು, ಅಥವಾ ಎರಡು ದಿನಾಂಕಗಳ ನಡುವಿನ ವ್ಯವಹಾರದ ದಿನಗಳನ್ನು (business days) ಎಣಿಸಲು ಕೇಳಿದರೆ, ನೀವು ನೋಡುವ ಉತ್ತರವು ನಂಬಲರ್ಹವಾಗಿ ಕಂಡರೂ, ಅಂಕಿಅಂಶಗಳು ಸ್ವಲ್ಪ ಮಟ್ಟಿಗೆ ತಪ್ಪಾಗಿರುತ್ತವೆ.

ಇದು ಸಂಭವಿಸುವುದಕ್ಕೆ ಕಾರಣವೆಂದರೆ, ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿಗಳು (large language models) ಮನುಷ್ಯರಂತೆ ಸಂಖ್ಯೆಗಳ ಬಗ್ಗೆ ತರ್ಕ ಮಾಡುವುದಿಲ್ಲ. ಅವು ಟೋಕನ್‌ಗಳನ್ನು (tokens) ಊಹಿಸುತ್ತವೆ. ಒಂದು ಟೋಕನ್ ಇಡೀ ಪದವಾಗಿರಬಹುದು, ಪದದ ಭಾಗವಾಗಿರಬಹುದು ಅಥವಾ ಒಂದು ಬಿಡಿ ಅಂಕಿ (digit) ಆಗಿರಬಹುದು. ಮಾದರಿಯು “strawberry” ಪದವನ್ನು ನೋಡಿದಾಗ, ಅದು ಸಾಲಾಗಿ ಜೋಡಿಸಲ್ಪಟ್ಟ ಎಂಟು ಪ್ರತ್ಯೇಕ ಅಕ್ಷರಗಳನ್ನು ನೋಡುವುದಿಲ್ಲ. ಬದಲಾಗಿ ಅದು ಕೆಲವು ತುಣುಕುಗಳನ್ನು (chunks) ನೋಡುತ್ತದೆ. ಅಕ್ಷರಗಳನ್ನು ಎಣಿಸುವುದನ್ನು ಅದಕ್ಕೆ ಕಲಿಸಿಲ್ಲ, ಕೇವಲ ಮುಂದಿನ ಪಠ್ಯದ ತುಣುಕು ಯಾವುದು ಎಂದು ಊಹಿಸುವುದನ್ನು ಮಾತ್ರ ಕಲಿಸಲಾಗಿದೆ. ಇದೇ ಮಿತಿ ಅಂಕಗಣಿತಕ್ಕೂ ಅನ್ವಯಿಸುತ್ತದೆ. ಮಾದರಿಯು ತನ್ನೊಳಗೆ ಯಾವುದೇ ಕ್ಯಾಲ್ಕುಲೇಟರ್ ಅನ್ನು ಹೊಂದಿಲ್ಲ. ಅದರಲ್ಲಿ 'ಕ್ಯಾರಿ ಲಾಜಿಕ್' (carry logic) ಇಲ್ಲ. ಅದಕ್ಕೆ ಸ್ಥಾನ ಬೆಲೆಯ (place value) ಬಗ್ಗೆ ಯಾವುದೇ ನೈಜ ತಿಳುವಳಿಕೆ ಇಲ್ಲ. ಅದು 148 ಅನ್ನು 279 ರಿಂದ ಗುಣಿಸಿದಾಗ, ಅದು ಗುಣಾಕಾರವನ್ನು ಮಾಡುತ್ತಿಲ್ಲ. ಬದಲಾಗಿ ತರಬೇತಿಯ ಸಮಯದಲ್ಲಿ ಕಂಡಿದ್ದ ಅಂತಹದೇ ಅಭಿವ್ಯಕ್ತಿಗಳೊಂದಿಗೆ ಮಾದರಿಯು ಪ್ಯಾಟರ್ನ್-ಮ್ಯಾಚಿಂಗ್ (pattern-matching) ಮಾಡುತ್ತಾ, ಅಂಕಿಗಳ ಸರಣಿ ಯಾವುದು ಎಂದು ಊಹಿಸುತ್ತದೆ. ಸಣ್ಣ ಮೊತ್ತಗಳಿಗೆ ಈ ಪ್ಯಾಟರ್ನ್ ಕೆಲಸ ಮಾಡಲು ಸಾಕಷ್ಟು ಬಲವಾಗಿರುತ್ತದೆ. ಆದರೆ ಹೆಚ್ಚಿನ ನಿಖರತೆ ಬೇಕಾದಾಗ, ಈ ಊಹೆಗಳು ತಪ್ಪಾಗುತ್ತವೆ.

ಎರಡು ಕೆಲಸಗಳು, ಒಂದು ಬಾಟ್

ಸಾಮಾನ್ಯ ಪ್ರಾಂಪ್ಟಿಂಗ್ ವಿಧಾನಗಳು (Standard prompting methods) ಒಂದು ವ್ಯವಸ್ಥೆಯನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಎರಡು ವಿಭಿನ್ನ ಕೆಲಸಗಳನ್ನು ಮಾಡಲು ಕೇಳುತ್ತವೆ. ಮೊದಲನೆಯದಾಗಿ, ಸಮಸ್ಯೆಯ ತರ್ಕವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು. ಎರಡನೆಯದಾಗಿ, ನಿಖರವಾದ ಗಣಿತವನ್ನು ಮಾಡುವುದು. ಮೊದಲನೇ ಕೆಲಸದಲ್ಲಿ ಮಾದರಿಯು ನಿಜವಾಗಿಯೂ ಅದ್ಭುತವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಅದು ಒಂದು ಪದದ ಸಮಸ್ಯೆಯನ್ನು ಓದಿ, ಚರಾಂಶಗಳನ್ನು (variables) ಹೊರತೆಗೆಯಬಹುದು, ಸಂಬಂಧಗಳನ್ನು ಗುರುತಿಸಬಹುದು ಮತ್ತು ಪರಿಹಾರದ ಹಾದಿಯನ್ನು ಯೋಜಿಸಬಹುದು. ಆದರೆ ನಂತರ ಅದು ತನ್ನದೇ ಕ್ಯಾಲ್ಕುಲೇಟರ್ ಆಗಿ ಕೆಲಸ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಅಲ್ಲಿಯೇ ಸಂಪರ್ಕವು ತಪ್ಪುತ್ತದೆ. ಮೂರನೇ ಹಂತದಲ್ಲಿ ಒಂದು ಅಂಕಿ ತಪ್ಪಾದರೆ, ಅದರ ನಂತರದ ಎಲ್ಲಾ ಹಂತಗಳೂ ತಪ್ಪಾಗುತ್ತವೆ. ತರ್ಕವು ಪರಿಪೂರ್ಣವಾಗಿರಬಹುದು, ಆದರೆ ಮಾದರಿಯು ತಪ್ಪಾಗಿ ಕೂಡಿಸಿದ್ದರಿಂದ ಅಂತಿಮ ಉತ್ತರವು ವ್ಯರ್ಥವಾಗುತ್ತದೆ.

Program-Aided Language Models ಅಥವಾ PAL, ಕೆಲಸವನ್ನು ವಿಭಜಿಸುವ ಮೂಲಕ ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತದೆ. ಮಾದರಿಯನ್ನು ನೇತುವರಿ ಉತ್ತರಕ್ಕಾಗಿ ಕೇಳುವ ಬದಲು, ಅದಕ್ಕೆ ಒಂದು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಬರೆಯಲು ಕೇಳಲಾಗುತ್ತದೆ.

ಇದರ ಕಾರ್ಯವಿಧಾನ ಹೀಗಿದೆ: ನೀವು ಸಮಸ್ಯೆಯನ್ನು ನೀಡುತ್ತೀರಿ. ಮಾದರಿಯು ತರ್ಕವನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತದೆ, ಚರಾಂಶಗಳನ್ನು (variables) ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ ಮತ್ತು ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ರೂಪಿಸುತ್ತದೆ. ನಂತರ, ಫಲಿತಾಂಶವನ್ನು ತಾನೇ ಲೆಕ್ಕಹಾಕುವ ಬದಲು, ಅದು ಒಂದು ಸಣ್ಣ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬರೆಯುತ್ತದೆ (ಸಾಮಾನ್ಯವಾಗಿ Python ನಲ್ಲಿ). ಆ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ನೈಜ ಕೋಡ್ ಇಂಟರ್ಪ್ರೆಟರ್‌ಗೆ (code interpreter) ನೀಡಲಾಗುತ್ತದೆ. ಇಂಟರ್ಪ್ರೆಟರ್ ಆ ತರ್ಕವನ್ನು ಚಲಾಯಿಸುತ್ತದೆ ಮತ್ತು ನಿಖರವಾದ, ನಿರ್ಣಾಯಕ (deterministic) ಫಲಿತಾಂಶವನ್ನು ನೀಡುತ್ತದೆ. ಮಾದರಿಯು ಗಣಿತವನ್ನು ವಿವರಿಸುತ್ತದೆ. Python ಗಣಿತವನ್ನು ಮಾಡುತ್ತದೆ.

ಪ್ರಾಯೋಗಿಕವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ತರ್ಕ (Executable Reasoning)

PAL ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ತರ್ಕ (executable reasoning) ಎಂದು ಭಾವಿಸಿ. ಒಂದು ಸ್ಕ್ರಿಪ್ಟ್ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಬಲ್ಲದಿದ್ದರೆ, ಮಾದರಿಯನ್ನು ಆ ಸ್ಕ್ರಿಪ್ಟ್ ಬರೆಯಲು ಬಿಡಿ.

ಒಂದುជាក់ಾತ್ಮಕ ಉದಾಹರಣೆಯನ್ನು ಗಮನಿಸಿ. ನೀವು ₹50,000 ರ ಸ್ಥಿರ ಠೇವಣಿಯ ಮೇಲೆ (fixed deposit), ವಾರ್ಷಿಕ 8.5 ಪ್ರತಿಶತ ಬಡ್ಡಿ ದರದಲ್ಲಿ, ತ್ರೈಮಾಸಿಕ ಚಕ್ರಬಡ್ಡಿಯೊಂದಿಗೆ (compounded quarterly), ಏಳು ವರ್ಷಗಳ ಅವಧಿಗೆ ಸಿಗುವ ಮ್ಯಾಚ್ಯೂರಿಟಿ ಮೊತ್ತವನ್ನು (maturity amount) ಲೆಕ್ಕಹಾಕಬೇಕಿದೆ ಎಂದು ಭಾವಿಸೋಣ. ನೀವು ನೇರವಾಗಿ language model ಅನ್ನು ಕೇಳಿದರೆ, ಅದು ಒಂದು ಸೂತ್ರವನ್ನು ಬರೆದು, ಮೌಲ್ಯಗಳನ್ನು ಆದೇಶಿಸಿ, chain of thought ಮೂಲಕ ಫಲಿತಾಂಶವನ್ನು ಲೆಕ್ಕಹಾಕಬಹುದು. ಆದರೆ ಸೂಕ್ಷ್ಮವಾಗಿ ಗಮನಿಸಿದರೆ, ಅದು ತ್ರೈಮಾಸಿಕ ಚಕ್ರಬಡ್ಡಿಯನ್ನು ತಪ್ಪಾಗಿ ವಿಭಜಿಸಿರಬಹುದು ಅಥವಾ ಮಧ್ಯಂತರ ಹಂತದಲ್ಲಿ ಸಂಖ್ಯೆಯನ್ನು ತಪ್ಪಾಗಿ ರೌಂಡ್-ಆಫ್ (round off) ಮಾಡಿ ತಪ್ಪು ಫಲಿತಾಂಶವನ್ನು ಮುಂದಕ್ಕೆ ಕೊಂಡೊಯ್ದಿರಬಹುದು. ಉತ್ತರವು ಸಮಂಜಸವಾಗಿ ಕಂಡರೂ, ಅದು ನೂರಾರು ರೂಪಾಯಿಗಳ ವ್ಯತ್ಯಾಸವನ್ನು ಹೊಂದಿರಬಹುದು.

PAL ಬಳಸಿದಾಗ, ಸಂವಹನವು ಬದಲಾಗುತ್ತದೆ. ನೀವು ಮಾದರಿಗೆ principal = 50000, rate = 0.085, time = 7, ಮತ್ತು n = 4 ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಿ, ನಂತರ amount = principal * (1 + rate/n) ** (n * time) ಅನ್ನು ಲೆಕ್ಕಹಾಕುವ Python ಕೋಡ್ ಅನ್ನು ರಚಿಸಲು ಸೂಚಿಸುತ್ತೀರಿ. ಮಾದರಿಯು ಕೋಡ್ ಅನ್ನು ನೀಡುತ್ತದೆ. Python runtime ಅದನ್ನು ಚಲಾಯಿಸುತ್ತದೆ. ನೀವು ಪ್ರತಿ ಬಾರಿಯೂ ಕೊನೆಯ ದಶಮಾಂಶದವರೆಗೆ ನಿಖರವಾದ ಅಂಕಿಅಂಶವನ್ನು ಪಡೆಯುತ್ತೀರಿ. ಇಲ್ಲಿ ಗುಣಾಕಾರದಲ್ಲಿ ಯಾವುದೇ ಊಹೆಗಳಿಲ್ಲ, ಯಾವುದೇ ಭ್ರಮಿತ (hallucinated) ಶೇಷಗಳಿಲ್ಲ ಅಥವಾ ಆತ್ಮವಿಶ್ವಾಸದಿಂದ ಮಾಡಿದ ರೌಂಡಿಂಗ್ ತಪ್ಪುಗಳಿಲ್ಲ.

ಇದೇ ಮಾದರಿಯು ದಿನಾಂಕದ ಗಣಿತಕ್ಕೂ (date math) ಅನ್ವಯಿಸುತ್ತದೆ. ವಾರಾಂತ್ಯಗಳನ್ನು ಹೊರತುಪಡಿಸಿ, ಇಂದಿನಿಂದ ಸರಿಯಾಗಿ 120 ವ್ಯವಹಾರದ ದಿನಗಳ ನಂತರ ಬರುವ ದಿನಾಂಕ ಯಾವುದು ಎಂದು ಮಾದರಿಯನ್ನು ಕೇಳಿ. ಕೇವಲ ಪಠ್ಯವನ್ನು ಬಳಸುವ ಮಾದರಿಯು ದಿನಗಳನ್ನು ಎಣಿಸುವಾಗ ಶನಿವಾರ ಅಥವಾ ಭಾನುವಾರವನ್ನು ತಪ್ಪಿಸಬಹುದು. PAL ವಿಧಾನವು ಮಾದರಿಯನ್ನು datetime ಮತ್ತು calendar ತರ್ಕವನ್ನು ಬಳಸುವ ಸ್ಕ್ರಿಪ್ಟ್ ಬರೆಯಲು ಸೂಚಿಸುತ್ತದೆ, ನಂತರ ಇಂಟರ್ಪ್ರೆಟರ್ ಅದನ್ನು ನಿಖರವಾಗಿ ಎಣಿಸುತ್ತದೆ. ಡೇಟಾ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್ (Data manipulation) ಕೂಡ ಇದೇ ರೀತಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ನೀವು ಒಂದು ಗೊಂದಲಮಯ CSV ಫೈಲ್ ಅನ್ನು ಪಾರ್ಸ್ ಮಾಡಬೇಕಿದ್ದರೆ, ನೆಸ್ಟೆಡ್ JSON ಅನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಬೇಕಿದ್ದರೆ ಅಥವಾ ವೇಗವಾದ ಸ್ಟ್ಯಾಟಿಸ್ಟಿಕಲ್ ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮ್ ಮಾಡಬೇಕಿದ್ದರೆ, ಮಾದರಿಯು ತರ್ಕವನ್ನು ಸಿದ್ಧಪಡಿಸಬೇಕು ಮತ್ತು ಇಂಟರ್ಪ್ರೆಟರ್ ಅದನ್ನು ನಿರ್ವಹಿಸಬೇಕು.

ಇದು ನಿಜವಾಗಿಯೂ ಏಕೆ ಮುಖ್ಯ

ಗದ್ಯ ರೂಪದ ಉತ್ತರಗಳಿಂದ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಕೋಡ್‌ಗೆ ಬದಲಾಗುವುದು ಮೂರು ಪ್ರಾಯೋಗಿಕ ಪ್ರಯೋಜನಗಳನ್ನು ನೀಡುತ್ತದೆ.

ನಿರ್ಣಯವಾದ (Determinism). ಒಂದೇ ಪ್ರಶ್ನೆಯನ್ನು ಎರಡು ಬಾರಿ ಕೇಳಿದಾಗ ಒಂದು ಭಾಷಾ ಮಾದರಿಯು (language model) ತನ್ನ ಪದಬಳಕೆಯನ್ನು ಬದಲಾಯಿಸಬಹುದು ಅಥವಾ ಒಂದು ಅಂಕಿ-ಅಂಶವನ್ನು ಬದಲಾಯಿಸಬಹುದು. ಇಂಟರ್ಪ್ರಿಟರ್ (interpreter) ಒಂದೇ ಇನ್‌ಪುಟ್‌ಗೆ ಪ್ರತಿ ಬಾರಿಯೂ ಒಂದೇ ರೀತಿಯ ಔಟ್‌ಪುಟ್ ಅನ್ನು ನೀಡುತ್ತದೆ. ಅಕೌಂಟಿಂಗ್, ಲಾಜಿಸ್ಟಿಕ್ಸ್, ಶೆಡ್ಯೂಲಿಂಗ್ ಮತ್ತು ಸ್ಥಿರತೆ ಕಡ್ಡಾಯವಾಗಿರುವ ಯಾವುದೇ ಎಂಜಿನಿಯರಿಂಗ್ ಲೆಕ್ಕಾಚಾರಗಳಲ್ಲಿ ಆ ಸ್ಥಿರತೆ ಬಹಳ ಮುಖ್ಯವಾಗುತ್ತದೆ.

ಪರಿಶೀಲಿಸುವಿಕೆ (Verifiability). ಒಂದು ಮಾದರಿಯು ನಿಮಗೆ ಮೂರು ಪ್ಯಾರಾಗಳ ತಾರ್ಕಿಕ ವಿವರಣೆಯನ್ನು ನೀಡಿದಾಗ, ಅದರಲ್ಲಿರುವ ಒಂದು ತಪ್ಪಾದ ಸಂಖ್ಯೆಯನ್ನು ಹುಡುಕಲು ನೀವು ಪ್ರತಿಯೊಂದು ವಾಕ್ಯವನ್ನೂ ಓದಬೇಕಾಗುತ್ತದೆ. ಅದು ನಿಮಗೆ ಹತ್ತು ಸಾಲುಗಳ ಸ್ಕ್ರಿಪ್ಟ್ ನೀಡಿದಾಗ, ನೀವು ಕೋಡ್ ಅನ್ನು ಪರಿಶೀಲಿಸಬಹುದು. ಇಂಟರ್ಪ್ರಿಟರ್ ಚಾಲನೆಯಾಗುವ ಮೊದಲೇ ಚಕ್ರಬಡ್ಡಿಯ ಸೂತ್ರವು ಸರಿಯಾಗಿದೆಯೇ ಎಂದು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು. ನೀವು ವೇರಿಯೇಬಲ್ ಹೆಸರುಗಳನ್ನು ಪರೀಕ್ಷಿಸಬಹುದು, 'off-by-one' ದೋಷಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಬಹುದು ಮತ್ತು ಪರಿಹಾರವನ್ನು ವರ್ಷನ್-ಕಂಟ್ರೋಲ್ (version-control) ಕೂಡ ಮಾಡಬಹುದು. ಇದರಿಂದ ಅಡಗಿರುವ ತಪ್ಪುಗಳು ಸಂಭವಿಸುವ ಸಾಧ್ಯತೆಗಳು ಗಣನೀಯವಾಗಿ ಕಡಿಮೆಯಾಗುತ್ತವೆ.

ನಂಬಿಕಾರ್ಹತೆ (Reliability). ಮಾದರಿಯು ತನ್ನ ವ್ಯಾಪ್ತಿಯಲ್ಲೇ ಇರುತ್ತದೆ. ಅದು ಮಾಡಲು ನಿರ್ಮಿಸಲಾದ ಕೆಲಸವನ್ನೇ ಮಾಡುತ್ತದೆ: ರಚನೆ (structure), semantics (ಅರ್ಥ) ಮತ್ತು ಸಮಸ್ಯೆಯ ವಿಭಜನೆಯ (problem decomposition) ಬಗ್ಗೆ ತರ್ಕ ಮಾಡುವುದು. ಯಂತ್ರವು ಮಾಡಲು ನಿರ್ಮಿಸಲಾದ ಕೆಲಸವನ್ನೇ ಮಾಡುತ್ತದೆ: ನಿಖರವಾಗಿ ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು. ಈ ರೀತಿಯ ಕೆಲಸಗಳ ವಿಭಜನೆಯೇ (separation of concerns) ನಂಬಿಕಾರ್ಹ ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವ ಸರಿಯಾದ ವಿಧಾನವಾಗಿದೆ. ಸಂಯೋಜಿತ ವಿನ್ಯಾಸವು (Composition) ಏಕರೂಪದ ವಿನ್ಯಾಸಕ್ಕಿಂತ (monolithic design) ಉತ್ತಮವಾದುದು.

ಇದನ್ನು ನಂಬಲಾಗದ ಕೋಡ್‌ನಂತೆ ಚಲಾಯಿಸಿ

ಒಂದು ಎಚ್ಚರಿಕೆಯ ಮಾತು ಅಗತ್ಯವಿದೆ. ಸೃಷ್ಟಿಸಲಾದ ಕೋಡ್ ಅನ್ನು ನಂಬಲಾಗದ ಇನ್‌ಪುಟ್ ಎಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಾದರಿಯು ಅನಂತ ಲೂಪ್ (infinite loop), ಅನಗತ್ಯ ನೆಟ್‌ವರ್ಕ್ ವಿನಂತಿ ಅಥವಾ ನೀವು ಕೇಳದ ಫೈಲ್‌ಸಿಸ್ಟಮ್ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಒಳಗೊಂಡ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬರೆಯಬಹುದು. ಈ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಯಾವಾಗಲೂ ಪ್ರತ್ಯೇಕವಾದ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ (sandbox) ಒಳಗೆ ಚಲಾಯಿಸಿ. ಸೀಮಿತ ಅಧಿಕಾರವಿರುವ ಕಂಟೇನರ್‌ಗಳು, ನೆಟ್‌ವರ್ಕ್ ಪ್ರವೇಶವಿಲ್ಲದ ಸರ್ವರ್‌ಲೆಸ್ ಫಂಕ್ಷನ್‌ಗಳು ಅಥವಾ ಸೀಮಿತ CPU ಸಮಯ ಮತ್ತು ಯಾವುದೇ ಪರ್ಸಿಸ್ಟೆಂಟ್ ಸ್ಟೋರೇಜ್ ಇಲ್ಲದ ಕಟ್ಟುನಿಟ್ಟಾಗಿ ನಿಯಂತ್ರಿಸಲ್ಪಟ್ಟ ಪರಿಸರಗಳನ್ನು ಬಳಸಿ. ಇಲ್ಲಿ ಭದ್ರತೆಯು ಕೇವಲ ಒಂದು ಸಣ್ಣ ಟಿಪ್ಪಣಿಯಲ್ಲ. ಅದು ಸಿಸ್ಟಮ್ ವಿನ್ಯಾಸದ ಒಂದು ಭಾಗವಾಗಿದೆ.

PAL ಎಲ್ಲಿ ಉತ್ತಮವಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಮತ್ತು ಎಲ್ಲಿ ನಿಲ್ಲುತ್ತದೆ

ಗಣಿತ, ದಿನಾಂಕಗಳು ಮತ್ತು ರಚನಾತ್ಮಕ ಡೇಟಾ ನಿರ್ವಹಣೆಗೆ (structured data manipulation) PAL ಅದ್ಭುತವಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಇದು ಕೇವಲ ಪಠ್ಯ ಆಧಾರಿತ ತರ್ಕದಲ್ಲಿ ಕಂಡುಬರುವ ಯಾಂತ್ರಿಕ ದೋಷಗಳನ್ನು ನಿವಾರಿಸುತ್ತದೆ.

ಆದಾಗ್ಯೂ, ಇದು ತಪ್ಪು ತರ್ಕವನ್ನು ಸರಿಪಡಿಸುವುದಿಲ್ಲ. ಮಾದರಿಯು ತಪ್ಪಾದ ಸೂತ್ರವನ್ನು ಆರಿಸಿಕೊಂಡರೆ,