04 ਸਤੰ 2025·8 ਮਿੰਟ
2025 ਵਿੱਚ ਖੋਜ-ਯੋਗ 12 ਅਨੋਖੀਆਂ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ
2025 ਵਿੱਚ 12 ਅਨੋਖੀਆਂ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਦੀ ਖੋਜ ਕਰੋ: ਉਹਨਾਂ ਦੀਆਂ ਵਿਲੱਖਣਤਾਂ, ਕਿੱਥੇ ਉਹ ਚਮਕਦੀਆਂ ਹਨ, ਅਤੇ ਬਿਨਾਂ ਭਟਕੇ ਉਨ੍ਹਾਂ ਨੂੰ ਆਜ਼ਮਾਉਣ ਦੇ ਸਧਾਰਨ ਤਰੀਕੇ।
ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਲਈ “ਐਕਸੋਟਿਕ” ਦਾ ਕੀ ਮਤਲਬ ਹੈ
“ਐਕਸੋਟਿਕ” ਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਕਿ ਉਹ “ਵਧੀਆ” ਜਾਂ “ਔਖਾ” ਹੈ। ਆਮ ਤੌਰ 'ਤੇ ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਭਾਸ਼ਾ ਕੁਝ ਅਜਿਹਾ ਕਰ ਰਹੀ ਹੈ ਜੋ ਆਮ ਨਹੀਂ—ਚਾਹੇ ਉਹ ਲਿਖਣ ਦੇ ਢੰਗ ਵਿੱਚ ਹੋਵੇ, ਭਾਸ਼ਾ ਕਿਸੇ ਨਿਰਧਾਰਿਤ ਘਟਕ ਲਈ ਤਿਆਰ ਕੀਤੀ ਗਈ ਹੋਵੇ, ਜਾਂ ਉਹ ਕੋਈ ਨਵੀਂ ਧਾਰਣਾ ਸਿਖਾਉਂਦੀ ਹੋਵੇ।
ਇੱਕ ਪ੍ਰਯੋਗਿਕ ਪਰਿਭਾਸ਼ਾ
ਇਸ ਲੇਖ ਵਿੱਚ, ਇੱਕ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾ ਨੂੰ ਐਕਸੋਟਿਕ ਮੰਨਿਆ ਜਾਵੇਗਾ ਜੇ ਇਹ ਘੱਟੋ-ਘੱਟ ਇੱਕ ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਵਿੱਚੋਂ ਮਿਲਦੀ ਹੋਵੇ:
- ਅਨੋਖਾ ਸਿੰਟੈਕਸ: ਕੋਡ ਜੋ ਮੁੱਖਧਾਰਾ ਭਾਸ਼ਾਵਾਂ ਵਰਗਾ ਨਹੀਂ ਦਿਖਦਾ (ਕਈ ਵਾਰੀ ਚਿੰਨ੍ਹਾਂ-భਰਿਆ, ਕਈ ਵਾਰੀ ਲਗਭਗ ਦਿੱਖੈ ਵੀ ਨਹੀਂ).
- ਨਿਸ਼-ਉਦੇਸ਼: ਕਿਸੇ ਵਿਸ਼ੇਸ਼ ਸੋਚ-ਵਿਧੀ ਲਈ ਬਣਾਈ ਗਈ—ਸਰਣੀਆਂ, ਲਾਜਿਕ ਕੁਐਰੀਜ਼, ਸਟੈਕ-ਆਧਾਰਿਤ ਰਚਨਾ, ਜਾਂ ਸੰਕੁਚਿਤ ਨਿਊਨਤਾ।
- ਪ੍ਰਯੋਗਾਤਮਕ ਵਿਚਾਰ: ਵੱਖਰਾ ਐਕਜ਼ਿਕਿਊਸ਼ਨ ਮਾਡਲ (2D ਕੋਡ ਫਲੋ, ਨਿਯਮ-ਅਧਾਰਤ ਮੁਲਾਂਕਣ, ਜਾਂ ਕਵਾਂਟਮ ਸੰਕਲਪ) ਦੀ ਪੜਤਾਲ ਕਰਦੀ ਹੋਵੇ।
ਉਮੀਦਾਂ ਸੈੱਟ ਕਰੋ (ਤਾਂ ਜੋ ਤੁਹਾਨੂੰ ਮਜ਼ਾ ਆਵੇ)
ਇੱਕ ਐਕਸੋਟਿਕ ਜਾਂ ਐਸੋਲੈਂਗ ਸਿੱਖਣਾ ਆਮ ਤੌਰ 'ਤੇ ਮਜ਼ੇਦਾਰ ਅਤੇ ਹੈਰਾਨ ਕਰਨ ਵਾਲਾ ਸਿੱਖਣ ਦਾ ਤਜਰਬਾ ਹੁੰਦਾ ਹੈ, ਕਿਉਂਕਿ ਇਹ ਤੁਹਾਨੂੰ ਅਫ਼ਸਰ-ਫਿਕਸ ਧਾਰਣਾਵਾਂ ਨੂੰ ਦੁਬਾਰਾ ਸੋਚਣ 'ਤੇ ਮਜਬੂਰ ਕਰਦਾ ਹੈ: “ਪ੍ਰੋਗਰਾਮ” ਕੀ ਹੁੰਦਾ ਹੈ, ਡੇਟਾ ਕਿਵੇਂ ਬਹਿੰਦਾ ਹੈ, ਅਤੇ ਅਸਲ ਵਿੱਚ ਕਿੰਨੀ ਸਿੰਟੈਕਸ ਦੀ ਲੋੜ ਹੈ।
ਕਈ ਭਾਸ਼ਾਵਾਂ ਰੋਜ਼ਾਨਾ ਦੇ ਕੰਮ ਲਈ ਨਹੀਂ ਹੁੰਦੀਆਂ। ਕੁਝ ਪਹੇਲੀਆਂ ਹਨ, ਕੁਝ ਰਿਸਰਚ ਵਾਹਨ ਹਨ, ਅਤੇ ਕੁਝ ਇੱਕ ਸੰਕੁਚਿਤ ਕਾਰਜ ਵਿੱਚ ਬਹੁਤ ਵਧੀਆ ਹੁੰਦੀਆਂ ਹਨ ਜਦਕਿ ਹਰ ਚੀਜ਼ ਲਈ ਔਖੀਆਂ। ਨਤੀਜਾ ਗਿਆਨ ਹੁੰਦਾ ਹੈ—ਜ਼ਰੂਰੀ ਤੌਰ ਤੇ ਉਤਪਾਦਕਤਾ ਨਹੀਂ।
2025 ਵਿੱਚ ਇਹ ਕਿਉਂ ਮਹੱਤਵਪੂਰਨ ਹੈ
2025 ਖੋਜ ਲਈ ਵਧੀਆ ਸਮਾਂ ਹੈ: ਬਹੁਤ ਸਾਰੀਆਂ ਨਿਸ਼ ਭਾਸ਼ਾਵਾਂ ਦੀ ਸਕ्रीय ਕਮਿਊਨਿਟੀ, ਵਧੀਆ ਦਸਤਾਵੇਜ਼ੀ, ਅਤੇ ਦੋਸਤਾਨਾ ਟੂਲਿੰਗ (REPLs, ਪੈਕੇਜ, ਆਨਲਾਈਨ ਪਲੇਗ੍ਰਾਊਂਡ) ਮਿਲ ਰਹੀਆਂ ਹਨ। ਤਬਦੀਲ ਪੈਰੇਡਾਇਮਾਂ ਪ੍ਰਤੀ ਨਵੀਂ ਰੁਚੀ ਵੀ ਹੈ—ਡੇਟਾ ਕੰਮ ਲਈ ਐਰੇ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ, ਨਿਯਮਾਂ ਲਈ ਲਾਜਿਕ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ, ਅਤੇ ਕਵਾਂਟਮ “ਟੁਏ” ਵਾਤਾਵਰਨ ਜੋ ਤੁਹਾਨੂੰ ਵਿਸ਼ੇਸ਼ ਹਾਰਡਵੇਅਰ ਦੇ ਬਿਨਾਂ ਪ੍ਰਯੋਗ ਕਰਨ ਦੇ ਯੋਗ ਬਣਾਉਂਦੇ ਹਨ।
ਇਹ ਸੂਚੀ ਕਿਵੇਂ ਠਹਿਰਾਈ ਗਈ ਹੈ
“ਅਜੀਬਤਾ” ਦੀ ਕਦਰ ਕਰਨ ਦੀ ਥਾਂ, ਸੂਚੀ ਨੂੰ ਪਰਿਵਾਰਾਂ (ਮਿਨੀਮਲਿਸਟ, ਅਦ੍ਰਿਸ਼, 2D, ਐਰੇ, ਲਾਜਿਕ, ਸਟੈਕ-ਆਧਾਰਿਤ, ਸੁਰੱਖਿਆ-ਕੇਂਦਰਿਤ, ਕਵਾਂਟਮ) ਵਿੱਚ ਗਰੁੱਪ ਕੀਤਾ ਗਿਆ ਹੈ। ਹਰ ਸੈਕਸ਼ਨ ਵਿੱਚ ਇੱਕ ਸਧਾਰਨ “ਕਿਆ ਅਜ਼ਮਾਓ” ਵਿਚਾਰ ਦਿੱਤਾ ਗਿਆ ਹੈ ਤਾਂ ਜੋ ਤੁਸੀਂ ਛੇਤੀ ਜਿੱਤ ਹਾਸਲ ਕਰ ਸਕੋ ਫਿਰ ਫੈਸਲਾ ਕਰੋ ਕਿ ਅੱਗੇ ਜਾਣਾ ਹੈ ਜਾਂ ਨਹੀਂ।
ਅਸੀਂ ਭਾਸ਼ਾਵਾਂ ਕਿਵੇਂ ਚੁਣੀਆਂ (ਅਤੇ ਸੁਰੱਖਿਅਤ ਤਰੀਕੇ ਨਾਲ ਕਿਵੇਂ ਅਜ਼ਮਾਉ)
“ਐਕਸੋਟਿਕ” ਦੇ ਬਹੁਤ ਸਾਰੇ ਅਰਥ ਹੋ ਸਕਦੇ ਹਨ, ਇਸ ਲਈ ਇਹ ਸੂਚੀ ਸਿਰਫ਼ ਵਿਲੱਖਣ ਸਿੰਟੈਕਸ ਦੀ ਪਰੈਡ ਤੋ ਨਹੀਂ ਬਣਾਈ ਗਈ। ਅਸੀਂ ਉਹ ਭਾਸ਼ਾਵਾਂ ਚੁਣੀਆਂ ਜੋ ਸੱਚਮੁੱਚ ਵੱਖਰੀ ਮਹਿਸੂਸ ਹੁੰਦੀਆਂ ਅਤੇ 2025 ਵਿੱਚ ਸਿੱਖਣ ਲਈ ਪ੍ਰਯੋਗਿਕ ਰਹਿੰਦੀਆਂ ਹਨ।
ਸਾਡੀਆਂ ਚੋਣ ਮਿਆਰ
ਪਹਿਲਾਂ, ਅਸਲਪਨ ਦੀ ਤਲਾਸ਼ ਕੀਤੀ ਗਈ: ਉਹ ਭਾਸ਼ਾਵਾਂ ਜੋ ਨਵਾਂ ਮਾਨਸਿਕ ਮਾਡਲ ਮੰਗਦੀਆਂ ਹਨ (2D ਕੋਡ, ਸਟੈਕ-ਆਧਾਰਿਤ ਸੋਚ, ਨਿਯਮ/ਕੁਐਰੀ, ਐਰੇ-ਡਿਫੌਲਟ, ਕਵਾਂਟਮ ਸਰਕਿਟ)।
ਦੂਜੇ, ਅਸੀਂ ਸਿੱਖਣਯੋਗਤਾ ਨੂੰ ਤਰਜੀਹ ਦਿੱਤੀ। ਭਾਵੇਂ ਭਾਸ਼ਾ ਅਨੋਖੀ ਹੋਵੇ, ਤੁਹਾਨੂੰ ਇੱਕ ਸਪਸ਼ਟ “ਹੈਲੋ ਵਰਲਡ”, ਟਿਊਟੋਰਿਯਲ, ਅਤੇ ਛੋਟੀਆਂ ਪ੍ਰੋਗਰਾਮਾਂ ਲਿਖਣ ਦਾ ਰਸਤਾ ਮਿਲਣਾ ਚਾਹੀਦਾ ਹੈ ਬਿਨਾਂ ਲੰਮੀ ਸੈਟਅਪ ਦੇ।
ਤੀਜੇ, ਅਸੀਂ ਉਸ ਟੂਲਿੰਗ ਦੀ ਜਾਂਚ ਕੀਤੀ ਜੋ ਤੁਸੀਂ ਅਸਲ ਵਿੱਚ ਵਰਤ ਸਕਦੇ ਹੋ: ਸਾਹਮਣੇ ਡੌਕ, ਕੰਮ ਕਰਨ ਵਾਲਾ ਇੰਟਰਪ੍ਰੇਟਰ/ਕੰਪਾਇਲਰ, ਜਾਂ ਸਕਰਿਯ ਰਿਪੋਜ਼ਿਰਿ. ਇੱਕ ਭਾਸ਼ਾ ਬੇਹਤਰੀਨ ਹੋ ਸਕਦੀ ਹੈ, ਪਰ ਜੇ ਤੁਸੀਂ ਉਸਨੂੰ ਆਪਣੇ ਆਧੁਨਿਕ ਮਸ਼ੀਨ 'ਤੇ ਨਹੀਂ ਚਲਾ ਸਕਦੇ ਤਾਂ ਸੁਝਾਉਣਾ ਔਖਾ ਹੈ।
ਅਖੀਰ ਵਿੱਚ, ਅਸੀਂ ਬੈਲੈਂਸ ਲਈ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ—ਕਲਾਸਿਕ ਏਸੋਲੈਂਗ (ਮਜ਼ੇਦਾਰ, ਮਨ-ਮੋੜਨ ਵਾਲੇ) ਅਤੇ ਗੰਭੀਰ ਨਿਸ਼ ਜਾਂ ਰਿਸਰਚ ਭਾਸ਼ਾਵਾਂ ਦਾ ਮਿਕਸ (ਜਿਹੜੀਆਂ ਮੂਲ ਵਿਚਾਰਾਂ ਨੂੰ ਮੈਨਸਟ੍ਰੀਮ ਵਿੱਚ ਲਿਆਉਂਦੀਆਂ ਹਨ)।
ਕੁਝ ਸੁਰੱਖਿਆ ਨੋਟ ਪਹਿਲਾਂ ਕਿ ਤੁਸੀਂ ਕੁਝ ਚਲਾਓ
ਅੰਜਾਣ ਕੋਡ ਨੂੰ ਉਸੇ ਤਰ੍ਹਾਂ ਭਾਵੋ ਜਿਵੇਂ ਤੁਸੀਂ ਕਿਸੇ ਅਣਚਾਹੇ ਡਾਊਨਲੋਡ ਨੂੰ ਮਹਿਸੂਸ ਕਰਦੇ ਹੋ। ਇੰਟਰਪ੍ਰੇਟਰ ਅਤੇ ਨਮੂਨੇ ਪ੍ਰੋਗ੍ਰਾਮਾਂ ਨੂੰ ਇੱਕ ਕੰਟੇਨਰ ਜਾਂ ਸੈਂਡਬਾਕਸ ਵਿੱਚ ਚਲਾਉਣਾ ਬਿਹਤਰ ਹੈ (ਜਾਂ ਘੱਟੋ-ਘੱਟ ਇੱਕ ਅਲੱਗ ਫੋਲਡਰ), ਅਤੇ ਅਣਜਾਣ ਕੋਡ ਨੂੰ ਆਪਣੇ ਨਿੱਜੀ ਫਾਈਲਾਂ, SSH ਚਾਵੀਆਂ, ਜਾਂ ਕਲਾਉਡ ক্রੇਡੈਂਸ਼ਿਆਲ ਤਕ ਪਹੁੰਚ ਵਾਲੇ ਵਾਤਾਵਰਨਾਂ ਵਿੱਚ ਪੇਸਟ ਨਾ ਕਰੋ।
ਜੇ ਤੁਸੀਂ ਬਾਰੰਬਾਰ ਪ੍ਰਯੋਗ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਇੱਕ “ਸੁਰੱਖਿਅਤ ਪਲੇਗ੍ਰਾਊਂਡ” ਸੈੱਟਅਪ ਨੂੰ ਸਥਿਰ ਕਰਨਾ ਮਦਦਗਾਰ ਹੁੰਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ ਇੱਕ ਛੋਟਾ ਨਾਸ਼ਪੱਦਾ ਵੈੱਬ ਐਪ ਘੁਮਾਉ ਸਕਦੇ ਹੋ ਜੋ ਇੱਕ API ਦੇ ਪਿੱਛੇ ਇੰਟਰਪ੍ਰੇਟਰ ਚਲਾਉਂਦਾ ਹੈ ਅਤੇ ਹਰ ਰਨ ਦੇ ਬਾਅਦ ਸਟੇਟ ਰੀਸੈਟ ਕਰਦਾ ਹੈ। ਪਲੇਟਫਾਰਮਾਂ ਵਰਗੇ Koder.ai ਇੱਥੇ ਮਦਦਗਾਰ ਹੋ ਸਕਦੇ ਹਨ ਕਿਉਂਕਿ ਤੁਸੀਂ ਚੈਟ ਵਿੱਚ ਉਹ ਪਲੇਗ੍ਰਾਊਂਡ ਵਰਣਨ ਕਰ ਸਕਦੇ ਹੋ (ਫਰੰਟਐਂਡ + ਬੈਕਐਂਡ + ਡੇਟਾਬੇਸ ਜੇ ਲੋੜ ਹੋਵੇ), ਤੇਜ਼ੀ ਨਾਲ ਦੁਹਰਾਓ, ਅਤੇ ਜਦ ਤੁਸੀਂ ਖੁਸ਼ ਹੋਵੋ ਤਾਂ ਸੋਰਸ ਕੋਡ ਨਿਰਯਾਤ ਕਰੋ।
Brainfuck: ਨਿਊਨਤਮਤਾਵਾਦ ਇੱਕ ਪਹੇਲੀ ਵਿੱਚ ਬਦਲਿਆ
Brainfuck ਨੂੰ ਇਕੋ ਇੱਕ ਕਾਰਨ ਲਈ “ਐਕਸੋਟਿਕ” ਕਿਹਾ ਜਾਂਦਾ ਹੈ: ਇਹ ਲਗਭਗ ਹਾਸਿਆਸਪਦ ਤੌਰ 'ਤੇ ਛੋਟੇ ਹੁਕਮ-ਸੈੱਟ ਨਾਲ ਸਭ ਕੁਝ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ। ਭਾਸ਼ਾ ਕੋਲ ਸਿਰਫ਼ ਅੱਠ ਆਦੇਸ਼ ਹਨ (+ - \\u003c \\u003e [ ] . ,), ਕੋਈ ਕੀਵਰਡ ਨਹੀਂ, ਕੋਈ ਪਰੰਪਰਾਗਤ ਤੌਰ ਤੇ ਵੇਰੀਏਬਲ ਨਹੀਂ, ਅਤੇ ਪਾਠ-ਸੂਚਨਾ ਉਸਤੋਂ ਪਛਾਣਯੋਗ ਨਹੀਂ ਹੁੰਦੀ ਜਦ ਤੱਕ ਤੁਸੀਂ ਕੌਸ਼ਲ ਨਾ ਜਾਣਦੇ ਹੋ।
ਇਹ ਕਿਉਂ ਐਕਸੋਟਿਕ ਹੈ
ਨਾਂਅ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਥਾਂ, Brainfuck ਤੁਹਾਨੂੰ ਮੈਮੋਰੀ ਸੈਲਾਂ ਦੀ ਇੱਕ ਟੇਪ ਅਤੇ ਇੱਕ ਪੌਇੰਟਰ ਦਿੰਦਾ ਹੈ ਜੋ ਖੱਬੇ ਅਤੇ ਸੱਜੇ ਹਿਲਦਾ ਹੈ। ਤੁਸੀਂ ਮੌਜੂਦਾ ਸੈਲ ਨੂੰ ਇੰਕ੍ਰੀਮੈਂਟ/ਡਿਕ੍ਰੀਮੈਂਟ ਕਰਦੇ ਹੋ, ਪੌਇੰਟਰ ਨੂੰ ਹਿਲਾਉਂਦੇ ਹੋ, ਅਤੇ ਲੂਪ ਲਈ ਕੋਠੀਆਂ ਵਰਤਦੇ ਹੋ। ਇਹੀ ਸਭ ਹੈ। ਨਤੀਜਾ ਇਕ ਐਸਾ ਤਜਰਬਾ ਮਹਿਸੂਸ ਹੁੰਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਕੋਈ ਤਰਕ-ਪਹੇਲੀ ਸੁਲਝਾ ਰਹੇ ਹੋ ਨਾ ਕਿ ਐਪਲੀਕੇਸ਼ਨ ਲਿਖ ਰਹੇ ਹੋ।
ਇਹ ਕੀ ਸਿਖਾਉਂਦਾ ਹੈ
Brainfuck यह ਸਿੱਧਾ ਸਬਕ ਹੈ ਕਿ ਕੰਪਿਊਟਰ ਨੂੰ ਗਣਨਾ ਕਰਨ ਲਈ ਕਿੰਨਾ ਘੱਟ ਚਾਹੀਦਾ ਹੈ। ਇਹ ਤੁਹਾਨੂੰ ਸੋਚਣ 'ਤੇ ਮਜਬੂਰ ਕਰਦਾ ਹੈ:
- ਮੈਮੋਰੀ ਅਤੇ ਸਟੇਟ (ਟੇਪ)
- ਕੰਟਰੋਲ ਫਲੋ (
[ਅਤੇ]ਰਾਹੀਂ ਲੂਪ) - ਨੀਵੀਂ ਪੱਧਰ ਦੀ ਇਨਪੁੱਟ/ਆਉਟਪੁੱਟ (ਕਿਰਦਾਰ, ਨਾ ਕਿ ਸਤਰਾਂ)
ਜੇ ਤੁਸੀਂ ਕਦੇ ਸੋਚਿਆ ਹੈ ਕਿ ਇੰਟਰਪ੍ਰੇਟਰ ਜਾਂ ਕੰਪਾਇਲਰ ਅਸਲ ਵਿੱਚ ਕੀ ਕਰਦਾ ਹੈ, ਤਾਂ Brainfuck ਇੱਕ ਵਧੀਆ ਅਭਿਆਸ ਮੰਤਵ ਹੈ।
ਕਿੱਥੇ ਇਸਦੀ ਵਰਤੋਂ ਹੁੰਦੀ ਹੈ
ਅਧਿਕਤਰ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਪਹੇਲੀਆਂ, ਸਿਧਾਂਤ ਚਰਚਾਵਾਂ, ਕੋਡ ਗੋਲਫ, ਅਤੇ ਇੰਟਰਪ੍ਰੇਟਰ ਲਿਖਣ ਦੇ ਅਭਿਆਸ ਲਈ।
ਅਜ਼ਮਾਉਣ ਲਈ
“Hello World” (ਕਲਾਸਿਕ ਸੰਸਕਰਣ):
++++++++++[\\u003e+++++++\\u003e++++++++++\\u003e+++\\u003e+\\u003c\\u003c\\u003c\\u003c-]\\u003e++.\\u003e+.+++++++..+++.\\u003e++.\\u003c\\u003c+++++++++++++++.\\u003e.+++.------.--------.\\u003e+.\\u003e.
ਇੱਕ ਛੋਟੀ ਲੂਪ ਉਦਾਹਰਨ ਜੋ ਇੱਕ ਮੁੱਲ ਸੈੱਟ ਕਰਦੀ ਹੈ ਅਤੇ ਉਸਨੂੰ ਇੱਕ ਅੱਖਰ ਵਜੋਂ ਪ੍ਰਿੰਟ ਕਰਦੀ ਹੈ:
+++++[\\u003e++++++++\\u003c-]\\u003e.
ਸੁਝਾਅ: ਇੱਕ ਆਨਲਾਈਨ Brainfuck ਇੰਟਰਪ੍ਰੇਟਰ ਵਰਤੋ ਜੋ ਕਦਮ-ਬ-ਕਦਮ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦਿਖਾਉਂਦਾ ਹੈ ਤਾਂ ਜੋ ਤੁਸੀਂ ਹਰ ਹੁਕਮ ਚਲਾਉਣ ਵੇਲੇ ਟੇਪ ਦੇ ਬਦਲਾਅ ਨੂੰ ਦੇਖ ਸਕੋ।
Whitespace: ਉਹ ਪ੍ਰੋਗਰਾਮ ਜੋ ਤੁਸੀਂ ਦੇਖ ਨਹੀਂ ਸਕਦੇ
Whitespace ਇੱਕ ਐਸੋਲੈਂਗ ਹੈ ਜਿਸ ਵਿੱਚ ਸਿਰਫ ਸਪੇਸ, ਟੈਬ ਅਤੇ ਲਾਈਨ ਬ੍ਰੇਕ ਕੀਮਤੀ ਹੁੰਦੇ ਹਨ। ਹੋਰ ਸਭ ਕੁਝ ਇੱਕ ਟਿੱਪਣੀ ਵਜੋਂ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇੱਕ ਵਿਧਾਨੀਕ ਪ੍ਰੋਗ੍ਰਾਮ ਤੁਹਾਡੇ ਏਡੀਟਰ ਵਿੱਚ ਬਿਲਕੁਲ ਖਾਲੀ ਦਿਖ ਸਕਦਾ ਹੈ—ਅਤੇ ਫਿਰ ਵੀ ਚੱਲ ਸਕਦਾ ਹੈ।
ਇਹ ਕਿਉਂ ਐਕਸੋਟਿਕ ਹੈ
ਅਧਿਕਤਰ ਭਾਸ਼ਾਵਾਂ ਦਿੱਖਣਯੋਗ ਕੀਵਰਡਾਂ ਅਤੇ ਵਿਸਰਗਾਂ ਵਰਤਦੀਆਂ ਹਨ। Whitespace ਉਹ ਉਮੀਦ ਉਲਟ ਕਰ ਦਿੰਦੀ ਹੈ: ਸਾਰਾ ਸਰੋਤ ਕੋਡ ਅਦ੍ਰਿਸ਼ ਹੋ ਸਕਦਾ ਹੈ ਜੇ ਤਕ ਤੁਸੀਂ ਇਸਨੂੰ ਵਿਸ਼ੇਸ਼ ਸੈਟਿੰਗਸ ਨਾਲ ਨਾ ਦਿਖਾਓ। ਇਹ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਕਿੰਨੀ ਹੱਦ ਤੱਕ ਪ੍ਰਚਲਿਤ ਨਿਯਮਾਂ, ਟੂਲਿੰਗ ਅਤੇ ਮਨੁੱਖੀ ਨਜ਼ਰ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ।
ਇਹ ਕੀ ਸਿਖਾਉਂਦਾ ਹੈ (ਅਤੇ ਕਿਉਂ ਇਹ ਹੈਰਾਨ ਕਰਕੇ ਪ੍ਰਯੋਗਿਕ ਹੈ)
Whitespace ਤੁਹਾਨੂੰ ਨੀਵੀਂ ਪੱਧਰ 'ਤੇ ਪਾਰਸਿੰਗ ਅਤੇ ਟੋਕਨਾਈਜੇਸ਼ਨ ਬਾਰੇ ਸੋਚਣ 'ਤੇ ਮਜਬੂਰ ਕਰਦਾ ਹੈ:
- ਜਦਕਿ ਉਹ ਦਿੱਖਦੇ ਨਹੀਂ, ਤੁਸੀਂ ਟੋਕਨ ਕਿਵੇਂ ਵਿਸ਼ਵਾਸਯੋਗ ਢੰਗ ਨਾਲ ਅਲੱਗ ਕਰਦੇ ਹੋ?\n- ਨਿਊਨਤਮ ਚਿੰਨ੍ਹਾਂ ਨਾਲ ਗਿਣਤੀ ਅਤੇ ਆਪਰੇਸ਼ਨਾਂ ਨੂੰ ਕਿਵੇਂ ਦਰਸਾਇਆ ਜਾਵੇ?\n- ਇੱਕ ਛੋਟੀ ਚਰੈਕਟਰ ਸੈੱਟ ਦੇ ਪਿੱਛੇ ਕਿੰਨੀ ਜਟਿਲਤਾ ਲੁਕ ਸਕਦੀ ਹੈ?
ਜੇ ਤੁਸੀਂ ਕਦੇ ਛੋਟਾ ਪਾਰਸਰ ਬਣਾਇਆ, ਲੇਕਸਰ ਲਿਖਿਆ, ਜਾਂ ਅਸਲ ਕੋਡ ਵਿੱਚ “ਅਦ੍ਰਿਸ਼” ਅੱਖਰਾਂ (ਮਿਸ਼ਰਤ ਟੈਬ/ਸਪੇਸ, ਅਜੀਬ ਲਾਈਨ ਐਂਡਿੰਗ) ਦੀ ਡੀਬੱਗਿੰਗ ਕੀਤੀ ਹੈ, ਤਾਂ Whitespace ਉਸ ਦਰਦ ਨੂੰ ਸਿੱਖਣ ਵਾਲੇ ਅਭਿਆਸ ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ।
ਕਿਹੜੀ ਗੱਲ ਧਿਆਨ ਰੱਖਣੀ ਹੈ
ਡੀਬੱਗਿੰਗ ਸਭ ਤੋਂ ਵੱਡੀ ਚੁਣੌਤੀ ਹੈ। ਇੱਕ ਗਲਤ ਟੈਬ ਜਾਂ ਲਾਈਨਫੀਡ ਪੂਰੀ ਮਾਇਨੇ ਬਦਲ ਸਕਦਾ ਹੈ।
ਵਿਜ਼ੂਲਾਈਜ਼ਰ (ਉਹ ਟੂਲ ਜੋ ਸਪੇਸ/ਟੈਬ/ਨਿਊਲਾਈਨ ਨੂੰ ਦਿੱਖਾਉਂਦੇ ਹਨ) ਅਤੇ ਐਡੀਟਰ ਜਿਹੜੇ “invisibles” ਦਿਖਾਉਂਦੇ ਹਨ, ਵਰਤੋ। ਬਿਨਾਂ ਉਹਨਾਂ ਦੇ, ਆਪਣਾ ਕੋਡ ਬਾਅਦ ਵਿੱਚ ਪੜ੍ਹਨਾ ਵੀ ਨਿਰਾਸ਼ਾਜਨਕ ਹੋ ਸਕਦਾ ਹੈ।
ਅਜ਼ਮਾਓ
ਇੱਕ ਕੁਨਿਸ਼ ਪ੍ਰੋਗ੍ਰਾਮ ਲਿਖੋ ਜੋ ਇੱਕ ਅੱਖਰ ਜਾਂ ਨੰਬਰ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ, ਫਿਰ ਉਹੀ ਵਰਤੋਂ ਇੱਕ ਆਮ ਭਾਸ਼ਾ (Python/JavaScript) ਵਿੱਚ ਲਿਖੋ। ਤੁਲਨਾ ਕਰੋ:
- ਕੋਡ ਦੀ ਲੰਬਾਈ ਵਿਰੁੱਧ ਸਪਸ਼ਟਤਾ
- ਤੁਸੀਂ ਕਿਵੇਂ ਟੈਸਟ ਅਤੇ ਡੀਬੱਗ ਕਰਦੇ ਹੋ
- ਜਦ ਸਰੋਤ ਪੜ੍ਹਨਯੋਗ ਨਹੀਂ ਹੁੰਦਾ ਤਾਂ ਤੁਹਾਡੀ ਮਨੁੱਖੀ ਦਸਤਾਵੇਜ਼ੀ ਕਿਵੇਂ ਦਰਸਾਈ ਜਾਂਦੀ ਹੈ
Befunge: ਦੋ-ਆਯਾਮੀ, ਸਵੈ-ਸੰਸ਼ੋਧਨ ਕੋਡ
Befunge ਅਨੋਖਾ ਹੈ ਕਿਉਂਕਿ ਪ੍ਰੋਗ੍ਰਾਮ ਪੰਕਤੀਆਂ ਵਿੱਚ ਸਟੇਟਿਕ ਟੈਕਸਟ ਨਹੀਂ ਹੁੰਦਾ ਜੋ ਤੁਸੀਂ ਉੱਪਰ ਤੋਂ ਹੇਠਾਂ ਪੜ੍ਹਦੇ ਹੋ। ਇਸ ਦੀ ਥਾਂ, ਇਹ 2D ਗ੍ਰਿਡ 'ਤੇ ਰਹਿੰਦਾ ਹੈ, ਅਤੇ ਨਿਰਦੇਸ਼ ਪੌਇੰਟਰ ਉਥੇ-ਉਥੇ ਘੁੰਮਦਾ ਹੈ—ਸੱਜੇ, ਖੱਬੇ, ਉੱਪਰ ਅਤੇ ਹੇਠਾਂ—ਤੁਸੀਂ ਕੋਡ ਵਿੱਚ ਰੱਖੇ ਤੇਰਿੰਦੀਆਂ ਦੀ ਪਾਲਣਾ ਕਰਦੇ ਹੋ। ਇਹ ਇੱਕ ਸਕ੍ਰਿਟ ਲਿਖਣ ਦੀ ਥਾਂ ਇੱਕ ਛੋਟੀ ਸਰਕਿਟ ਡਾਇਗ੍ਰਾਮ ਜਾਂ ਪਿਨਬਾਲ਼ ਟੇਬਲ ਨੂੰ ਨੈਵੀਗੇਟ ਕਰਨ ਵਰਗਾ ਮਹਿਸੂਸ ਹੁੰਦਾ ਹੈ।
ਇਹ ਇਤਨਾ ਅਜੀਬ (ਅਤੇ ਵਧੀਆ) ਕਿਉਂ ਹੈ
ਅਧਿਕਤਰ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ, ਕੋਡ ਫਿਕਸਡ ਟੈਕਸਟ ਹੁੰਦਾ ਹੈ। Befunge ਵਿੱਚ, ਪ੍ਰੋਗ੍ਰਾਮ ਚਲਦੇ ਸਮੇਂ ਆਪਣਾ ਆਪ- ਨੂੰ ਸੋਧ ਸਕਦਾ ਹੈ: ਨਿਰਦੇਸ਼ ਨਵੇਂ ਅੱਖਰ ਗ੍ਰਿਡ ਵਿੱਚ ਲਿਖ ਸਕਦੇ ਹਨ, ਜਿਸ ਨਾਲ ਅਗਲਾ ਐਗਜ਼ੀਕਿਊਟ ਹੋਣ ਵਾਲਾ ਹਿੱਸਾ ਬਦਲ ਜਾਂਦਾ ਹੈ। ਇਹ ਸਵੈ-ਸੰਸ਼ੋਧਨ ਯੋਗਤਾ ਭਾਸ਼ਾ ਦੀ ਪਛਾਣ ਦਾ ਹਿੱਸਾ ਹੈ ਅਤੇ ਇਹ ਹੈਰਾਨ ਕਰਨ ਵਾਲੇ ਪਹੇਲੀ-ਟਰਕ ਪ੍ਰੋਗ੍ਰਾਮ ਪੈਦਾ ਕਰ ਸਕਦੀ ਹੈ।
ਇਹ ਤੁਹਾਨੂੰ ਕੀ ਸਿਖਾਉਂਦੀ ਹੈ
Befunge ਤੁਹਾਨੂੰ ਡੇਟਾ-ਫਲੋ ਅਤੇ ਸਟੇਟ-ਮਸ਼ੀਨ ਸੋਚ ਵੱਲ ਧਪਕਾਉਂਦੀ ਹੈ: ਤੁਸੀਂ ਰਾਹਾਂ ਦੀ ਯੋਜਨਾ ਬਣਾਉਂਦੇ ਹੋ, ਲੂਪ ਅਸਲ ਵਿੱਚ ਰੂਟ ਹੁੰਦੇ ਹਨ, ਅਤੇ branching ਰੂਟ-ਮੁੜਾਉ ਹੈ। ਕਈ ਦਿਸ਼ਾਵਾਂ ਕੁਦਰਤੀ ਹੁੰਦੀਆਂ ਹਨ, ਇਸ ਲਈ ਤੁਸੀਂ ਅਕਸਰ ਪੈਰਲੈਲ ਤੋਂ ਮਿਲਦੇ-जੁਲਦੇ ਫਲੋਜ਼ ਬਾਰੇ ਸੋਚ ਸਕਦੇ ਹੋ (ਭਾਵੇਂ ਤੁਹਾਡਾ ਇੰਟਰਪ੍ਰੇਟਰ ਇੱਕ-ਇੱਕ ਹੁਕਮ ਚਲਾ ਰਹਾ ਹੋਵੇ)।
ਕਿੱਥੇ ਇਹ ਫਿੱਟ ਬੈਠਦਾ ਹੈ
Befunge ਖੇਡ-ਜੋਗ ਸੰਦਰਭਾਂ ਵਿੱਚ ਚਮਕਦਾ ਹੈ: ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਪਹੇਲੀਆਂ, ਕੋਡ ਗੋਲਫ, ਇੰਟਰਐਕਟਿਵ ਇੰਸਟਾਲੇਸ਼ਨ ਜਿੱਥੇ ਵਿਲੱਖਣ ਜਨਰੇਟਿਵ ਵਿਹਾਰ ਚਾਹੀਦਾ ਹੈ, ਜਾਂ ਛੋਟੇ ਡੈਮੋ ਜਿੱਥੇ ਕੋਡ ਆਪਣੇ ਆਪ ਵਿੱਚ ਕਲਾ ਹੈ।
ਅਜ਼ਮਾਓ: ਇੱਕ ਛੋਟੀ ਸੰਖਿਆ ਰੂਪਾਂਤਰਕ
ਇੱਥੇ ਇੱਕ ਸਧਾਰਨ Befunge-93 ਪ੍ਰੋਗ੍ਰਾਮ ਹੈ ਜੋ ਇੱਕ ਅੰਕ ਪੜ੍ਹਦਾ ਹੈ ਅਤੇ ਉਸ ਦਾ ਦੂਨਾ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ:
\\u00262*.
ਇਹ ਕਿਸੇ ਵੀ Befunge ਇੰਟਰਪ੍ਰੇਟਰ ਵਿੱਚ ਚਲਾਓ: ਇੱਕ ਨੰਬਰ (0–9) ਟਾਈਪ ਕਰੋ, ਅਤੇ ਇਹ ਨਤੀਜਾ ਆউਟਪੁੱਟ ਕਰੇਗਾ। ਇਸ ਤੋਂ ਬਾਅਦ, ਦਿਸ਼ਾ ਤੀਰ (\\u003e \\u003c ^ v) ਅਤੇ ਵਾਧੂ ਸੈਲ ਸ਼ਾਮਲ ਕਰਕੇ ਪ੍ਰਯੋਗ ਕਰੋ ਤਾਂ ਕਿ ਨਿਰਦੇਸ਼ ਪੌਇੰਟਰ ਸਿੱਧੀ ਲਾਈਨ ਦੀ ਥਾਂ “ਰਾਹ” ਲਏ।
Hexagony: ਹੈਕਸ ਗ੍ਰਿਡ 'ਤੇ ਕੋਡਿੰਗ
ਅਣ-ਭਰੋਸੇਮੰਦ ਕੋਡ ਨੂੰ ਸੁਰੱਖਿਅਤ ਤਰੀਕੇ ਨਾਲ ਸੈਂਡਬਾਕਸ ਕਰੋ
ਇੱਕ ਨਾਸ਼ਪੱਦਾ ਵਾਤਾਵਰਨ ਚਲਾਓ ਅਤੇ ਰਨਸ ਦੇ ਵਿੱਚ ਸਟੇਟ ਨੂੰ ਰੀਸੈਟ ਕਰੋ।
Hexagony ਅਨੋਖਾ ਹੈ ਕਿਉਂਕਿ ਤੁਹਾਡਾ ਪ੍ਰੋਗ੍ਰਾਮ ਪੰਕਤੀਆਂ ਦਾ ਲਾਈਨ ਨਹੀਂ ਹੁੰਦਾ—ਇਹ ਇੱਕ ਹੈਕਸਾਗੋਨਲ “ਹਨੀਕਾਂਬ” ਸੈੱਲਾਂ 'ਤੇ ਰੱਖਿਆ ਹੁੰਦਾ ਹੈ। ਇੱਕ ਨਿਰਦੇਸ਼ ਪੌਇੰਟਰ ਉਸ ਗ੍ਰਿਡ 'ਤੇ ਘੁੰਮਦਾ ਹੈ, ਕਿਨਾਰਿਆਂ 'ਤੇ ਮੁੜਦਾ ਹੈ ਅਤੇ ਗ੍ਰਿਡ ਦੀ ਭੂਗੋਲਿਕਤਾ ਅਨੁਸਾਰ ਨਿਯਮਾਂ ਨੂੰ ਫਾਲੋ ਕਰਦਾ ਹੈ। ਇਹ ਇੱਕ ਤਖਤ ਖੇਡ ਨੂੰ ਨੈਵੀਗੇਟ ਕਰਨ ਵਰਗਾ ਮਹਿਸੂਸ ਕਰਵਾਉਂਦਾ ਹੈ ਨਾ ਕਿ ਆਮ ਕੋਡ ਲਿਖਣ ਵਰਗਾ।
ਇਹ ਕਿਹੜੀਆਂ ਗੱਲਾਂ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸਿਖਾਉਂਦਾ ਹੈ
Hexagony ਤੁਹਾਨੂੰ ਸਪੇਸ਼ਲੀ ਤਰੀਕੇ ਨਾਲ ਸੋਚਣ ਦੀ ਪ੍ਰੇਰਣਾ ਦਿੰਦਾ ਹੈ: ਕਿੱਥੇ ਇੱਕ ਨਿਰਦੇਸ਼ ਰਿਹਾ ਹੈ ਉਹ ਉਨ੍ਹਾਂ ਦੀ ਉੱਤਮਤਾ ਦੇ ਬਰਾਬਰ ਮਹੱਤਵ ਰਖਦਾ ਹੈ ਜੋ ਇਹ ਕਰਦਾ ਹੈ। ਇਸ ਨਾਲ ਤੁਸੀਂ ਅਭਿਆਸ ਕਰ ਸਕਦੇ ਹੋ:
- ਸਪੇਸ਼ਲ ਰੀਜ਼ਨਿੰਗ: ਤੁਸੀਂ ਰੋਟਾਂ ਦੀ ਯੋਜਨਾ ਬਣਾਉਂਦੇ ਹੋ, ਨਾ ਕਿ ਸਿਰਫ ਕ੍ਰਮ।
- ਸਟੇਟ ਮਸ਼ੀਨਾਂ: ਮੂਵਮੈਂਟ ਦੀ ਦਿਸ਼ਾ ਅਤੇ ਸੈੱਲ ਦੀ ਵਿਹਾਰ “ਸਟੇਟ” ਬਣ ਜਾਂਦੀ ਹੈ ਜਿਸਨੂੰ ਤੁਸੀਂ ਮੈਨੇਜ ਕਰਦੇ ਹੋ।
- ਪਾਬੰਦੀ ਸੋਚ: ਸੀਮਤ ਥਾਂ ਤੁਹਾਨੂੰ ਸੰਕੁਚਿਤ, ਇੱਛਿਤ ਕੰਟਰੋਲ ਫਲੋ ਵੱਲ ਧਕਾਉਂਦੀ ਹੈ।
ਉਮੀਦ: ਪਹਿਲਾਂ ਮਜ਼ਾ, ਬਾਅਦ ਵਿੱਚ ਉਤਪਾਦਕਤਾ
ਇਹ ਤਲਾਸ਼ ਅਤੇ ਪ੍ਰਯੋਗ ਲਈ ਹੈ। ਤੁਸੀਂ ਕੰਮ 'ਤੇ Python ਜਾਂ JavaScript ਦੀ ਥਾਂ Hexagony ਨਹੀਂ ਵਰਤੋਂਗੇ, ਪਰ ਤੁਸੀਂ ਇੰਟਰਪ੍ਰੇਟਰ, ਨਿਰਦੇਸ਼ ਪੌਇੰਟਰ, ਅਤੇ ਕੰਟਰੋਲ ਫਲੋ ਦੇ ਕੰਮ ਕਰਨ ਬਾਰੇ ਤੇਜ਼ ਤਜਰਬਾ ਹਾਸਲ ਕਰੋਗੇ।
ਅਜ਼ਮਾਓ: ਮੂਵਮੈਂਟ ਨਿਯਮਾਂ ਦਾ ਇੱਕ ਛੋਟਾ ਵਾਕਥਰੂ
ਛੋਟੇ ਗ੍ਰਿਡ ਦੀ ਕਲਪਨਾ ਕਰੋ ਜਿੱਥੇ ਹਰ ਸੈੱਲ ਇੱਕ ਅੱਖਰ ਨਿਰਦੇਸ਼ ਰੱਖਦਾ ਹੈ। ਤੁਸੀਂ ਨਿਰਦੇਸ਼ ਪੌਇੰਟਰ ਨੂੰ ਇੱਕ ਸ਼ੁਰੂਆਤੀ ਸੈੱਲ 'ਤੇ ਕਿਸੇ ਦਿਸ਼ਾ (ਹੈਕਸ ਗ੍ਰਿਡ 'ਤੇ ਛੇ ਸੰਭਵ ਦਿਸ਼ਾਵਾਂ) ਨਾਲ ਰੱਖਦੇ ਹੋ। ਫਿਰ:
- ਮੌਜੂਦਾ ਸੈੱਲ ਦਾ ਨਿਰਦੇਸ਼ ਪੜ੍ਹੋ (ਉਦਾਹਰਨ: ਦਿਸ਼ਾ ਬਦਲੋ, ਗਣਿਤ ਕਰੋ, ਮੁੱਲ ਪੜ੍ਹੋ/ਲਿਖੋ)।
- ਮੌਜੂਦਾ ਦਿਸ਼ਾ ਵਿੱਚ ਅਗਲੇ ਸੈੱਲ 'ਤੇ ਜਾਓ।
- ਜਦ ਤੁਸੀਂ ਕਿਨਾਰੇ 'ਤੇ ਪਹੁੰਚਦੇ ਹੋ, ਪੌਇੰਟਰ ਗ੍ਰਿਡ ਦੀ ਭੌਗੋਲਿਕਤਾ ਅਨੁਸਾਰ “ਰੈਪ” ਜਾਂ ਮੁੜਦਾ ਹੈ।
ਪਹਿਲੀ ਕਸਰਤ: ਇੱਕ ਪ੍ਰੋਗ੍ਰਾਮ ਤੇ ਕਦਮ-ਬ-ਕਦਮ ਚਲੋ ਜੋ ਸਿਰਫ ਦਿਸ਼ਾ ਬਦਲਦਾ ਹੈ ਅਤੇ ਇੱਕ ਅੱਖਰ ਆਉਟਪੁੱਟ ਕਰਦਾ ਹੈ—ਇਸ ਨਾਲ ਤੁਸੀਂ ਮਹਿਸੂਸ ਕਰੋਗੇ ਕਿ ਨੈਵੀਗੇਸ਼ਨ ਹੀ ਕੰਟਰੋਲ ਫਲੋ ਹੈ। ਜੇ ਤੁਸੀਂ ਸੁਰੱਖਿਅਤ ਪਲੇਗ੍ਰਾਊਂਡ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ ਆਨਲਾਈਨ ਇੰਟਰਪ੍ਰੇਟਰ ਅਤੇ ਸਿੰਗਲ-ਸਟੈਪ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਵਰਤੋ (ਦੇਖੋ /blog/how-to-try-esoteric-languages-safely)।
Wolfram Language: ਨਿਯਮ-ਅਧਾਰਤ ਸੋਚ ਵੱਡੇ ਪੱਧਰ 'ਤੇ
ਅਧਿਕਤਰ ਭਾਸ਼ਾਵਾਂ ਤੁਹਾਨੂੰ ਕਦਮ-ਬ-ਕਦਮ ਵੇਰਵਾ ਕਰਨ ਲਈ ਪ੍ਰੋਤਸਾਹਿਤ ਕਰਦੀਆਂ ਹਨ: ਇਹ ਕਰੋ, ਫਿਰ ਉਹ ਕਰੋ, ਲੂਪ ਤੱਕ। Wolfram Language ਐਸਾ ਮਹਿਸੂਸ ਕਰਵਾਉਂਦੀ ਹੈ ਕਿਉਂਕਿ ਤੁਸੀਂ ਅਕਸਰ ਨਿਯਮ ਵਰਣਨ ਕਰ ਸਕਦੇ ਹੋ—ਰਿਸ਼ਤੇ ਅਤੇ ਤਬਦੀਲੀਆਂ—ਅਤੇ ਸਿਸਟਮ ਉਹਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ।
ਇਹ ਕਿਉਂ ਐਕਸੋਟਿਕ ਹੈ
ਆਧਾਰ ਵਿੱਚ, Wolfram Language ਰੂਪਾਤਮਕ ਅਤੇ ਨਿਯਮ-ਅਧਾਰਤ ਹੈ। ਤੁਸੀਂ ਪੈਟਰਨ ਲਿਖਦੇ ਹੋ ਜੋ ਇਕ ਅਭਿਵ्यਕਤੀ ਦੇ ਹਿੱਸਿਆਂ ਨੂੰ ਮੈਚ ਕਰਦੇ ਹਨ, ਫਿਰ ਇਹ ਦਰਸਾਉਂਦੇ ਹੋ ਕਿ ਕਿਵੇਂ ਉਨ੍ਹਾਂ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖਣਾ ਹੈ। ਮੈਨੁਅਲ ਕন্ট੍ਰੋਲ ਫਲੋ ਦੀ ਥਾਂ, ਤੁਸੀਂ ਪੈਟਰਨ ਮੈਚਿੰਗ ਅਤੇ ਤਬਦੀਲੀ ਨਿਯਮਾਂ 'ਤੇ ਨਿਰਭਰ ਰਹਿਣ ਦਿੰਦੇ ਹੋ।
ਇਹ ਕੀ ਸਿਖਾਉਂਦਾ ਹੈ
ਇਹ ਸ਼ੈਲੀ ਤੁਹਾਨੂੰ ਟਰਨ-ਰਾਈਟਿੰਗ (term rewriting) ਵਿੱਚ ਪ੍ਰਵੇਸ਼ ਕਰਵਾਉਂਦੀ ਹੈ: ਗਣਨਾ ਦੀ ਇੱਕ ਸ਼ੈਲੀ ਜਿਸ ਵਿੱਚ ਵਾਰ-ਵਾਰ ਬਦਲਾਅ ਹੁੰਦਾ ਹੈ। ਤੁਸੀਂ ਮਹਿਸੂਸ ਕਰਨ ਲੱਗੋਗੇ ਕਿ ਬਹੁਤ ਸਾਰੇ “ਅਲਗੋਰਿਥਮ” ਇਕ ਛੋਟੀ ਨਿਯਮ-ਸੈੱਟ ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਰਣਨੀਤੀ ਹੁੰਦੀ ਹੈ। ਇਹ ਪੈਟਰਨ ਮੈਚਿੰਗ ਲਈ ਵੀ ਅਹਿਮ ਹੁੰਦਾ ਹੈ—ਸਿਰਫ ਸਤਰਾਂ 'ਤੇ ਨਹੀਂ, ਸਗੋਂ ਸੰਰਚਿਤ ਅਭਿਵਯਕਤੀਆਂ 'ਤੇ ਵੀ।
ਜਦ ਇਹ ਲਾਭਦਾਇਕ ਹੈ
ਨਿਯਮ-ਅਧਾਰਿਤ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਚੰਗੀ ਹੈ ਜਿੱਥੇ ਤੁਸੀਂ ਤਬਦੀਲੀਆਂ ਮਾਡਲ ਕਰ ਰਹੇ ਹੋ: ਬੀਜਗਣਿਤ ਸਧਾਰਨ ਕਰਨਾ, ਸੁਤਰਾਂ ਨੂੰ ਮੁੜ-ਲਿਖਣਾ, ਦਰੱਖ਼ਤਾਂ ਦੀ ਹੇਲ-ਚਲ, ਫਾਰਮੇਟ ਬਦਲਣਾ, ਜਾਂ ਉਹਨੂੰ ਪ੍ਰਗਟ ਕਰਨਾ ਜਿੱਥੇ ਨਿਯਮ ਪ੍ਰਕਿਰਿਆ ਨਾਲੋਂ ਜ਼ਿਆਦਾ ਮਹੱਤਵ ਰਖਦੇ ਹਨ।
ਅਜ਼ਮਾਓ: ਇੱਕ ਛੋਟੀ ਰੀਰਾਈਟ ਸਿਸਟਮ
ਇਸ ਨੂੰ Wolfram Language ਵਿੱਚ ਪੇਸਟ ਕਰੋ ਅਤੇ ਦੇਖੋ ਕਿ ਕੁਝ ਨਿਯਮ ਕਿਵੇਂ ਹੈਰਾਨ ਕਰਨ ਵਾਲਾ ਵਿਹਾਰ ਪੈਦਾ ਕਰਦੇ ਹਨ:
rules = {
x_ + 0 -\\u003e x,
0 + x_ -\\u003e x,
x_ * 1 -\\u003e x,
1 * x_ -\\u003e x,
x_ + x_ -\\u003e 2 x
};
expr = (a + 0) + (a + a) * 1;
FixedPoint[# //. rules \\u0026, expr]
ਫਿਰ ਇਕ ਨਿਯਮ (ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਡਿਸਟ੍ਰਿਬਿਊਟਿਵ ਰੀਰਾਈਟ) ਸ਼ਾਮਲ ਕਰਕੇ ਦੇਖੋ ਕਿ ਸਿਸਟਮ ਦੀ “ਪर्सਨਾਲਟੀ” ਕਿਵੇਂ ਬਦਲਦੀ ਹੈ।
APL ਅਤੇ BQN: ਚਿੰਨ੍ਹ-ਭਰਿਆ ਐਰੇ ਤਾਕਤ
APL ਅਤੇ ਇਸ ਦਾ ਆਧੁਨਿਕ ਸੰਗੀ BQN ਐਸੇ “ਐਕਸੋਟਿਕ” ਮਹਿਸੂਸ ਹੁੰਦੇ ਹਨ ਕਿਉਂਕਿ ਉਹ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਦਾ ਡਿਫੌਲਟ ਮਾਨਸਿਕ ਮਾਡਲ ਉਲਟ ਦਿੰਦੇ ਹਨ। ਸਿੰਗਲ ਮੁੱਲ ਅਤੇ ਲੂਪ ਬਾਰੇ ਸੋਚਣ ਦੀ ਥਾਂ, ਤੁਸੀਂ ਹਰ ਚੀਜ਼ ਨੂੰ ਇੱਕ ਐਰੇ (ਲਿਸਟ, ਟੇਬਲ, ਜਾਂ ਉੱਚ-ਆਯਾਮੀ ਡੇਟਾ) ਸਮਝਦੇ ਹੋ, ਅਤੇ ਬਹੁਤ ਸਾਰੇ آپਰੇਸ਼ਨ ਆਟੋਮੈਟਿਕ ਤੌਰ 'ਤੇ ਪੂਰੇ ਸੰਗ੍ਰਹਿ 'ਤੇ ਲਾਗੂ ਹੁੰਦੇ ਹਨ।
ਇਹ ਕਿਉਂ ਐਕਸੋਟਿਕ ਹੈ: ਪਹਿਲਾਂ ਐਰੇ, ਹਰ ਜਗਾਹ ਬਰਾਡਕਾਸਟ
ਆਮ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ, ਇੱਕ ਲਿਸਟ ਵਿੱਚ ਇੱਕ ਨੰਬਰ ਜੋੜਨਾ ਲਈ ਲੂਪ ਜਾਂ ਇੱਕ ਹੈਲਪਰ ਫੰਗਸ਼ਨ ਲੋੜੀਂਦਾ ਹੈ। APL/BQN ਵਿੱਚ, “10 ਜੋੜੋ” ਦਾ ਮਤਲਬ ਹੋ ਸਕਦਾ ਹੈ “ਹਰ ਤੱਤ ਵਿੱਚ 10 ਜੋੜੋ,” ਅਤੇ ਭਾਸ਼ਾ ਇਹ ਕੁਦਰਤੀ ਵਿਆਖਿਆ ਬਨਾਉਂਦੀ ਹੈ। ਇਸ ਬਰਾਡਕਾਸਟਿੰਗ ਵਿਹਾਰ ਦੀ ਤਾਕਤ ਹੈ—ਪਰ ਅਸਲ ਹੈਰਾਨੀ ਨੋਟੇਸ਼ਨ ਹੈ: ਸੰਖੇਪ ਚਿੰਨ੍ਹ (glyphs) ਆਮ آپਰੇਸ਼ਨਾਂ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ, ਇਸ ਲਈ ਪ੍ਰੋਗ੍ਰਾਮ ਘਣ ਹੋ ਸਕਦੇ ਹਨ।
ਇਹ ਕੀ ਸਿਖਾਉਂਦਾ ਹੈ: ਵੇਕਟਰ ਸੋਚ ਅਤੇ ਸੋਚ-ਬਚਤ ਸੰਕੁਚਨ
APL/BQN ਵਿੱਚ ਕੰਮ ਕਰਨ ਨਾਲ ਤੁਸੀਂ ਪੁੱਛਣ ਲੱਗਦੇ ਹੋ: “ਮੇਰੇ ਡੇਟਾ ਦੀ ਸ਼ਕਲ ਕੀ ਹੈ?” ਅਤੇ “ਕੀ ਮੈਂ ਇਸਨੂੰ ਪੂਰੇ-ਐਰੇ ਤਬਦੀਲ ਵਜੋਂ ਦਰਸਾ ਸਕਦਾ ਹਾਂ?” ਤੁਸੀਂ ਕਦਮ-ਦਰ-ਕਦਮ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੀ ਥਾਂ ਛੋਟੀ ਕਿਛ ਏਕ ਵਿਆਖ੍ਯਾ ਵਾਲੀਆਂ ਡੇਟਾ ਆਪਰੇਸ਼ਨਾਂ ਨੂੰ ਵਰਤਣਾ ਸਿਖੋਗੇ: reshape, sort, group, reduce (ਜੋੜ), scan (ਚਲਦੀ ਕُل), ਅਤੇ outer products।
ਕਿੱਥੇ ਇਹ ਚਮਕਦਾ ਹੈ: ਵਿਸ਼ਲੇਸ਼ਣ, ਫਾਇਨੈਂਸ, ਸਿਮੁਲੇਸ਼ਨ
ਜੇ ਤੁਹਾਡਾ ਕੰਮ ਕੰਲਮਾਂ, ਮੈਟ੍ਰਿਕਸਾਂ, ਅਤੇ ਟਾਈਮ ਸੀਰੀਜ਼ਾਂ ਨੂੰ ਸੰਭਾਲਣਾ ਹੈ, ਤਾਂ ਐਰੇ ਭਾਸ਼ਾਵਾਂ ਬਹੁਤ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਇਸੀ ਲਈ ਉਹਨਾਂ ਦਾ ਫਾਇਨੈਂਸ ਅਤੇ ਵਿਗਿਆਨਕ ਕੰਪਿਊਟਿੰਗ ਵਿੱਚ ਜ਼ੋਰ ਰਹਿਆ ਹੈ, ਅਤੇ BQN ਉਹਨਾਂ ਵਿਕਾਸਕਾਰਾਂ ਨੂੰ ਆਕਰਸ਼ਿਤ ਕਰਦਾ ਹੈ ਜੋ ਐਰੇ ਮਹਾਰਤਾਂ ਇੱਕ ਆਧੁਨਿਕ ਅਹਿਸਾਸ ਨਾਲ ਚਾਹੁੰਦੇ ਹਨ।
ਅਜ਼ਮਾਓ: ਇੱਕ ਲੂਪ ਨੂੰ ਐਰੇ ਅਭਿਵਿਆਕਤੀ ਵਿੱਚ ਦੁਬਾਰਾ ਲਿਖੋ
ਇੱਕ ਜਾਣੂ ਕੰਮ ਚੁਣੋ—ਜਿਵੇਂ ਕਿ ਨੰਬਰਾਂ ਦੀ ਸੂਚੀ ਨਾਰਮਲਾਈਜ਼ ਕਰਨਾ ਜਾਂ ਮੂਵਿੰਗ ਐਵਰੇਜ ਗਣਨਾ—ਅਤੇ ਇਸਨੂੰ ਦੋ ਵਾਰੀ ਲਿਖੋ: ਇੱਕ ਲੂਪ ਨਾਲ, ਇੱਕ “ਹੋਲ-ਐਰੇ” ਤਬਦੀਲੀਆਂ ਦੇ ਰੂਪ ਵਿੱਚ। ਭਾਵੇਂ ਚਿੰਨ੍ਹ ਪਰਾਚੀਨ ਲੱਗਣ, ਇਹ ਅਭਿਆਸ ਤੁਹਾਨੂੰ ਸਿਖਾਏਗਾ ਕਿ ਕਿਵੇਂ ਗਣਨਾ ਨੂੰ ਡੇਟਾ-ਫਲੋ ਵਜੋਂ ਵੇਖਿਆ ਜਾਵੇ ਨਾ ਕਿ ਕੰਟਰੋਲ ਫਲੋ ਵਜੋਂ।
J ਅਤੇ K: ਸੰਘਣੇ, ਜੋੜਨਯੋਗ ਐਰੇ ਭਾਸ਼ਾਵਾਂ
ਸਿੱਖਦੇ ਸਮੇਂ ਕ੍ਰੈਡਿਟਸ ਹਾਸਲ ਕਰੋ
ਜੋ ਤੁਸੀਂ ਬਣਾਉਂਦੇ ਹੋ ਉਹ ਸਾਂਝਾ ਕਰੋ ਅਤੇ ਸਮੱਗਰੀ ਜਾਂ ਰੈਫਰਲਾਂ ਰਾਹੀਂ ਕ੍ਰੈਡਿਟਸ ਪ੍ਰਾਪਤ ਕਰੋ।
J ਅਤੇ K “ਐਕਸੋਟਿਕ” ਹਨ ਕਿਉਂਕਿ ਉਹ ਤੁਹਾਨੂੰ ਪੂਰੇ ਐਰੇ (ਲਿਸਟ, ਟੇਬਲ) ਅਤੇ ਰਚਨਾਵਾਂ ਵਿੱਚ ਸੋਚਣ ਲਈ ਪ੍ਰੇਰਿਤ ਕਰਦੇ ਹਨ, ਬਜਾਏ ਕਿ ਕਦਮ-ਦਰ-ਕਦਮ ਹਦਾਇਤਾਂ ਦੇ। ਤੁਸੀਂ ਲੂਪਾਂ ਅਤੇ ਅਸਥਾਈ ਵੇਰੀਏਬਲਾਂ ਲਿਖਣ ਦੀ ਥਾਂ ਛੋਟੇ ਫੰਕਸ਼ਨਾਂ ਦੀਆਂ ਪਾਈਪਲਾਈਨਾਂ ਬਣਾਉਂਦੇ ਹੋ—ਅਕਸਰ ਇੰਨੀ ਸੰਖੇਪ ਕਿ ਉਹ ਪਿਛਲੇਚਿੰਨ੍ਹ ਵਾਂਗ ਲੱਗਦੇ ਹਨ।
ਇਹ ਕਿਉਂ ਐਕਸੋਟਿਕ ਹੈ: ਫੰਗਸ਼ਨ ਰਚਨਾ ਅਤੇ ਪਾਈਪਲਾਈਨ ਦੁਆਰਾ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ
ਦੋਹਾਂ ਭਾਸ਼ਾਵਾਂ ਚੇਨਿੰਗ آپਰੇਸ਼ਨਾਂ ਲਈ ਬਣੀਆਂ ਹਨ: ਕੁਝ ਡੇਟਾ ਲਓ, ਇਸਨੂੰ ਤਬਦੀਲ ਕਰੋ, ਘਟਾਓ, ਫਿਰ reshape ਕਰੋ। J “ਤacit” (ਪੁਆਇੰਟ-ਫ੍ਰੀ) ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਵਿੱਚ ਝੁਕਦੀ ਹੈ ਜਿੱਥੇ ਤੁਸੀਂ ਇਨਪੁੱਟ ਦਾ ਨਾਮ ਨਾ ਦੇਕੇ ਵਿਵਹਾਰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹੋ। K (ਅਤੇ ਇਸ ਦਾ q/kdb+ ਰਿਸ਼ਤੇਦਾਰ) ਵੀ ਇਸੇ ਤਰ੍ਹਾਂ ਸੰਕੋਚੀ ਅਤੇ ਤੇਜ਼, ਜੋੜਨਯੋਗ ਡੇਟਾ ਤਬਦੀਲੀਆਂ ਲਈ ਬਣੀ ਹੈ।
ਇਹ ਕੀ ਸਿਖਾਉਂਦਾ ਹੈ: ਤacit ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਅਤੇ ਪੌਇੰਟ-ਫ੍ਰੀ ਅੰਦਾਜ਼
J/K ਨਾਲ ਘੰਟਾ ਵੀ ਗੁਜ਼ਾਰਨ ਨਾਲ ਹੀ ਤੁਹਾਡੀ ਧਿਆਨ ਦੀ ਦਿਗਰੀ ਬਦਲ ਜਾਂਦੀ ਹੈ: ਤੁਸੀਂ ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ “ਮੈਂ ਕੀ ਤਬਦੀਲ ਕਰ ਰਿਹਾ ਹਾਂ?” ਦੀ ਥਾਂ “ਮੇਰਾ ਤਬਦੀਲ ਕੀ ਹੈ?” ਪੁੱਛਦੇ ਹੋ। ਤੁਸੀਂ ਪ੍ਰੋਗ੍ਰਾਮਾਂ ਨੂੰ ਗਣਿਤ ਵਾਂਗ ਪੜ੍ਹਨਾ ਸਿਖਦੇ ਹੋ, ਜਿੱਥੇ ਪਾਈਪਲਾਈਨ ਦੀ ਬਣਤਰ ਹੀ ਵਿਆਖਿਆ ਹੈ।
ਕਿੱਥੇ ਇਹ ਚਮਕਦਾ ਹੈ: ਡੇਟਾ ਤਬਦੀਲੀਆਂ ਅਤੇ ਸੁੰਦਰ ਛੋਟੇ ਹੱਲ
ਇਹ ਭਾਸ਼ਾਵਾਂ ਉਹ ਕੰਮ ਬਿਹਤਰ ਕਰਦੀਆਂ ਹਨ ਜੋ “ਇਸ ਸੰਗ੍ਰਹਿ ਤੋਂ ਇਹ ਨਿਕਾਲੋ” ਤਰ੍ਹਾਂ ਦੇ ਹਨ: ਰੈਂਕਿੰਗ, ਗਰੂਪਿੰਗ, ਨਾਰਮਲਾਈਜ਼ੇਸ਼ਨ, ਫਿਲਟਰਿੰਗ, ਅਤੇ ਛੋਟੀ ਖੋਜੀ ਵਿਸ਼ਲੇਸ਼ਣ। ਜਿੱਥੇ ਬਹੁਤ ਕੋਡ ਬੋਇਲਰਪਲੇਟ ਹੋਵੇ, ਇਹ ਖ਼ਾਸ ਤੌਰ 'ਤੇ ਸੰਤੋਸ਼ਜਨਕ ਹੁੰਦਾ ਹੈ।
ਅਜ਼ਮਾਓ: ਵੇਰੀਏਬਲਾਂ ਬਿਨਾਂ ਇੱਕ ਛੋਟੀ ਪਾਈਪਲਾਈਨ ਬਣਾਓ
J ਵਿੱਚ, ਨਾਰਮਲਾਈਜ਼ੇਸ਼ਨ ਪਾਈਪਲਾਈਨ (min-max scale) ਨੂੰ ਇਨਪੁੱਟ ਦੇ ਨਾਮ ਦੇ ਬਿਨਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ:
norm =: (] - \\u003c./) % (\\u003e./ - \\u003c./)
norm 3 10 5 7
ਜਾਂ ਇੱਕ ਛੋਟੀ ਟੈਕਸਟ ਪਾਈਪਲਾਈਨ—ਇੱਕ ਸਤਰ ਵਿੱਚ ਸ਼ਬਦਾਂ ਗਿਣੋ:
#@;: 'J makes pipelines feel like algebra'
ਸ਼ੁਰੂ ਵਿੱਚ ਚਿੰਨ੍ਹ ਘੁਟਣਭਾਵ ਹੋ ਸਕਦੇ ਹਨ—ਉਹੀ ਮੁਲ-ਹੇਠਾਂ ਦੀ ਲੜੀ ਹੈ: ਇਹ ਤੁਸੀਂ ਡੇਟਾ آپਰੇਸ਼ਨਾਂ ਨੂੰ ਜੋੜਨਯੋਗ ਬਿਲਡਿੰਗ ਬਲਾਕ ਵਜੋਂ ਦੇਖਣਾ ਸਿਖਾਉਂਦਾ ਹੈ।
Forth ਅਤੇ Factor: ਸਟੈਕ ਇੱਕ ਭਾਸ਼ਾ ਵਜੋਂ
Forth ਅਤੇ Factor “ਐਕਸੋਟਿਕ” ਮਹਿਸੂਸ ਹੁੰਦੇ ਹਨ ਕਿਉਂਕਿ ਤੁਸੀਂ Python ਜਾਂ JavaScript ਵਰਗੇ ਅਭਿਵਕਤੀਆਂ ਤਰ੍ਹਾਂ ਐਕਸਪ੍ਰੈਸ਼ਨ ਨਹੀਂ ਲਿਖਦੇ। ਇਸ ਦੀ ਥਾਂ, ਤੁਸੀਂ ਮੁਖਤਲਫ ਸਟੈਕ آپਰੇਸ਼ਨਾਂ ਲਿਖਦੇ ਹੋ: ਮੁੱਲ ਪুশ ਕਰੋ, ਇੱਕ ਸ਼ਬਦ (ਫੰਕਸ਼ਨ) ਲਗਾਓ, ਅਤੇ ਨਤੀਜੇ ਅਗਲੇ ਸ਼ਬਦ ਲਈ ਸਟੈਕ 'ਤੇ ਛੱਡ ਦਿਓ।
ਇਹ ਕਿਉਂ ਐਕਸੋਟਿਕ ਹੈ
ਸਟੈਕ ਭਾਸ਼ਾ ਵਿੱਚ, ਕ੍ਰਮ ਹੀ ਸਿੰਟੈਕਸ ਹੈ। ਲੜੀ ਵਿੱਚ ਥੋੜਾ ਜਿਹਾ ਬਦਲਾਅ ਹੀ ਅਰਥ ਬਦਲ ਸਕਦਾ ਹੈ, ਅਤੇ ਪੰਨੇ ਉਤੇ ਘੱਟ ਹੀ “ਨਾਂ” (ਵੇਰੀਏਬਲ) ਦਿੱਖਦੇ ਹਨ। Forth ਮਸ਼ਹੂਰ ਹੈ ਆਪਣੇ ਨਿਊਨ ਕੋਰ ਲਈ, ਜੋ ਅਕਸਰ ਛੋਟੇ ਅਮਲ ਨਾਲ ਅਮਲ ਹੋ ਜਾਂਦਾ ਹੈ। Factor ਸਟੈਕ ਮਾਡਲ ਰੱਖਦਾ ਹੈ ਪਰ ਇੱਕ ਆਧੁਨਿਕ ਸਟੈਂਡਰਡ ਲਾਇਬ੍ਰੇਰੀ, ਟੂਲਿੰਗ, ਅਤੇ ਹੁਨਰਵਰਤ ਬਣਾਵਟ ਜੋੜਦਾ ਹੈ।
ਇਹ ਕੀ ਸਿਖਾਉਂਦਾ ਹੈ
ਤੁਸੀਂ ਸਟੈਕ ਮਸ਼ੀਨਾਂ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀਆਂ ਹਨ ਅਤੇ ਕਿਉਂ ਉਹ ਇੰਟਰਪ੍ਰੇਟਰਾਂ ਅਤੇ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਲਈ ਆਕਰਸ਼ਕ ਹਨ, ਇਹ ਸਿੱਖਦੇ ਹੋ। ਤੁਸੀਂ ਕੰਪੋਜ਼ੀਸ਼ਨ ਦਾ ਇੱਕ ਪ੍ਰਯੋਗਿਕ ਪਾਠ ਵੀ ਸਿੱਖਦੇ ਹੋ: ਛੋਟੇ ਸ਼ਬਦ ਬਣਾਉਣਾ ਜੋ ਇਕ-ਦੂਜੇ ਵਿੱਚ ਅਸਾਨੀ ਨਾਲ ਜੁੜ ਜਾਂਦੇ ਹਨ, ਕਿਉਂਕਿ ਸਟੈਕ ਬੈਲੰਸ ਰੱਖਣਾ ਅਨੁਸ਼ਾਸਨ ਲਿਆਉਂਦਾ ਹੈ।
ਅਸਲ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ ਫਾਇਦੇ
ਕੋਰ ਛੋਟਾ ਹੋਣ ਕਰਕੇ, Forth-ਸਟਾਈਲ ਸਿਸਟਮ ਡਿਵਾਈਸ, ਗੇਮ, ਅਤੇ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਅਸਾਨੀ ਨਾਲ ਐਮਬੈਡ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ ਜਿੱਥੇ ਤੁਸੀਂ ਇੱਕ ਸੰਕੁਚਿਤ ਕਮਾਂਡ ਭਾਸ਼ਾ ਚਾਹੁੰਦੇ ਹੋ। Factor ਛੋਟੇ, ਜੋੜਨਯੋਗ ਪ੍ਰੋਗਰਾਮ ਤੇਜ਼ੀ ਨਾਲ ਬਣਾਉਣ ਲਈ ਇੱਕ ਖੇਡਗਾਹ ਹੋ ਸਕਦਾ ਹੈ।
ਅਜ਼ਮਾਓ
ਅੰਕਗਣਿਤ ਅਤੇ ਸਟੈਕ ਮੈਨਿਪੁਲੇਸ਼ਨ (ਉਦਾਹਰਨ: ਨਕਲ ਅਤੇ ਬਦਲੀ ਮੁੱਲ) ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ। ਫਿਰ ਇੱਕ ਛੋਟੀ ਕੈਲਕੁਲੇਟਰ REPL ਬਣਾਓ: ਇੱਕ ਟੋਕਨ ਪੜ੍ਹੋ, ਨੰਬਰ ਪুশ ਕਰੋ, + ਅਤੇ * ਵਰਗੇ ਸ਼ਬਦ ਚਲਾਓ, ਅਤੇ ਸਟੈਕ ਪ੍ਰਿੰਟ ਕਰੋ। ਜੇ ਇਹ ਚਲੇ ਤਾਂ ਇੱਕ ਛੋਟੇ ਇੰਟਰਪ੍ਰੇਟਰ ਵਿੱਚ ਵਧਾਓ ਜਿਸ ਵਿੱਚ ਯੂਜ਼ਰ-ਪਰਿਭਾਸ਼ਿਤ ਸ਼ਬਦਾਂ ਦੀ ਡਿਕਸ਼ਨਰੀ ਹੋ।
Prolog ਅਤੇ Datalog: ਪ੍ਰਸ਼ਨ ਪੁੱਛੋ, ਜਵਾਬ ਪਾਓ
ਅਧਿਕਤਰ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਤੁਹਾਨੂੰ ਦੱਸਦੀਆਂ ਹਨ ਕਿ ਕਿਵੇਂ ਕੁਝ ਕਰਨਾ ਹੈ: ਇੱਥੇ ਲੂਪ ਲਗਾਓ, ਉੱਥੇ ਸ਼ਾਖਾ ਬਣਾਓ, ਇਸ ਨੂੰ ਅਪਡੇਟ ਕਰੋ। Prolog ਅਤੇ Datalog ਇਸਨੂੰ ਉਲਟ ਕਰਦੇ ਹਨ। ਤੁਸੀਂ ਤੱਥ ਅਤੇ ਨਿਯਮ ਵਰਣਨ ਕਰਦੇ ਹੋ, ਫਿਰ ਪ੍ਰਸ਼ਨ ਪੂਛਦੇ ਹੋ—ਅਤੇ ਸਿਸਟਮ ਹੱਲ ਲੱਭਦਾ ਹੈ।
ਇਹ ਕਿਉਂ “ਐਕਸੋਟਿਕ” ਹਨ
ਕੰਟਰੋਲ ਫਲੋ ਦੀ ਥਾਂ, ਤੁਸੀਂ ਲਾਜਿਕ ਨਿਯਮ ਲਿਖਦੇ ਹੋ। Prolog ਦਾ ਪ੍ਰੋਗ੍ਰਾਮ ਅਕਸਰ ਇੱਕ ਸੰਕੁਚਿਤ ਨਿਯਮਾਂ ਅਤੇ ਕਾਨੂੰਨਾਂ ਵਰਗਾ ਪੜ੍ਹਦਾ ਹੈ, ਨਾਲ ਹੀ ਕੁਐਰੀਜ਼। ਅੰਦਰਲੇ ਤੌਰ 'ਤੇ, Prolog ਯੂਨੀਫਿਕੇਸ਼ਨ (ਮੈਚਿੰਗ ਪੈਟਰਨ) ਅਤੇ ਬੈਕਟ੍ਰੈਕਿੰਗ (ਵਿਕਲਪਾਂ ਦੀ ਕੋਸ਼ਿਸ਼) ਵਰਤਦਾ ਹੈ ਉੱਤਰ ਲੱਭਣ ਲਈ।
Datalog ਇਸਦਾ ਨੇੜਲਾ ਰਿਸ਼ਤੇਦਾਰ ਹੈ: ਆਮ ਤੌਰ 'ਤੇ ਵਧੇਰੇ ਸੀਮਿਤ (ਉਹਨਾ ਵਿੱਚ ਵੱਡੇ ਜਾਂ ਉਲਝਣ ਭਰੇ ਟਰਮ ਨਹੀਂ ਹੁੰਦੇ) ਪਰ ਸਕੇਲਬਲ ਨਿਯਮ ਮੁਲਾਂਕਣ ਅਤੇ ਡੇਟਾਬੇਸ-ਸਟਾਈਲ ਤਰਕ ਲਈ ਸ਼ਾਨਦਾਰ ਹੈ।
ਇਹ ਕੀ ਸਿਖਾਉਂਦਾ ਹੈ
ਡਿਕਲੇਰੇਟਿਵ ਅੰਦਾਜ਼ ਵਿੱਚ ਕੰਮ ਕਰਨ ਨਾਲ ਇੱਕ ਵੱਖਰਾ ਮਾਨਸਿਕ ਮਾਡਲ ਸਿਖਦਾ ਹੈ:
- ਪਾਬੰਦੀਆਂ ਅਤੇ ਸੰਬੰਧਾਂ ਵਿੱਚ ਸੋਚੋ, ਕਦਮਾਂ ਵਿੱਚ ਨਹੀਂ।
- ਗਿਆਨ (ਤੱਥ) ਨੂੰ ਕਲਾਜ਼ (ਨਿਯਮਾਂ) ਤੋਂ ਅਲੱਗ ਰੱਖੋ।
- ਧਿਆਨ ਦਿਓ ਕਿ ਇਕ ਛੋਟਾ ਨਿਯਮ ਸੈੱਟ ਕਿਵੇਂ ਬਹੁਤ ਸਾਰੇ ਵੈਧ ਹੱਲ ਉਪਜਾ ਸਕਦਾ ਹੈ।
ਇਹ ਵਿਚਾਰ ਏਸੋਲੈਂਗ ਤੋਂ ਬਾਹਰ ਵੀ ਜ਼ਿਆਦਾ ਵਰਤੋਂ ਵਾਲੇ ਹਨ—ਨਿਯਮ ਇੰਜਨਾਂ, ਪਾਲੀਸੀ ਸਿਸਟਮ, ਕੁਐਰੀ ਪਲਾਨਰ, ਅਤੇ ਭਾਸ਼ਾ ਰਿਸਰਚ ਵਿੱਚ।
ਕਿੱਥੇ ਇਹ ਚਮਕਦੇ ਹਨ
ਲਾਜਿਕ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਸਮਾਂ-ਸੂਚਨਾ, ਸੰਰਚਨਾ ਨਿਯਮ, ਗਿਆਨ ਬੇਸ, ਅਤੇ ਪਹੇਲੀਆਂ ਹੱਲ ਕਰਨ ਲਈ ਵਧੀਆ ਹਨ—ਜਿੱਥੇ “ਇੱਕ ਹੱਲ ਲੱਭੋ ਜੋ ਇਨ੍ਹਾਂ ਸ਼ਰਤਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ” ਲਕੜੀ ਹੈ।
ਅਜ਼ਮਾਓ: ਇੱਕ ਛੋਟੀ ਪਰਿਵਾਰਕ ਰੂਪ-ਉਦਾਹਰਨ
parent(alex, sam).
parent(sam, riley).
grandparent(X, Y) :- parent(X, Z), parent(Z, Y).
ਹੁਣ ਪੁੱਛੋ:
?- grandparent(alex, Who).
ਤੁਸੀਂ ਕੋਈ ਲੂਪ ਨਹੀਂ ਲਿਖਿਆ; ਤੁਸੀਂ ਇੱਕ ਸਵਾਲ ਪੁੱਛਿਆ। ਇਹ ਬਦਲਾਅ ਮੂਲ ਪਾਠ ਹੈ—ਅਤੇ ਇਸ ਲਈ ਇਹ ਨਿਸ਼ ਭਾਸ਼ਾਵਾਂ 2025 ਵਿੱਚ ਵੀ ਤਾਜ਼ਾ ਮਹਿਸੂਸ ਹੁੰਦੀਆਂ ਹਨ।
Rust: ਅਜੀਬ ਸੁਰੱਖਿਆ ਨਿਯਮ ਪਰ ਅਸਲ-ਦੁਨੀਆ ਫਾਇਦਾ
ਲਾਜਿਕ ਕੁਐਰੀਆਂ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਪ੍ਰੋਟੋਟਾਈਪ ਕਰੋ
ਇੱਕ ਕ੍ਰਿਯਾ API ਫੈਰ ਇਟਰੇਟ ਕਰੋ ਅਤੇ ਬਿਨਾਂ ਬੋਇਲਰਪਲੇਟ ਦੇ ਨਿਯਮਾਂ ਅਤੇ ਤੱਥਾਂ 'ਤੇ ਕੰਮ ਕਰੋ।
Rust ਐਕਸੋਟਿਕ ਇਸ ਲਈ ਮਹਿਸੂਸ ਹੋ ਸਕਦੀ ਹੈ ਕਿ ਇਹ ਪ੍ਰਚਲਿਤ ਨਹੀਂ, ਪਰ ਇਹ ਤੁਹਾਨੂੰ ਇੱਕ ਨਵਾਂ ਮਾਨਸਿਕ ਮਾਡਲ ਸਿਖਾਉਂਦੀ ਹੈ: ownership। ਜੇਕਰ JavaScript ਜਾਂ Python ਵਰਗੇ ਗਾਰਬੇਜ ਕਲੈਕਟਰ ਤੇ ਭਰੋਸਾ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ, ਜਾਂ C ਵਾਂਗ ਮੈਨੁਅਲ ਮੈਮੋਰੀ ਛੱਡਣ 'ਤੇ ਭਰੋਸਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ Rust ਉਹ ਨਿਯਮ ਲਾਉਂਦੀ ਹੈ ਕਿ ਕੌਣ ਕਿਸ ਚੀਜ਼ ਦਾ ਮਾਲਿਕ ਹੈ ਅਤੇ ਇਸਨੂੰ ਕਿਵੇਂ ਸਾਂਝਾ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
ਇਹ ਕਿਉਂ ਐਕਸੋਟਿਕ ਹੈ: ownership ਅਤੇ borrowing
ਬੋਰੋ ਚੈੱਕਰ ਇੱਕ ਕੰਪਾਇਲ-ਟائم ਰੈਫਰੀ ਹੈ। ਇਹ ਕਈ ਆਮ ਬਗਾਂ—use-after-free, double frees, ਅਤੇ ਡੇਟਾ ਰੇਸ—ਨੂੰ ਰੋਕਦਾ ਹੈ, ਇਹਨਾਂ ਕੋਡਾਂ ਨੂੰ ਅਸੁਰੱਖਿਅਤ ਹੋਣ ਦੀ ਸੰਭਾਵਨਾ ਰੱਖਣ ਵਾਲੇ। ਇਹ ਪਹਿਲਾਂ ਹੈਰਾਨ ਕਰਨ ਵਾਲਾ ਹੋ ਸਕਦਾ ਹੈ: ਤੁਸੀਂ ਜੋ ਮੰਨਦੇ ਹੋ ਕਿ ਤੁਸੀਂ ਕਰ ਰਹੇ ਹੋ, Rust ਉਸਦਾ ਸਬੂਤ ਮੰਗਦਾ ਹੈ।
ਇਹ ਕੀ ਸਿਖਾਉਂਦਾ ਹੈ: ਗਾਰਬੇਜ ਕਲੈਕਸ਼ਨ ਬਿਨਾਂ ਸੁਰੱਖਿਆ
Rust ਦੀ ਵੱਡੀ ਸਿੱਖਿਆ ਇਹ ਹੈ ਕਿ ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਸੁਰੱਖਿਆ ਟਰੇਡ-ਆਫ਼ ਹੋਣੀ ਲਾਜ਼ਮੀ ਨਹੀਂ। ਤੁਸੀਂ ਲਾਈਫਟਾਈਮ, ਸਪਸ਼ਟ ਡੇਟਾ-ਫਲੋ, ਅਤੇ “ਇੱਕ ਮਾਲਿਕ” ਅਤੇ “ਸਾਂਝੇ ਅਕਸਸ” ਦੇ ਦਰਮਿਆਨੀ ਸਾਫ ਹੱਦਾਂ ਬਾਰੇ ਸੋਚਣਾ ਸਿੱਖਦੇ ਹੋ। ਜੇਕਰ ਤੁਸੀਂ Rust ਕਦੇ ਵੀ ਨਹੀਂ ਲੈ ਕੇ ਜਾਓਗੇ, ਇਹ ਆਦਤਾਂ ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਵੀ ਲਾਭਦਾਇਕ ਹਨ।
ਕਿੱਥੇ ਇਹ ਚਮਕਦਾ ਹੈ
Rust ਸਿਸਟਮ ਟੂਲਜ਼, ਕਮਾਂਡ-ਲਾਈਨ ਯੂਟਿਲਿਟੀਜ਼, ਗੇਮ ਇੰਜਣ, ਐਂਬੈਡਡ ਪ੍ਰੋਜੈਕਟ, ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ-ਸੰਵੇਦਨਸ਼ੀਲ ਸਰਵਿਸਿਜ਼ ਲਈ ਇੱਕ ਪ੍ਰਯੋਗਿਕ ਚੋਣ ਹੈ—ਉਹ ਜਗ੍ਹਾ ਜਿੱਥੇ ਗਤੀਸ਼ੀਲਤਾ ਮੱਤੀ ਰੱਖਦੀ ਹੈ ਅਤੇ ਕਰੈਸ਼ ਮਹਿੰਗੇ ਹੁੰਦੇ ਹਨ।
ਅਜ਼ਮਾਓ: ਇੱਕ ਛੋਟਾ ਸਕ੍ਰਿਪਟ ਅਨੁਵਾਦ ਕਰੋ ਅਤੇ ਗਾਰੰਟੀ ਵੇਖੋ
ਆਪਣੇ ਜਾਣੂ ਇੱਕ ਛੋਟਾ ਸਕ੍ਰਿਪਟ ਲਓ (ਵਰਡ ਕਾਊਂਟਰ, CSV ਕਲੀਨਰ, ਜਾਂ ਫਾਇਲ ਰੀਨੇਮਰ)। ਇਸਨੂੰ Rust ਵਿੱਚ ਲਿਖੋ, ਫਿਰ ਗਿਆਨ-ਪੂਰਵਕ ਇੱਕ ਬੱਗ ਜੋੜੋ:
- ਇੱਕ ਸਤਰ ਲਈ ਇੱਕ ਹਵਾਲਾ ਰੱਖੋ, ਫਿਰ ਸਤਰ ਨੂੰ ਬਦਲਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ।
- ਵਧੇਰੇ ਥ੍ਰੇਡਾਂ ਵਿੱਚ ਗੁਣਾਂ ਨੂੰ ਸਾਂਝਾ ਕਰੋ ਬਿਨਾਂ ਸਮਨਵਯ ਦੇ।
Rust ਅਕਸਰ ਤੁਹਾਨੂੰ ਕੰਪਾਇਲ ਹੋਣ ਨਹੀਂ ਦੇਵੇਗਾ ਜਦ ਤੱਕ ਉਹ ਖ਼ਤਰਨਾਕ ਵਿਹਾਰ ਠੀਕ ਨਾ ਕੀਤਾ ਜਾਏ। ਗਲਤੀ ਸੁਨੇਹਿਆਂ ਨੂੰ ਇੱਕ ਮਾਰਗਦਰਸ਼ਕ ਪਾਠ ਸਮਝੋ: ਉਹ ਦੱਸਦੇ ਹਨ ਤੁਸੀਂ ਕਿਹੜਾ ਨਿਯਮ ਤੋੜਿਆ ਅਤੇ ਆਮ ਤੌਰ 'ਤੇ ਇੱਕ ਸੁਰੱਖਿਅਤ ਢਾਂਚਾ ਸੁਝਾਉਂਦੇ ਹਨ।
Q# ਅਤੇ Qiskit: ਤੁਸੀਂ ਅਸਲ ਵਿੱਚ ਕਵਾਂਟਮ ਪਰੋਗ੍ਰਾਮਿੰਗ ਅਜ਼ਮਾ ਸਕਦੇ ਹੋ
ਕਵਾਂਟਮ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਐਕਸੋਟਿਕ ਮਹਿਸੂਸ ਹੁੰਦੀ ਹੈ ਕਿਉਂਕਿ ਤੁਸੀਂ ਕਦਮ-ਬ-ਕਦਮ ਹਦਾਇਤਾਂ ਦੀ ਥਾਂ ਇਕ ਕਵਾਂਟਮ ਸਰਕਿਟ ਦਾ ਵਰਣਨ ਕਰ ਰਹੇ ਹੋ: qubits, gates, ਅਤੇ ਮਾਪ। “ਫੰਕਸ਼ਨ ਇੱਕ ਐਮ ਨਾਲ ਵਾਪਸ ਕਰਦਾ ਹੈ” ਵਾਲੀ ਸੋਚ ਦੀ ਥਾਂ, ਤੁਸੀਂ ਅਕਸਰ ਪ੍ਰਾਪਤਿਕਾਂ ਬਾਰੇ ਸੋਚਦੇ ਹੋ—ਉਹਨਾਂ ਨੂੰ ਅੱਖਾਂ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਚਲਾਈਦਾ ਹੈ ਅਤੇ ਇੱਕੋ ਪ੍ਰੋਗ੍ਰਾਮ ਨੂੰ ਕਈ ਵਾਰੀ ਚਲਾਉਂਦੇ ਹੋ ਤਾਂਕਿ ਵਿਭਿੰਨ ਨਤੀਜੇ ਮਿਲ ਸਕਣ।
ਇਹ ਕਿਉਂ ਐਕਸੋਟਿਕ ਹੈ
Q# (Microsoft) ਅਤੇ Qiskit (IBM) ਸਰਕਿਟ ਆਪਰੇਸ਼ਨਾਂ ਅਤੇ ਮਾਪਦੇਸ਼ਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਬਣੇ ਹਨ। ਤੁਸੀਂ ਕੋਡ ਲਿਖਦੇ ਹੋ ਜੋ superposition ਅਤੇ entanglement ਸੈਟਅੱਪ ਕਰਦਾ ਹੈ, ਫਿਰ ਮਾਪਣ ਕਰਕੇ ਇਹਨਾਂ ਨੂੰ ਅਪ-ਕੰਪਾਉਂਡ ਕਰਦਾ ਹੈ। ਇਹ ਸੋਚ ਸਧਾਰਨ ਐਪਾਂ ਤੋਂ ਬਹੁਤ ਹੀ ਵੱਖਰੀ ਹੈ।
ਇਹ ਕੀ ਸਿਖਾਉਂਦਾ ਹੈ
ਭਾਵੇਂ ਤੁਸੀਂ ਅਸਲ ਕਵਾਂਟਮ ਹਾਰਡਵੇਅਰ ਨੂੰ ਛੂਹਦੇ ਨਹੀਂ, ਇਹ ਟੂਲ ਮੁੱਖ ਸੰਕਲਪਾਂ ਨੂੰ ਸੂਝਬੂਝਯੋਗ ਬਣਾਉਂਦੇ ਹਨ:
- Superposition: ਇੱਕ qubit ਮਾਪਣ ਤੱਕ 0 ਅਤੇ 1 ਦਾ ਮਿਲਾਪ ਦਿਖਾ ਸਕਦਾ ਹੈ।
- Entanglement: qubits ਇੰਝ ਜੁੜ ਸਕਦੇ ਹਨ ਕਿ ਉਹਨਾਂ ਦੇ ਨਤੀਜੇ ਇੱਕ-ਦੂਜੇ ਨਾਲ ਸੰਬੰਧਤ ਰਹਿੰਦੇ ਹਨ।
- ਸੰਭਾਵਨਾਤਮਕ ਨਤੀਜੇ: ਨਤੀਜੇ ਵਿਤਰਣ ਹੁੰਦੇ ਹਨ, ਇਕਲ ਮੁੱਲ ਨਹੀਂ।
ਹਕੀਕਤ-ਚੈਕ (ਸਿਮੁਲੇਟਰ ਆਮ ਹਨ)
ਅਧਿਕাংশ ਲੋਕ ਕਵਾਂਟਮ ਪ੍ਰੋਗ੍ਰਾਮਾਂ ਨੂੰ ਸਿਮੁਲੇਟਰ 'ਤੇ ਚਲਾਉਂਦੇ ਹਨ। ਅਸਲ ਡਿਵਾਇਸਾਂ ਵਿੱਚ ਸ਼ੋਰ, ਕਤਾਰਾਂ, ਅਤੇ ਸੀਮਾਵਾਂ ਹੁੰਦੀਆਂ ਹਨ। ਸਿਮੁਲੇਟਰ ਅਜੇ ਵੀ ਕੀਮਤੀ ਹਨ: ਤੁਸੀਂ ਹਾਰਡਵੇਅਰ-ਮੁਸ਼ਕਲਾਂ ਦੇ ਬਿਨਾਂ ਮਾਨਸਿਕ ਮਾਡਲ ਸਿੱਖ ਸਕਦੇ ਹੋ।
ਅਜ਼ਮਾਓ: ਇੱਕ ਛੋਟੀ ਸਰਕਿਟ ਸਿਮੁਲੇਟਰ 'ਤੇ (Qiskit)
ਇਹ ਦੋ entangled qubits (Bell pair) ਬਣਾਂਦਾ ਹੈ ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ ਮਾਪਦਾ ਹੈ:
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
sim = AerSimulator()
result = sim.run(qc, shots=1000).result()
print(result.get_counts())
ਤੁਸੀਂ ਆਮ ਤੌਰ 'ਤੇ ਮੁੱਖ ਰੂਪ 00 ਅਤੇ 11 ਦੇਖੋਗੇ—ਇਹ ਉਹ “ਆਹਾ” ਲਹਿਜ਼ਾ ਹੈ: qubits ਇਕ ਜੋੜੀ ਦੀ ਤਰ੍ਹਾਂ ਵਰਤਦੇ ਹਨ, ਦੋ ਅਲੱਗ ਬਿੱਟਾਂ ਵਾਂਗ ਨਹੀਂ।
ਅਪਣਾ ਅਗਲਾ ਐਕਸੋਟਿਕ ਭਾਸ਼ਾ ਪ੍ਰਯੋਗ ਕਿਵੇਂ ਚੁਣੀਏ
ਐਕਸੋਟਿਕ ਭਾਸ਼ਾ ਚੁਣਨਾ ਅਸਾਨ ਹੁੰਦਾ ਹੈ ਜਦ ਤੁਸੀਂ ਆਪਣਾ ਲਕਸ਼ ਤੈਅ ਕਰ ਲਓ। ਕੁਝ ਭਾਸ਼ਾਵਾਂ ਵਿਚਾਰ ਸਿਖਾਉਂਦੀਆਂ ਹਨ (ਲਾਜਿਕ, ਐਰੇ, ਕਵਾਂਟਮ ਸੋਚ), ਹੋਰਾਂ ਅਨੁਸ਼ਾਸਨ (ਸੁਰੱਖਿਆ ਨਿਯਮ), ਅਤੇ ਕੁਝ ਸਿਰਫ਼ ਮਜ਼ੇਦਾਰ ਪਾਬੰਦੀਆਂ ਹਨ ਜੋ ਸਮੱਸਿਆ-ਹੱਲ ਨੂੰ ਤਿੱਖਾ ਕਰਦੀਆਂ ਹਨ।
ਜੋ ਤੁਸੀਂ ਸਿੱਖਣਾ ਚਾਹੁੰਦੇ ਹੋ ਉਸ ਅਨੁਸਾਰ ਚੁਣੋ
- ਸਿਧਾਂਤ ਅਤੇ ਨਵੇਂ ਮਾਨਸਿਕ ਮਾਡਲ: Prolog/Datalog (ਕੁਐਰੀ), Wolfram Language (ਨਿਯਮ-ਅਧਾਰਤ), ਕਵਾਂਟਮ ਟੂਲ (Q#/Qiskit).
- ਗਣਿਤੀ ਅਭਿਵ੍ਯਕਤਤਾ: APL/BQN, J/K (ਐਰੇ ਸੋਚ ਅਤੇ ਸੰਕੁਚਿਤ ਰਚਨਾ).
- ਸੁਰੱਖਿਆ ਅਤੇ ਇੰਜੀਨੀਅਰਿੰਗ ਆਦਤਾਂ: Rust (ownership ਅਤੇ borrowing).
- ਖੇਡ ਵਾਲੇ ਪਾਬੰਦੀ-ਰਚਨਾ ਸਮਾਧਾਨ: Brainfuck, Whitespace, Befunge, Hexagony.
ਜੇ ਤੁਸੀਂ ਪੱਕੇ ਨਹੀਂ ਹੋ, ਤਾਂ ਉਹ ਚੁਣੋ ਜੋ ਥੋੜ੍ਹਾ ਅਸੁਖਦਣਕ ਲੱਗੇ ਪਰ ਫਿਰ ਵੀ ਹੱਲਯੋਗ ਹੋ—ਤੁਹਾਨੂੰ ਘਸਿਆ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਨਾ ਕਿ ਨਿਰਾਸ਼ਾ।
ਇਕ ਹਲਕਾ-ਭਾਰ ਸਿੱਖਣ ਦਾ ਰਸਤਾ (1 ਘੰਟਾ → 1 ਦਿਨ → 1 ਹਫ਼ਤਾ)
1-ਘੰਟਾ ਰਕਰੀਆ:
ਛੋਟਾ ਟਿਊਟੋਰਿਯਲ ਪੜ੍ਹੋ ਅਤੇ 3–5 ਛੋਟੇ ਉਦਾਹਰਨ ਚਲਾਓ। ਤੁਹਾਡਾ ਇਕੱਲਾ ਮਕਸਦ ਇਹ ਸਮਝਣਾ ਹੈ ਕਿ ਕੋਡ ਕਿਵੇਂ ਦਿਖਦਾ ਹੈ ਅਤੇ ਇਹ ਕਿਵੇਂ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ।
1-ਦਿਨ ਪ੍ਰੋਜੈਕਟ:
ਇੱਕ ਛੋਟਾ-ਜਿਹਾ ਬਣਾ ਕੇ ਖਤਮ ਕਰੋ। ਚੰਗੇ ਵਿਕਲਪ:
- ਇੱਕ ਛੋਟਾ ਇੰਟਰਪ੍ਰੇਟਰ ਭਾਗ (ਜਿਵੇਂ Brainfuck-ਸ਼ੈਲੀ VM)।
- ਇੱਕ ਪ੍ਰਿਟੀ-ਪ੍ਰਿੰਟਰ/ਵਿਜ਼ੂਲਾਈਜ਼ਰ (Befunge/Hexagony ਗ੍ਰਿਡ ਲਈ ਵਧੀਆ)।
- ਇੱਕ ਪਹੇਲੀ ਸਾਲਵਰ (ਲਾਜਿਕ ਭਾਸ਼ਾਵਾਂ ਇੱਥੇ ਚਮਕਦੀਆਂ ਹਨ）。
1-ਹਫ਼ਤਾ ਡੀਪ ਡਾਈਵ:
ਉਹੀ ਪ੍ਰੋਜੈਕਟ ਵਾਪਸ ਬਣਾਓ ਪਰ ਹੁਣ ਚੰਗੀ ਬਣਤਰ: ਟੈਸਟ, ਐਰਰ ਸੁਨੇਹੇ, ਦਸਤਾਵੇਜ਼, ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਸੁਧਾਰ। ਇੱਥੇ ਹੀ ਭਾਸ਼ਾ ਦੀਆਂ ਅਸਲ ਤਾਕਤਾਂ ਅਤੇ ਟਰੇਡ-ਆਫ਼ਸ ਸਪਸ਼ਟ ਹੋ ਜਾਦੀਆਂ ਹਨ।
ਜੇ ਤੁਸੀਂ “1-ਦਿਨ ਪ੍ਰੋਜੈਕਟ” ਨੂੰ ਤੇਜ਼ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ Koder.ai ਵਰਤ ਕੇ ਇੱਕ ਛੋਟਾ ਵੈੱਬ ਰਨਰ (React UI + Go ਬੈਕਐਂਡ + PostgreSQL ਜੇ ਸਟੋਰੇਜ ਚਾਹੀਦਾ ਹੋਵੇ) ਸਕੈਫੋਲਡ ਕਰ ਸਕਦੇ ਹੋ—ਸਿਰਫ਼ ਇੱਕ ਚੈਟ ਬ੍ਰੀਫ ਦੇ ਕੇ, ਫਿਰ ਯੋਜਨਾ ਮੋਡ ਵਿੱਚ ਦੁਹਰਾਓ ਅਤੇ ਜਦ ਤਿਆਰ ਹੋਵੋ ਤਾਂ ਸੋਰਸ ਕੋਡ ਨਿਰਯਾਤ ਕਰੋ। ਇਹ ਇੱਕ ਆਸਾਨ ਤਰੀਕਾ ਹੈ ਜੋ ਭਾਸ਼ਾ ਦੀ ਜਿਗਿਆਸਾ ਨੂੰ ਇੱਕ ਚੱਲਦੇ-ਫਿਰਦੇ ਪਲੇਗ੍ਰਾਊਂਡ ਵਿੱਚ ਬਦਲ ਸਕਦਾ ਹੈ ਜਿਹੜਾ ਤੁਸੀਂ ਸਾਂਝਾ ਕਰ ਸਕਦੇ ਹੋ।
ਅੱਗੇ ਕਿੱਥੇ ਜਾਣਾ ਹੈ
ਹੋਰ ਹੱਥ-ਅਨੁਭਵ ਪ੍ਰਯੋਗਾਂ ਅਤੇ ਲੇਖਾਂ ਲਈ /blog ਦੇਖੋ।
ਜੇ ਤੁਸੀਂ ਟੂਲਿੰਗ ਸੰਦਰਭ—ਐਡੀਟਰ, ਰਨਰ, ਸੈਂਡਬਾਕਸ, ਜਾਂ ਟੀਮ ਵਰਕਫਲੋਜ਼—ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ /pricing ਵੇਖੋ ਅਤੇ ਫੈਸਲਾ ਕਰੋ ਕਿ ਤੁਹਾਨੂੰ ਕੀ ਚਾਹੀਦਾ ਹੈ ਤਾਂ ਜੋ ਤੁਸੀਂ ਨਿਯਮਤ ਤੌਰ 'ਤੇ ਅਭਿਆਸ ਕਰ ਸਕੋ।