ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਅਕਸਰ ਨੈਟੇਵਲੀ ਤੌਰ 'ਤੇ ਮਿਟਦੀਆਂ ਨਹੀਂ; ਇਕੋਸਿਸਟਮ, ਲੈਗੇਸੀ ਸਿਸਟਮ, ਨਿਯਮ ਅਤੇ ਨਵੇਂ ਰਨਟਾਈਮ ਉਨ੍ਹਾਂ ਨੂੰ ਨਵੇਂ ਖੇਤਰਾਂ ਵਿੱਚ ਲੰਬੇ ਸਮੇਂ ਲਈ ਜੀਵਤ ਰੱਖਦੇ ਹਨ।
ਲੋਕ ਕਹਿੰਦੇ ਹਨ ਕਿ ਕੋਈ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾ “ਮਰ ਗਈ” ਜਦੋਂ ਉਹ ਸੋਸ਼ਲ ਮੀਡੀਆ 'ਤੇ ਟ੍ਰੈਂਡ ਨਹੀਂ ਰਹਿੰਦੀ, ਡਿਵੈਲਪਰ ਸਰਵੇਖਣ ਵਿੱਚ ਥੱਲੇ ਆ ਜਾਂਦੀ ਜਾਂ ਨਵੀਂ ਬੂਟਕੈਂਪ ਵਿੱਚ ਨਹੀਂ ਪੜ੍ਹਾਈ ਜਾਂਦੀ। ਇਹ ਮਰਨ ਨਹੀਂ—ਇਹ ਵੇਖਣ ਯੋਗਤਾ ਦਾ ਘੱਟ ਹੋਣਾ ਹੈ।
ਇੱਕ ਭਾਸ਼ਾ ਸੱਚਮੁੱਚ "ਮਰਦੀ" ਓਦੋ ਹੁੰਦੀ ਹੈ ਜਦੋਂ ਉਸਦਾ ਹਕੀਕਤੀ ਵਰਤੋਂ ਯੋਗ ਹੋਣਾ ਖਤਮ ਹੋ ਜਾਵੇ। ਅਸਲ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਇਹ ਆਮ ਤੌਰ 'ਤੇ ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਕਈ ਚੀਜ਼ਾਂ ਇੱਕੋ-ਸਮੇਂ ਹੋ ਜਾਦੀਆਂ ਹਨ: ਕੋਈ ਅਸਲ ਯੂਜ਼ਰ ਨਹੀਂ ਰਹਿੰਦੇ, ਕੋਈ ਰੱਖ-ਰਖਾਅ ਵਾਲਾ ਕੰਪਾਇਲਰ ਜਾਂ ਇੰਟਰਪ੍ਰੀਟਰ ਨਹੀਂ ਰਿਹਾ, ਅਤੇ ਨਵਾਂ ਕੋਡ ਬਣਾਉਣ ਜਾਂ ਚਲਾਉਣ ਦਾ ਕੋਈ ਠੀਕ ਤਰੀਕਾ ਨਹੀਂ ਰਿਹਾ।
ਜੇ ਤੁਸੀਂ ਇੱਕ ਠੋਸ ਚੈੱਕਲਿਸਟ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਭਾਸ਼ਾ ਕਰੀਬ-ਮਰਤੀ ਮਨੀ ਜਾ ਸਕਦੀ ਹੈ ਜਦੋਂ ਇਹਨਾਂ ਵਿੱਚੋਂ ਜ਼ਿਆਦਾਤਰ ਸੱਚ ਹੋਣ:
ਫਿਰ ਵੀ, "ਮਰਨਾ" ਕਾਫੀ ਦੁਰਲਭ ਹੁੰਦਾ ਹੈ। ਸੋর্স ਕੋਡ ਅਤੇ ਸਪੈਸੀਫਿਕੇਸ਼ਨ ਸੰਭਾਲੇ ਜਾ ਸਕਦੇ ਹਨ, ਫੋਰਕਸ ਰਖੜੀ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹਨ, ਅਤੇ ਕੰਪਨੀਆਂ ਕਈ ਵਾਰੀ ਉਹ ਟੂਲਚੇਨ ਜਿਊਂਦਾ ਰੱਖਣ ਲਈ ਭੁਗਤਾਨ ਵੀ ਕਰਦੀਆਂ ਹਨ ਕਿਉਂਕਿ ਸਾਫਟਵੇਅਰ ਅਜੇ ਵੀ ਕੀਮਤੀ ਹੁੰਦਾ ਹੈ।
ਅਕਸਰ, ਭਾਸ਼ਾਵਾਂ ਥੱਲੇ ਆ ਜਾਂਦੀਆਂ, ਖਾਸ ਹੋ ਜਾਦੀਆਂ ਜਾਂ ਨਵੇਂ ਸਟੈਕਾਂ ਵਿੱਚ ਐਂਬੈੱਡ ਹੋ ਜਾਂਦੀਆਂ ਹਨ।
ਵੱਖ-ਵੱਖ ਉਦਯੋਗਾਂ ਵਿੱਚ ਤੁਸੀਂ ਵੱਖ-ਵੱਖ “ਆਫ਼ਟਰਲਾਈਫ” ਦੇਖੋਗੇ: ਕੰਪਨੀਆਂ ਨੌਕਰੀ ਵਿੱਚ ਪੁਰਾਣੀਆਂ ਭਾਸ਼ਾਵਾਂ ਨੂੰ ਚਲਾਉਂਦੀਆਂ ਰਹਿੰਦੀਆਂ ਹਨ, ਵਿਗਿਆਨ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਗਣਿਤੀਕ ਟੂਲ ਨੂੰ ਰੱਖਦਾ ਹੈ, ਐਂਬੈਡਡ ਡਿਵਾਈਸ ਸਥਿਰਤਾ ਮਹੱਤਵ ਦਿੰਦੇ ਹਨ, ਅਤੇ ਵੈੱਬ ਲੰਬੇ ਸਮੇਂ ਵਾਲੀਆਂ ਭਾਸ਼ਾਵਾਂ ਨੂੰ ਪਲੇਟਫਾਰਮ ਦੇ ਨਿਰੰਤਰ ਵਿਕਾਸ ਰਾਹੀਂ ਮੈਨਟੇਨ ਕਰਦਾ ਹੈ।
ਇਹ ਲੇਖ ਗੈਰ-ਟੈਕਨੀਕਲ ਪਾਠਕਾਂ ਅਤੇ ਫੈਸਲਾ ਲੈਣ ਵਾਲਿਆਂ ਲਈ ਹੈ—ਜੋ ਟੈਕਨਾਲੋਜੀ ਚੁਣਦੇ ਹਨ, ਰੀਰਾਈਟਾਂ ਨੂੰ ਫੰਡ ਕਰਦੇ ਹਨ, ਜਾਂ ਜੋਖਮ ਮੈਨੇਜ ਕਰਦੇ ਹਨ। ਮਕਸਦ ਇਹ ਦਿਖਾਉਣਾ ਹੈ ਕਿ ਹਰ ਪੁਰਾਣੀ ਭਾਸ਼ਾ ਚੰਗੀ ਚੋਣ ਹੈ—ਉਸ ਦੀ ਥਾਂ ਇਹ ਸਮਝਾਉਣਾ ਹੈ ਕਿ "ਡੈਡ ਭਾਸ਼ਾ" ਵਾਲੀਆਂ ਸਿਰਲੇਖਾਂ ਅਕਸਰ ਉਹ ਮੁੱਦੇ ਛੱਡ ਦਿੰਦੀਆਂ ਹਨ ਜੋ ਅਸਲ ਵਿੱਚ ਗਿਣਤੀ ਰੱਖਦੇ ਹਨ: ਕੀ ਭਾਸ਼ਾ ਅਜੇ ਵੀ ਚਲਾਉਣ, ਵਿਕਸਿਤ ਅਤੇ ਸਮਰਥਨ ਹਾਸਲ ਕਰਨ ਲਈ ਇੱਕ ਯੋਗ ਰਸਤਾ ਰੱਖਦੀ ਹੈ।
ਭਾਸ਼ਾਵਾਂ ਇਸ ਲਈ ਨਹੀਂ ਟਿਕਦੀਆਂ ਕਿ ਉਹ ਲੋਕਪ੍ਰਿਯਤਾ ਜਿੱਤ ਲੈਣ—ਉਹ ਇਸ ਲਈ ਟਿਕਦੀਆਂ ਹਨ ਕਿਉਂਕਿ ਉਹਨਾਂ ਵਿੱਚ ਲਿਖਿਆ ਸਾਫਟਵੇਅਰ ਸਿਰਲੇਖਾਂ ਮੂਵ ਕਰਨ ਤੋਂ ਬਾਅਦ ਵੀ ਮੁੱਲ ਦਿੰਦਾ ਰਹਿੰਦਾ ਹੈ।
ਇੱਕ ਪੇਰੋਲ ਸਿਸਟਮ ਜੋ ਹਰ ਪੰਦਰਾਂ ਦਿਨ ਚੱਲਦਾ ਹੈ, ਇੱਕ ਬਿੱਲਿੰਗ ਇੰਜਨ ਜੋ ਇਨਵੌਇਸ ਮਿਲਾਉਂਦਾ ਹੈ, ਜਾਂ ਲੋਜਿਸਟਿਕਸ ਸ਼ੈਡਿਊਲਰ ਜੋ ਗੋਦਾਮਾਂ ਨੂੰ ਸਟਾਕ ਰੱਖਦਾ ਹੈ—ਇਹ "ਕੂਲ" ਨਹੀਂ ਹੁੰਦੇ ਪਰ ਕਾਰੋਬਾਰ ਲਈ ਅਨਿਵਾਰ्य ਹੁੰਦੇ ਹਨ। ਜੇ ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ, ਭਰੋਸੇਯੋਗ ਹੈ ਅਤੇ ਸਾਲਾਂ ਦੀਆਂ ਕੋਨੇ-ਕੋਨੇ ਦੀਆਂ ਹਾਲਤਾਂ ਨਾਲ ਪਰਖਿਆ ਹੋਇਆ ਹੈ, ਤਾਂ ਉਸਦੇ ਹੇਠਾਂ ਵਾਲੀ ਭਾਸ਼ਾ ਲੰਬੀ ਉਮਰ ਲੈ ਲੈਂਦੀ ਹੈ।
ਜ਼ਿਆਦਾਤਰ ਸੰਸਥਾਵਾਂ ਨਵੀਨਤਮ ਸਟੈਕ ਦੇ ਪਿਛੇ ਨਹੀਂ ਦੌੜਦੀਆਂ—ਉਹ ਜੋਖਮ ਘੱਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੀਆਂ ਹਨ। ਪੱਕੇ ਸਿਸਟਮਾਂ ਦੇ ਜਾਣੇ ਹੋਏ ਵਿਫਲਤਾ ਮੋਡ, ਆਡੀਟ ਟ੍ਰੇਲ ਅਤੇ ਓਪਰੇਸ਼ਨਲ ਗਿਆਨ ਹੁੰਦੇ ਹਨ। ਉਹਨਾਂ ਦੀ ਬਦਲੀ ਸਿਰਫ ਤਕਨੀਕੀ ਪ੍ਰੋਜੈਕਟ ਨਹੀਂ ਹੁੰਦੀ; ਇਹ ਕਾਰੋਬਾਰੀ ਕੁਨਟੀਨਿਊਟੀ ਦਾ ਪ੍ਰੋਜੈਕਟ ਹੁੰਦਾ ਹੈ।
ਕੰਮ ਦਾ ਮੁੜ-ਲਿਖਣਾ ਮਤਲਬ ਹੋ ਸਕਦਾ ਹੈ:
ਅਕਸਰ, ਇਨਕ੍ਰਿਮੈਂਟਲ ਮੋਡਰਨਾਈਜੇਸ਼ਨ ਜ਼ਿਆਦਾ ਲਾਜ਼ਮੀ ਅਤੇ ਕਿਫਾਇਤੀ ਹੁੰਦੀ ਹੈ।
ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਨੂੰ ਗੈਜਟ ਦੀ ਤਰ੍ਹਾਂ ਨਹੀਂ, ਬਲਕਿ ਇਨਫ੍ਰਾਸਟ੍ਰੱਕਚਰ ਵਾਂਗ ਸੋਚੋ। ਤੁਸੀਂ ਹਰ ਕੁਝ ਸਾਲਾਂ 'ਤੇ ਫੋਨ ਬਦਲ ਸਕਦੇ ਹੋ, ਪਰ ਪُل ਨੂੰ ਉਸੇ ਤਰ੍ਹਾਂ ਦੁਬਾਰਾ ਨਹੀਂ ਬਣਾਉਂਦੇ ਕਿਉਂਕਿ ਕੋਈ ਨਵਾਂ ਡਿਜ਼ਾਇਨ ਟ੍ਰੈਂਡ ਕੀਤਾ। ਜਦ ਤੱਕ ਪُل ਸੁਰੱਖਿਅਤ ਤਰੀਕੇ ਨਾਲ ਟ੍ਰੈਫਿਕ ਵਹਾਉਂਦਾ ਹੈ, ਤੁਸੀਂ ਉਸਨੂੰ ਰੱਖਦੇ ਹੋ ਅਤੇ ਬਰਕਰਾਰ ਰੱਖਦੇ ਹੋ।
ਬਹੁਤ ਸਾਰੀਆਂ ਕੰਪਨੀਆਂ ਆਪਣਾ ਕੋਰ ਸਾਫਟਵੇਅਰ ਐਸੇ ਹੀ ਰੱਖਦੀਆਂ ਹਨ: ਰੱਖ-ਰਖਾਅ ਕਰੋ, ਬਾਹਰੀ ਹਿੱਸਿਆਂ ਨੂੰ ਅਪਗਰੇਡ ਕਰੋ, ਅਤੇ ਪੱਕੀ ਬੁਨਿਆਦ ਨੂੰ ਚਲਾਓ—ਕਈ ਵਾਰੀ ਦਹਾਕਿਆਂ ਤੱਕ ਉਹੀ ਭਾਸ਼ਾ ਵਰਤ ਕੇ।
"ਲੈਗੇਸੀ ਸਿਸਟਮ" ਦੋਸ਼ੀ ਨਹੀ—ਇਹ ਸਿਰਫ ਉਹ ਸਾਫਟਵੇਅਰ ਹੈ ਜੋ ਪ੍ਰੋਡਕਸ਼ਨ ਵਿੱਚ ਕਾਫੀ ਸਮੇਂ ਤੋਂ ਚੱਲ ਰਿਹਾ ਹੈ ਅਤੇ ਲਾਜ਼ਮੀ ਹੋ ਚੁੱਕਾ ਹੈ। ਇਹ ਪੇਰੋਲ, ਭੁਗਤਾਨ, ਇਨਵੈਂਟਰੀ, ਲੈਬ ਇੰਸਟਰੂਮੈਂਟ ਜਾਂ ਗਾਹਕ ਦੇ ਰਿਕਾਰਡ ਚਲਾ ਸਕਦਾ ਹੈ। ਕੋਡ ਪੁਰਾਣਾ ਹੋ ਸਕਦਾ ਹੈ, ਪਰ ਕਾਰੋਬਾਰੀ ਮੁੱਲ ਮੌਜੂਦ ਹੈ, ਅਤੇ ਇਹੀ ਕਾਰਨ ਹੈ ਕਿ "ਲੈਗੇਸੀ ਭਾਸ਼ਾਵਾਂ" ਐਂਟਰਪ੍ਰਾਈਜ਼ ਸਾਫਟਵੇਅਰ ਵਿੱਚ ਸਰਗਰਮ ਰਹਿੰਦੀਆਂ ਹਨ।
ਸੰਸਥਾਵਾਂ ਅਕਸਰ ਲੰਬੇ ਸਮੇਂ ਚੱਲ ਰਹੀ ਐਪ ਨੂੰ ਨਵੇਂ ਸਟੈਕ 'ਚ ਲਿਆਂਦੇ ਜਾਣ 'ਤੇ ਵਿਚਾਰ ਕਰਦੀਆਂ ਹਨ। ਪਰ ਮੂਜੂਦਾ ਸਿਸਟਮ ਅਕਸਰ ਸਾਲਾਂ ਦੀਆਂ ਛੁਪੀਆਂ ਗਿਆਨ-ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਰੱਖਦਾ ਹੈ:
ਰੀਰਾਈਟ ਦੇ ਨਾਲ ਤੁਸੀਂ ਸਿਰਫ ਫੀਚਰ ਨਹੀਂ ਦੁਬਾਰਾ ਬਣਾਉਂਦੇ—ਤੁਸੀਂ ਵਿਵਹਾਰ ਨੂੰ ਦੁਬਾਰਾ ਬਣਾਉਂਦੇ ਹੋ। ਨਾਜ਼ੁਕ ਫਰਕ ਆਊਟੇਜ਼, ਆਰਥਿਕ ਗਲਤੀਆਂ ਜਾਂ ਨਿਯਮਤ ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਕਰ ਸਕਦੇ ਹਨ। ਇਸ ਲਈ Fortran ਜਾਂ COBOL ਵਰਗੀਆਂ ਭਾਸ਼ਾਵਾਂ ਅਜੇ ਵੀ ਕਈ ਮੁੱਖ ਕੰਮ ਚਲਾਉਂਦੀਆਂ ਹਨ—ਸਿੰਟੈਕਸ ਦੀ ਪਸੰਦ ਕਰਕੇ ਨਹੀਂ, ਬਲਕਿ ਸੌਫਟਵੇਅਰ ਦਾ ਪ੍ਰਮਾਣਿਤ ਹੋਣ ਕਾਰਨ।
ਬਹੁਤ ਸਾਰੀਆਂ ਕੰਪਨੀਆਂ ਇੱਕ ਵੱਡੇ ਰੀਰਾਈਟ ਦੀ ਥਾਂ ਹੌਲੀ-ਹੌਲੀ ਹਿੱਸਿਆਂ ਨੂੰ ਅਪਗਰੇਡ ਕਰਦੀਆਂ ਹਨ:
ਇਸ ਤਰੀਕੇ ਨਾਲ ਜੋਖਮ ਘਟਦਾ ਅਤੇ ਖ਼ਰਚ ਵੰਡਦਾ ਹੈ—ਅਤੇ ਇਹ ਸਮਝਾਉਂਦਾ ਹੈ ਕਿ ਭਾਸ਼ਾਵਾਂ ਦੀ ਲੰਬੀ ਉਮਰ ਕਿਉਂ ਹੁੰਦੀ ਹੈ: ਜਦ ਤੱਕ ਕੀਮਤੀ ਪ੍ਰਣਾਲੀਆਂ ਕਿਸੇ ਭਾਸ਼ਾ 'ਤੇ ਨਿਰਭਰ ਹੁੰਦੀਆਂ ਹਨ, ਹੁਨਰ, ਟੂਲਿੰਗ ਅਤੇ ਭਾਈਚਾਰੇ ਉਸਦੇ ਆਲੇ-ਦੁਆਲੇ ਜੀਉਂਦੇ ਰਹਿੰਦੇ ਹਨ।
ਪੁਰਾਣੀਆਂ ਕੋਡਬੇਸਾਂ ਆਮ ਤੌਰ 'ਤੇ ਨਵੀਨਤਾ ਤੋਂ ਬੇਮੁਹਰਤਾ ਅਤੇ ਭਰੋਸੇਯੋਗਤਾ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦੀਆਂ ਹਨ। ਨਿਯਮਤ ਜਾਂ ਹਾਈ-ਉਪਲਬਧਤਾ ਵਾਲੇ ਮਾਹੌਲ ਵਿੱਚ "ਬੋਰਿੰਗ" ਸਥਿਰਤਾ ਇੱਕ ਗੁਣ ਹੈ। ਇੱਕ ਭਾਸ਼ਾ ਜੋ ਸਾਲਾਂ ਤੱਕ ਇਕੋ ਭਰੋਸੇਯੋਗ ਪ੍ਰੋਗ੍ਰਾਮ ਚਲਾ ਸਕਦੀ ਹੈ—ਜਿਵੇਂ ਵਿਗਿਆਨ ਵਿੱਚ Fortran ਜਾਂ ਫਾਇਨੈਂਸ ਵਿੱਚ COBOL—ਉਹ ਇਸੀ ਕਾਰਨ ਰੀਲਵੇਂਟ ਰਹਿ ਸਕਦੀ ਹੈ।
ਭਾਸ਼ਾ ਸਿਰਫ ਸਿੰਟੈਕਸ ਨਹੀਂ—ਇਹ ਉਹ ਆਲੇ-ਦੁਆਲੇ ਦੀ ਫਰਮਾ ਹੈ ਜੋ ਰੋਜ਼ਾਨਾ ਉਪਯੋਗ ਯੋਗ ਬਣਾਂਦੀ ਹੈ। ਜਦ ਲੋਕ ਕਹਿੰਦੇ ਹਨ ਕਿ ਭਾਸ਼ਾ "ਮਰ ਗਈ", ਉਹ ਅਕਸਰ ਇਹੀ ਮਤਲਬ ਲੈਂਦੇ ਹਨ: "ਉਸ ਨਾਲ ਹਕੀਕਤ ਵਿੱਚ ਸਾਫਟਵੇਅਰ ਬਣਾਉਣਾ ਔਖਾ ਹੋ ਗਿਆ।" ਚੰਗੀ ਟੂਲਿੰਗ ਇਸਨੂੰ ਰੋਕਦੀ ਹੈ।
ਕੰਪਾਇਲਰ ਅਤੇ ਰਨਟਾਈਮ ਹੈਂ ਫੌਰਨਮੈਂਟਲ, ਪਰ ਬਚਾਉਣ ਲਈ ਰੋਜ਼ਾਨਾ ਵਾਰਕਬੈਂਚ ਵੀ ਜ਼ਰੂਰੀ ਹੁੰਦਾ ਹੈ:
ਇਕ ਪੁਰਾਣੀ ਭਾਸ਼ਾ ਵੀ ਜਿਉਂਦੀ ਰਹਿ ਸਕਦੀ ਹੈ ਜੇ ਇਹ ਟੂਲ ਰੱਖੇ ਜਾਂਦੇ ਹਨ ਅਤੇ ਪਹੁੰਚਣਯੋਗ ਰਹਿੰਦੇ ਹਨ।
ਹੈਰਾਨ ਕਰਨ ਵਾਲੀ ਪੈਟਰਨ ਇਹ ਹੈ ਕਿ ਨਵੇਂ ਭਾਸ਼ਾ ਫੀਚਰਾਂ ਤੋਂ ਵੱਧ ਟੂਲਿੰਗ ਅਪਗਰੇਡ ਇੱਕ ਭਾਸ਼ਾ ਨੂੰ ਨਵਾਂ ਜੀਵਨ ਦੇ ਸਕਦੇ ਹਨ। ਇੱਕ ਆਧੁਨਿਕ ਲੈਂਗਵੇਜ ਸਰਵਰ, ਤੇਜ਼ ਕੰਪਾਇਲਰ, ਸਾਫ਼ ਏਰਰ ਸੁਨੇਹੇ ਜਾਂ ਸੁਗਮ ਡਿਪੈਂਡੈਂਸੀ ਵਰਕਫਲੋ ਇੱਕ ਪੁਰਾਣੇ ਕੋਡਬੇਸ ਨੂੰ ਨਵਾਂ ਮਹਿਸੂਸ ਕਰਾ ਸਕਦੇ ਹਨ।
ਨਵੀਆਂ ਆਮਦਨੀਆਂ ਇਹ ਹਨ ਕਿ ਨਵੇਂ ਆਉਣ ਵਾਲੇ ਸਿੱਖਰ (ਨਿਊਕਮਰ) ਭਾਸ਼ਾ ਨੂੰ ਸਿਧੇ ਤੌਰ 'ਤੇ ਨਹੀਂ, ਉਸਦੀ ਵਰਤੋਂ ਦਾ ਅਨੁਭਵ ਅੰਕਿਆ ਕਰਦੇ ਹਨ। ਜੇ ਸੈਟਅੱਪ ਘੰਟਿਆਂ ਦੀ ਬਜਾਏ ਮਿੰਟਾਂ ਵਿੱਚ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਭਾਈਚਾਰਾ ਵਧਦਾ ਹੈ, ਟਿਊਟੋਰਿਅਲ ਵਧਦੇ ਹਨ ਅਤੇ ਭਰਤੀ ਆਸਾਨ ਹੋ ਜਾਂਦੀ ਹੈ।
ਲੰਬੀ ਉਮਰ ਲਾਇਨ LTS ਰਿਲੀਜ਼, ਸਪਸ਼ਟ ਡਿਪ੍ਰੇਕੇਸ਼ਨ ਨੀਤੀਆਂ ਅਤੇ ਸੰਭਾਲੇ ਅਪਗਰੇਡ ਰਾਹਾਂ ਤੋਂ ਵੀ ਆਉਂਦੀ ਹੈ। ਜਦ ਅਪਗਰੇਡ ਸੁਰੱਖਿਅਤ ਅਤੇ ਪੇਸ਼ਗੀ ਯੋਜਨਾਬੱਧ ਮਹਿਸੂਸ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਸੰਸਥਾਵਾਂ ਭਾਸ਼ਾ ਵਿੱਚ ਨਿਵੇਸ਼ ਕਰਨਾ ਜਾਰੀ ਰੱਖਦੀਆਂ ਹਨ।
ਡੌਕਸ, ਉਦਾਹਰਣ ਅਤੇ ਸਿੱਖਣ ਦੇ ਸਰੋਤ ਕੋਡ ਦੇ ਬਰਾਬਰ ਮਹੱਤਵਪੂਰਨ ਹਨ। ਸਪਸ਼ਟ "ਸ਼ੁਰੂਆਤ ਕਰੋ" ਗਾਈਡ, ਮਾਈਗ੍ਰੇਸ਼ਨ ਨੋਟਸ ਅਤੇ ਹਕੀਕਤੀ ਰੀਸੈਪੀਆਂ ਅਗਲੀ ਪੀੜ੍ਹੀ ਲਈ ਰੁਕਾਵਟ ਘਟਾਉਂਦੀਆਂ ਹਨ। ਇੱਕ ਭਾਸ਼ਾ ਜਿਸਦੀ ਡੌਕਸ ਮਜ਼ਬੂਤ ਹੈ, ਉਹ ਸਿਰਫ਼ ਟਿਕਦੀ ਹੀ ਨਹੀਂ—ਉਹ ਅਪਨਾਈ ਜਾ ਸਕਦੀ ਹੈ।
ਭਾਸ਼ਾਵਾਂ ਦੇ ਟਿਕਣ ਦਾ ਇੱਕ ਵੱਡਾ ਕਾਰਨ ਇਹ ਹੈ ਕਿ ਉਹ ਕਾਰੋਬਾਰਕ ਦ੍ਰਿਸ਼ਟੀ ਤੋਂ "ਸੁਰੱਖਿਅਤ" ਮਹਿਸੂਸ ਹੁੰਦੀਆਂ ਹਨ: ਟੀਮਾਂ ਸਾਲਾਂ ਦਾ ਨਿਵੇਸ਼ ਕਰਨ ਤੋਂ ਬਾਅਦ ਆਸ ਕਰ ਸਕਦੀਆਂ ਹਨ ਕਿ ਉਹ ਕੰਮ ਕਰਦੀਆਂ ਰਹਿਣ, ਕੰਪਾਇਲ ਹੁੰਦੀਆਂ ਰਹਿਣ ਅਤੇ ਉਹਨਾਂ ਦਾ ਵਿਵਹਾਰ ਇਕਸਾਰ ਰਹੇ।
ਜਦੋਂ ਕਿਸੇ ਭਾਸ਼ਾ ਦੀ ਇੱਕ ਸਪਸ਼ਟ, ਸਥਿਰ ਵਿਵਰਣਾ ਹੋਵੇ—ਅਕਸਰ ਕੋਈ ਮਿਆਰੀ ਸੰਸਥਾ ਇਸਨੂੰ ਨਭਾਉਂਦੀ—ਤਾਂ ਭਾਸ਼ਾ ਕਿਸੇ ਇਕ ਵੈਂਡਰ ਜਾਂ ਇਕ ਕੰਪਾਇਲਰ ਟੀਮ 'ਤੇ ਘੱਟ ਨਿਰਭਰ ਬਣਦੀ ਹੈ। ਮਿਆਰ ਇਹ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਨ ਕਿ ਭਾਸ਼ਾ ਦਾ ਅਰਥ ਕੀ ਹੈ: ਸਿੰਟੈਕਸ, ਕੋਰ ਲਾਇਬ੍ਰੇਰੀਆਂ, ਅਤੇ ਐਜ-ਕੇਸ ਵਿਵਹਾਰ।
ਇਹ ਸਥਿਰਤਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ ਵੱਡੀਆਂ ਸੰਸਥਾਵਾਂ ਆਪਣੀ ਕਾਰਵਾਈ ਕਿਸੇ "ਨਵੀਂ ਰਿਲੀਜ਼ ਦੀ ਮਰਜ਼ੀ" 'ਤੇ ਨਹੀਂ ਰੱਖਣੀਆਂ ਚਾਹੁੰਦੀਆਂ। ਇੱਕ ਸਾਂਝਾ ਸਪੈਸ ਇੱਕ ਤੋਂ ਵੱਧ ਇੰਪਲੀਮੈਂਟੇਸ਼ਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ, ਜੋ ਲਾਕ‑ਇਨ ਘਟਾਉਂਦਾ ਅਤੇ ਪੁਰਾਣੀਆਂ ਸਿਸਟਮਾਂ ਨੂੰ ਚਲਾਉਣਾ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ।
ਪਿੱਛੇ ਨਾਲ ਅਨੁਕੂਲਤਾ ਦਾ ਮਤਲਬ ਇਹ ਹੈ ਕਿ ਪੁਰਾਣਾ ਕੋਡ ਨਵੇਂ ਕੰਪਾਇਲਰ, ਰਨਟਾਈਮ ਜਾਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨਾਲ ਕੰਮ ਜਾਰੀ ਰੱਖਦਾ ਹੈ (ਯਾ ਘੱਟੋ-ਘੱਟ ਵਧੀਆ ਦਸਤਾਵੇਜ਼ੀ ਮਾਈਗ੍ਰੇਸ਼ਨ ਰਾਹ)। ਐਂਟਰਪ੍ਰਾਈਜ਼ ਇਹਦੀ ਕਦਰ ਕਰਦੀਆਂ ਹਨ ਕਿਉਂਕਿ ਇਹ ਟੋਟਲ ਕਾਸਟ ਓਨਰਸ਼ਿਪ ਘਟਾਉਂਦਾ ਹੈ:
ਪ੍ਰਡਿਕਟੇਬਲ ਵਿਵਹਾਰ ਨਿਯਮਤ ਵਾਤਾਵਰਨਾਂ ਵਿੱਚ ਖ਼ਾਸ ਕਰਕੇ ਕੀਮਤੀ ਹੁੰਦਾ ਹੈ—ਜੇ ਸਿਸਟਮ ਵੈਰੀਫਾਈਡ ਹੈ, ਤਾਂ ਅਪਡੇਟਸ ਕੰਮ-ਕਿਸਮ ਹੋਕੇ ਆਉਣ ਜਾਂਦੇ ਹਨ, ਨਾ ਕਿ ਮੁੜ-ਪੂਰੀ ਤਰ੍ਹਾਂ ਦੁਬਾਰਾ ਕੁਆਲੀਫਾਇ ਕਰਨ ਵਾਲੇ।
ਅਕਸਰ ਤੋੜ-ਫੋੜ ਵਾਲੇ ਬਦਲਾਅ ਲੋਕਾਂ ਨੂੰ ਦੂਰ ਧੱਕਦੇ ਹਨ ਕਿਉਂਕਿ ਉਹ "ਅਪਗਰੇਡ" ਨੂੰ ਇੱਕ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਬਦਲ ਦਿੰਦੇ ਹਨ। ਜੇ ਹਰ ਨਵੇਂ ਵਰਜ਼ਨ ਲਈ ਹਜ਼ਾਰਾਂ ਲਾਈਨਾਂ ਨੂੰ ਛੇੜਨਾ ਪੈਂਦਾ ਹੈ, ਡੀਪੈਂਡੈਸੀਜ਼ ਨੂੰ ਮੁੜ-ਤਬਦੀਲ ਕਰਨਾ ਪੈਂਦਾ ਹੈ ਅਤੇ ਵਿਵਹਾਰਕ ਫਰਕਾਂ ਦਾ ਪਿੱਛਾ ਕਰਨਾ ਪੈਂਦਾ ਹੈ, ਤਾਂ ਟੀਮਾਂ ਅਪਗਰੇਡ ਰੋਕ ਦਿੰਦੀਆਂ ਹਨ—ਜਾਂ ਇੱਕਸੋਸਿਸਟਮ ਨੂੰ ਛੱਡ ਦਿੰਦੀਆਂ ਹਨ।
ਅਜੇ ਵੀ, ਉਹ ਭਾਸ਼ਾਵਾਂ ਜੋ ਅਨੁਕੂਲਤਾ ਅਤੇ ਮਿਆਰੀਕਰਨ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦੀਆਂ ਹਨ, ਇੱਕ ਬੋਰੀੰਗ ਪਰ ਭਰੋਸੇਯੋਗ ਇੱਕ ਪੈਦਾ ਕਰਦੀਆਂ ਹਨ—ਅਤੇ ਇਹੀ ਅਕਸਰ ਉਹਨਾਂ ਨੂੰ ਹਾਇਪ ਹੋਣ ਤੋਂ ਬਾਅਦ ਵੀ ਸਰਗਰਮ ਰੱਖਦਾ ਹੈ।
ਭਾਸ਼ਾ ਨੂੰ ਹਰ ਨਵੀਨਤਮ ਰੁਝਾਨ 'ਚ ਜਿੱਤਣ ਦੀ ਲੋੜ ਨਹੀਂ; ਅਕਸਰ ਇਹ ਅਸਲ ਵਿੱਚ ਨਵੇਂ ਸਟੈਕ ਵਿੱਚ ਆਪਣਾ ਸਥਾਨ ਬਣਾ ਲੈਂਦੀ ਹੈ—ਚਾਹੇ ਉਹ ਵੈੱਬ ਸਰਵਿਸਿਜ਼ ਹੋਣ, ਆਧੁਨਿਕ ਸੁਰੱਖਿਆ ਲੋੜਾਂ ਹੋਣ ਜਾਂ ਡੇਟਾ ਸਾਇੰਸ ਹੋਵੇ—ਇੰਟਰੋਪਰੇਬਿਲਿਟੀ ਰਾਹੀਂ।
ਪੁਰਾਣੀਆਂ ਭਾਸ਼ਾਵਾਂ ਮੰਟੇਨ ਕੀਤੇ ਰਨਟਾਈਮ ਜਾਂ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸਮਰਥਤ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੁਆਰਾ ਆਧੁਨਿਕ ਸਮਰੱਥਾਵਾਂ ਤੱਕ ਪਹੁੰਚ ਹਾਸਲ ਕਰ ਲੈਂਦੀਆਂ ਹਨ। ਉਦਾਹਰਣਾਂ:
ਇਸ ਕਰਕੇ "ਪੁਰਾਣਾ" ਆਪਣੀ ਆਪ ਵਿੱਚ ਅਲੱਗ ਨਹੀ—ਜੇ ਭਾਸ਼ਾ ਦੁਨੀਆਂ ਨਾਲ ਭਰੋਸੇਯੋਗ ਢੰਗ ਨਾਲ ਗੱਲ ਕਰ ਸਕਦੀ ਹੈ, ਤਾਂ ਉਹ ਸਿਸਟਮਾਂ ਦੀਆਂ ਬਦਲਦੀਆਂ ਲੋੜਾਂ ਵਿੱਚ ਵੀ ਕੀਮਤੀ ਕੰਮ ਕਰ ਸਕਦੀ ਹੈ।
FFI ਦਾ ਮਤਲਬ ਹੈ foreign function interface—ਸਧਾਰਨ ਸ਼ਬਦਾਂ ਵਿੱਚ: ਇਹ ਇੱਕ ਪੁਲ ਹੈ ਜੋ ਇੱਕ ਭਾਸ਼ਾ ਦੇ ਕੋਡ ਨੂੰ ਦੂਜੇ ਭਾਸ਼ਾ ਦੇ ਕੋਡ ਨੂੰ ਕਾਲ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।
ਇਹ ਪੁਲ ਖ਼ਾਸ ਤੌਰ 'ਤੇ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ ਬਹੁਤ ਸਾਰਾ ਪ੍ਰਦਰਸ਼ਨ-ਨੂੰਮਈ ਅਤੇ ਬੁਨਿਆਦੀ ਸਾਫਟਵੇਅਰ C ਅਤੇ C++ ਵਿੱਚ ਲਿਖਿਆ ਹੋਇਆ ਹੈ; ਇਸ ਲਈ C/C++ ਨੂੰ ਕਾਲ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਇੱਕ ਯੂਨੀਵਰਸਲ ਪਾਰਟਸ ਬਿਨ ਤਰ੍ਹਾਂ ਹੈ।
ਇੱਕ ਪੈਟਰਨ ਹੈ ਉੱਚ-ਪੱਧਰ ਦੀਆਂ ਭਾਸ਼ਾਵਾਂ ਤੋਂ C/C++ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਕਾਲ ਕਰਨਾ। Python C ਵਿਸ਼ੇਸ਼ਾਂਤਰਾਂ (extensions) ਵਰਤਦਾ ਹੈ ਤੇਜ਼ੀ ਲਈ; Ruby ਅਤੇ PHP ਦੇ ਨੈਟਿਵ ਐਕਸਟੈਂਸ਼ਨ ਹਨ; ਕਈ ਨਵੀਆਂ ਭਾਸ਼ਾਵਾਂ ਵੀ C-ABI ਕੌਂਪੈਟਬਿਲਟੀ ਦਿੰਦੀਆਂ ਹਨ।
ਹੋਰ ਪੈਟਰਨ ਹੈ ਇੰਟਰਪ੍ਰੀਟਰ ਐਂਬੈੱਡ ਕਰਨਾ। ਵੱਡੇ ਸਿਸਟਮ ਨੂੰ ਮੁੜ-ਲਿਖਣ ਦੀ ਥਾਂ, ਟੀਮਾ ਇੱਕ ਸਕ੍ਰਿਪਟਿੰਗ ਭਾਸ਼ਾ (Lua, Python, ਜਾਵਾਸਕ੍ਰਿਪਟ) ਐਪ ਵਿੱਚ ਐਂਬੈੱਡ ਕਰਕੇ ਕਨਫਿਗਰੇਸ਼ਨ, ਪਲੱਗਇਨ ਸਿਸਟਮ ਜਾਂ ਤੇਜ਼ ਫੀਚਰ ਇਟਰੇਸ਼ਨ ਦਿੰਦੇ ਹਨ। ਇਸ ਵਿਚ, ਐਂਬੈੱਡ ਕੀਤੀ ਭਾਸ਼ਾ ਇੱਕ ਹਿੱਸਾ ਹੁੰਦੀ ਹੈ—ਸ਼ਕਤੀਸ਼ਾਲੀ ਪਰ ਪੂਰਾ ਉਤਪਾਦ ਨਹੀਂ।
ਇੰਟਰੋਪਰੇਬਿਲਿਟੀ "ਬਚਾਉ" ਨੂੰ ਨਵਾਂ ਮਤਲਬ ਦਿੰਦੀ ਹੈ: ਇੱਕ ਭਾਸ਼ਾ ਗਲੂ ਕੋਡ, ਐਕਸਟੈਂਸ਼ਨ ਪੜਤਾਲ ਜਾਂ ਇੱਕ ਸਥਿਰ ਕੋਰ ਵਜੋਂ ਅਹੰਕਾਰਸਾਰ ਰਹਿ ਸਕਦੀ ਹੈ ਜੋ ਆਧੁਨਿਕ ਕੰਮਾਂ ਨੂੰ ਖਾਸ ਮੋਡੀਊਲਾਂ ਨੂੰ ਸੌਂਪਰ ਦਿੰਦੀ ਹੈ।
ਕੁਝ ਭਾਸ਼ਾਵਾਂ ਇਸ ਲਈ ਟਿਕਦੀਆਂ ਹਨ ਕਿਉਂਕਿ ਖਾਸ ਉਦਯੋਗਾਂ ਨਵੀਂ ਚੀਜ਼ ਨੂੰ ਨਵਾਂ ਚੋਣਣ ਦੀ ਥਾਂ ਸਥਿਰਤਾ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦੀਆਂ ਹਨ। ਜਦ ਸਿਸਟਮ ਪੈਸੇ ਹਿਲਾਉਂਦਾ ਹੈ, ਐਮਰਜੈਂਸੀ ਕਾਲਾਂ ਰੂਟ ਕਰਦਾ ਹੈ ਜਾਂ ਮੈਡੀਕਲ ਡਿਵਾਇਸਾਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰਦਾ ਹੈ, "ਮਿਤਾਵਾਦੀ ਤਰੀਕੇ ਨਾਲ ਕੰਮ ਕਰਨਾ" ਉਹ ਗੁਣ ਹੈ ਜਿਸਨੂੰ ਤੁਸੀਂ ਆਸਾਨੀ ਨਾਲ ਤਬਦੀਲ ਨਹੀਂ ਕਰਦੇ।
ਫਾਇਨੇਨਸ ਕਲਾਸਿਕ ਉਦਾਹਰਨ ਹੈ: ਕੋਰ ਬੈਂਕਿੰਗ ਅਤੇ ਪੇਮੈਂਟ ਪ੍ਰੋਸੈਸਿੰਗ ਦਫਤਰ-ਟਰਾਂਜ਼ੈਕਸ਼ਨ ਸਿਸਟਮ ਅਕਸਰ ਵੱਡੇ, ਚੰਗੇ-ਟੈਸਟ ਕੀਤੇ ਹੋਏ ਕੋਡਬੇਸ ਚਲਾਉਂਦੇ ਹਨ ਜਿੱਥੇ ਡਾਊਨਟਾਈਮ ਮਹਿੰਗਾ ਹੁੰਦਾ ਹੈ। COBOL ਜਾਂ Java ਵਰਗੀਆਂ ਭਾਸ਼ਾਵਾਂ ਇਥੇ ਸਰਗਰਮ ਰਹਿੰਦੀਆਂ ਹਨ ਕਿਉਂਕਿ ਉਹ ਮਹੱਤਵਪੂਰਨ ਮਾਤਰਿਆਂ ਨੂੰ ਇੱਕ ਜੋਖਮ-ਮੁਕਤ ਤਰੀਕੇ ਨਾਲ ਸੰਭਾਲਦੀਆਂ ਹਨ।
ਟੈਲੀਕੌਮ ਸਿਸਟਮ ਵੀ ਇਸੇ ਤਰ੍ਹਾਂ: ਕੇਰੀਅਰ ਨੈੱਟਵਰਕ ਲਗਾਤਾਰ ਚਾਲੂ ਰਹਿਣ, ਲੰਬੇ ਹਾਰਡਵੇਅਰ ਲਾਈਫਸਾਈਕਲ ਅਤੇ ਸੰਭਾਲੇ ਅਪਗਰੇਡਾਂ ਦੀ ਮੰਗ ਕਰਦੇ ਹਨ। ਉਹ ਤਕਨੀਕਾਂ ਜਿੰਨ੍ਹਾਂ ਦੇ deterministic ਵਿਵਹਾਰ ਅਤੇ ਮੈਚੁਰ ਓਪਰੇਸ਼ਨ ਟੂਲਿੰਗ ਹੁੰਦੀਆਂ ਹਨ, ਉੱਥੇ ਟਿਕਦੀਆਂ ਹਨ।
ਐਅਰੋਸਪੇਸ ਅਤੇ ਡੀਫੈਂਸ ਵਿੱਚ ਸਰਟੀਫਿਕੇਸ਼ਨ ਇੱਕ ਫਿਲਟਰ ਵਰਗਾ ਕੰਮ ਕਰਦਾ ਹੈ। ਇਹਦੇ ਮਿਆਰ (ਜਿਵੇਂ DO-178C) ਬਦਲਾਅ ਨੂੰ ਮਹਿੰਗਾ ਬਣਾ ਦਿੰਦੇ ਹਨ, ਇਸ ਲਈ ਟੀਮਾਂ ਉਹ ਭਾਸ਼ਾਵਾਂ ਅਤੇ ਟੂਲਚੇਨ ਚੁਣਦੀਆਂ ਹਨ ਜਿਹੜੀਆਂ ਸੁਰੱਖਿਆ-ਵਰਤਾਵਾਂ, ਪੇਸ਼ਗੀ ਪرفਾਰਮੈਂਸ ਅਤੇ ਸਰਟੀਫਿਕੇਸ਼ਨ-ਮਿੱਤਰ ਇਕੋਸਿਸਟਮ ਰੱਖਦੀਆਂ ਹਨ। ਇਸੇ ਕਰਕੇ Ada ਜਾਂ ਨਿਰਜਨਤਾਵਾਦ C/C++ ਉਪਸੈੱਟ ਅਜੇ ਵੀ ਆਮ ਹਨ।
ਹੈਲਥਕੇਅਰ ਵਿੱਚ ਰੋਗੀ ਸੁਰੱਖਿਆ ਅਤੇ ਟਰੇਸਬਿਲਟੀ ਹੋਰ ਇਕ ਪੱਧਰ ਜੋੜਦੇ ਹਨ। ਮੈਡੀਕਲ ਸੌਫਟਵੇਅਰ ਅਤੇ ਡਿਵਾਇਸਾਂ (ਅਕਸਰ IEC 62304 ਜਾਂ FDA ਉਮੀਦਾਂ ਨਾਲ ਇਕਠੇ) ਲਈ ਲੋੜ ਹੈ ਕਿ ਜਰੂਰੀਤਾਂ, ਟੈਸਟਿੰਗ ਅਤੇ ਬਦਲਾਅ ਇਤਿਹਾਸ ਨੂੰ ਦਸਤਾਵੇਜ਼ ਕੀਤਾ ਜਾਵੇ—ਇਹ ਡਿਵੈਲਪਰ ਸੁਖਾਵਾਂ ਦੀ ਬਜਾਏ ਬਹੁਤ ਜ਼ਰੂਰੀ ਹੁੰਦਾ ਹੈ।
ਨਿਯਮਤ ਢਾਂਚੇ ਅਤੇ ਆਡਿਟ (SOX, PCI DSS, HIPAA ਆਦਿ) ਸੰਸਥਾਵਾਂ ਨੂੰ ਉਹ ਤਕਨੀਕਾਂ ਚੁਣਨ 'ਤੇ ਧੱਕਦੇ ਹਨ ਜੋ ਚੰਗੇ ਤਰੀਕੇ ਨਾਲ ਸਮਝੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਅਤੇ ਵਾਰ-ਵਾਰ ਵੈਰੀਫਾਈ ਕੀਤੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ। ਚਾਹੇ ਨਵੀਂ ਭਾਸ਼ਾ "ਵਧੀਆ" ਹੀ ਕਿਉਂ ਨਾ ਹੋਵੇ, ਇਸਨੂੰ ਸੁਰੱਖਿਅਤ, ਅਨੁਕੂਲ ਅਤੇ ਓਪਰੇਸ਼ਨਲੀ ਤੌਰ 'ਤੇ ਕੰਟਰੋਲਯੋਗ ਸਾਬਤ ਕਰਨ ਵਿੱਚ ਸਾਲ ਲੱਗ ਸਕਦੇ ਹਨ।
ਵੱਡੀਆਂ ਸੰਸਥਾਵਾਂ ਕਈ ਸਾਲਾਂ ਦੇ ਵੈਂਡਰ ਸਪੋਰਟ ਕਾਂਟਰੈਕਟ ਖਰੀਦਦੀਆਂ ਹਨ, ਸਟਾਫ਼ ਨੂੰ ਟਰੇਨ ਕਰਦੀਆਂ ਹਨ, ਅਤੇ ਮੰਨਣਯੋਗ ਸਟੈਕ 'ਤੇ ਸਟੈਂਡਰਡ ਬਣਾਉਂਦੀਆਂ ਹਨ। ਪ੍ਰੋਕਯੂਰਮੈਂਟ ਚੱਕਰ ਟੈਕ ਟ੍ਰੈਂਡਾਂ ਨੂੰ ਪਿੱਛੇ ਛੱਡ ਦਿੰਦੇ ਹਨ, ਅਤੇ ਨਿਯਮਕ ਰੈਗੂਲੇਟਰ ਮੁੱਖਤਾ ਲਗਾਤਾਰਤਾ ਦੀ ਉਮੀਦ ਰੱਖਦੇ ਹਨ। ਜਦ ਭਾਸ਼ਾ ਕੋਲ ਪੱਕਾ ਵੈਂਡਰ ਸਹਿਯੋਗ, ਲੰਬਾ-ਸਮਾਂ ਸਪੋਰਟ ਅਤੇ ਹੁਨਰ ਪਾਈਪਲਾਈਨ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਉਹ ਆਪਣੀ ਨਿਸ਼ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਦੀ ਹੈ।
ਨਤੀਜਾ: ਭਾਸ਼ਾਵਾਂ ਸਿਰਫ ਯਾਦਾਂ ਕਰਕੇ ਨਹੀਂ ਟਿਕਦੀਆਂ—ਉਹ ਇਸ ਲਈ ਟਿਕਦੀਆਂ ਹਨ ਕਿ ਉਨ੍ਹਾਂ ਦੀਆਂ ਖਾਸਤੌਰ 'ਤੇ ਤਾਕਤਾਂ (ਸੁਰੱਖਿਆ, ਨਿਰਣਯਾਤਕਤਾ, ਪੇਸ਼ਗੀ ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਪ੍ਰਮਾਣਿਤ ਓਪਰੇਸ਼ਨਲ ਵਿਵਹਾਰ) ਨਿਯਮਤ, ਉੱਚ-ਪ੍ਰਤੀਫਲ ਖੇਤਰਾਂ ਦੀਆਂ ਪਾਬੰਦੀਆਂ ਨਾਲ ਮਿਲਦੀਆਂ ਹਨ।
ਭਾਸ਼ਾ ਨੂੰ ਨੌਕਰੀ ਲਿਸਟਿੰਗ ਵਿੱਚ ਪ੍ਰਮੁੱਖ ਹੋਣਾ ਲਾਜ਼ਮੀ ਨਹੀਂ ਕਿ ਉਹ ਜੀਵਤ ਰਹੇ। ਯੂਨੀਵਰਸਿਟੀਆਂ, ਕਿਤਾਬਾਂ ਅਤੇ ਰਿਸਰਚ ਲੈਬਾਂ ਕਈ ਭਾਸ਼ਾਵਾਂ ਨੂੰ ਸਾਲਾਂ ਤੱਕ ਚਲਾਉਂਦੀਆਂ ਹਨ—ਕਈ ਵਾਰੀ ਮੁੱਖ ਪਾਠ-ਸਮੱਗਰੀ ਵਜੋਂ, ਕਈ ਵਾਰੀ ਇੱਕ "ਦੂਜੀ ਭਾਸ਼ਾ" ਜਿਨ੍ਹਾਂ ਰਾਹੀਂ ਛੋਟੇ-ਚੋਟੇ ਪਰਦਰਸ਼ਨ ਜਾਂ ਸੋਚ ਦੇ ਤਰੀਕਿਆਂ ਨੂੰ ਸਿੱਖਾਇਆ ਜਾਂਦਾ ਹੈ।
ਕਲਾਸਰੂਮ ਵਿੱਚ, ਭਾਸ਼ਾਵਾਂ ਅਕਸਰ ਇੱਕ ਪੈਰੈਡਾਇਮ ਦੇ ਸਾਫ ਉਦਾਹਰਣ ਵਜੋਂ ਵਰਤੀ ਜਾਂਦੀਆਂ ਹਨ:
ਇਹ "ਸਿੱਖਿਆ ਟੂਲ" ਦੀ ਭੂਮਿਕਾ ਖਾਲੀ ਢਿੱਲ ਨਹੀਂ—ਇਹ ਇੱਕ ਸਥਿਰ ਪਾਈਪਲਾਈਨ ਬਣਾਉਂਦੀ ਹੈ ਜੋ ਆਉਣ ਵਾਲੇ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਉਸ ਭਾਸ਼ਾ ਦੀ ਸੋਚ ਦਿੰਦੀ ਹੈ ਅਤੇ ਕਈ ਵਾਰੀ ਉਹਨਾਂ ਵਿਚਾਰਾਂ ਨੂੰ ਹੋਰ ਸਟੈਕਾਂ ਵਿੱਚ ਲਿਆਉਂਦੀ ਹੈ।
ਅਕਾਦਮੀ ਅਤੇ ਉਦਯੋਗਿਕ ਰਿਸਰਚ ਗਰੁੱਪ ਪਹਿਲਾਂ ਨਵੇਂ ਭਾਸ਼ਾ ਫੀਚਰਾਂ ਨੂੰ ਪ੍ਰੋਟੋਟਾਈਪ ਵਜੋਂ ਬਣਾਉਂਦੇ ਹਨ: ਟਾਈਪ ਸਿਸਟਮ, ਪੈਟਰਨ ਮੈਚਿੰਗ, ਗਾਰਬੇਜ ਕਲੇਕਸ਼ਨ, ਮੌਡੀਊਲ ਸਿਸਟਮ, concurrency ਮਾਡਲ ਅਤੇ ਫਾਰਮਲ ਵੇਰੀਫਿਕੇਸ਼ਨ। ਇਹ ਪ੍ਰੋਟੋਟਾਈਪ ਸਾਲਾਂ ਤੱਕ ਰਿਸਰਚ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਰਹਿ ਸਕਦੇ ਹਨ, ਪਰ ਉਹ ਵਿਚਾਰ ਬਾਅਦ ਵਿੱਚ ਮੈਨਸਟ੍ਰੀਮ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਦਿਖਾਈ ਦੇ ਸਕਦੇ ਹਨ।
ਇਸ ਲਈ ਪੁਰਾਣੀਆਂ ਭਾਸ਼ਾਵਾਂ.complete ਨਹੀਂ ਹੁੰਦੀਆਂ: ਜੇyntax-copy ਨਾ ਹੋਵੇ, ਤਾਂ ਵੀ ਉਹਨਾਂ ਦੇ ਵਿਚਾਰ ਹੋਰ ਰੂਪ ਵਿੱਚ ਉਤਰਨ।
ਸਿੱਖਿਆ ਵਿੱਚ ਵਰਤੋਂ ਨਾਲ ਅਕਸਰ ਵਿਦਿਆਰਥੀ ਲਾਇਬ੍ਰੇਰੀਆਂ, ਇੰਟਰਪ੍ਰੀਟਰ, ਕੰਪਾਇਲਰ ਅਤੇ ਟੂਲਿੰਗ ਨੂੰ ਬਾਹਰ ਲੈਕੇ ਜਾਂਦੇ ਹਨ; ਉਹ ਬਲੌਗ ਲਿਖਦੇ ਹਨ, ਨਿੱਛ-ਓਪਨ-ਸੋਰਸ ਭਾਈਚਾਰਾ ਬਣਾਉਂਦੇ ਹਨ, ਅਤੇ ਕਦੇ-ਕਦੇ ਮਾਹਿਰ ਖੇਤਰਾਂ ਵਿੱਚ ਪ੍ਰਯੋਗਤਮਕ ਤੌਰ 'ਤੇ ਇਸਨੂੰ ਤੈਨਾਤ ਕਰਦੇ ਹਨ।
ਇਸ ਲਈ ਜਦੋਂ ਕੋਈ ਭਾਸ਼ਾ ਕੋਰਸਾਂ ਅਤੇ ਰਿਸਰਚ ਵਿੱਚ ਰਹਿੰਦੀ ਹੈ, ਇਹ "ਮਰਿਆ" ਨਹੀਂ ਹੁੰਦੀ—ਇਹ ਅਜੇ ਵੀ ਸਾਫਟਵੇਅਰ ਡਿਜ਼ਾਈਨ ਨੂੰ ਆਕਾਰ ਦਿੰਦੀ ਹੈ।
ਹਰ ਭਾਸ਼ਾ ਨੋਸਟੈਲਜੀਆ ਜਾਂ ਲੈਗੇਸੀ ਕਾਰਨ ਨਹੀਂ ਜੀਉਂਦੀ। ਕੁਝ ਉਸ ਲਈ ਰਹਿੰਦੀਆਂ ਹਨ ਕਿ ਉਹ ਹੋਰਾਂ ਨਾਲੋਂ ਕੁਝ ਕੰਮ ਬਿਹਤਰ ਕਰਦੀਆਂ ਹਨ—ਜਾਂ ਘੱਟ ਅਣਚਾਹੇ ਚਿੰਤਾਵਾਂ ਨਾਲ।
ਜਦ ਤੁਸੀਂ ਹਾਰਡਵੇਅਰ ਦੀਆਂ ਸੀਮਾਵਾਂ 'ਤੇ ਧੱਕ ਰਹੇ ਹੋ ਜਾਂ ਇੱਕੋ ਹੀ ਕੰਪਿਊਟੇਸ਼ਨ ਨੂੰ ਮਿਲੀਅਨ ਵਾਰ ਚਲਾ ਰਹੇ ਹੋ, ਤਾਂ ਛੋਟੇ ਓਵਰਹੈੱਡ ਭਾਰੀ ਪੈ ਸਕਦੇ ਹਨ। ਜਿਹੜੀਆਂ ਭਾਸ਼ਾਵਾਂ ਪੇਸ਼ਗੀ ਪ੍ਰਦਰਸ਼ਨ, ਸਧਾਰਣ ਐਕਜ਼ੈਕਿਊਸ਼ਨ ਮਾਡਲ ਅਤੇ ਮੈਮੋਰੀ 'ਤੇ ਕਟਾਕਟ ਨ ਕੰਟਰੋਲ ਦਿੰਦੀਆਂ ਹਨ, ਉਹ ਅਕਸਰ ਬਦਲੀ ਨਹੀਂ ਹੁੰਦੀਆਂ।
ਇਹੀ ਕਾਰਨ ਹੈ ਕਿ ਹਾਰਡਵੇਅਰ-ਨਜ਼ਦੀਕੀਮਾਂਗਾਂ ਵਾਲੀ ਭਾਸ਼ਾ ਜ਼ਿਆਦਾਾਂ ਵੇਲੇ ਲੰਮਾ ਜੀਉਂਦੀ ਹੈ—ਜੇ ਤੁਹਾਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਪਤਾ ਹੋਵੇ ਕਿ ਮਸ਼ੀਨ ਕੀ ਕਰੇਗੀ, ਤਾਂ ਉਸਦੀ ਥਾਂ ਬਦਲਣਾ ਮੁਸ਼ਕਿਲ ਹੁੰਦਾ ਹੈ।
Fortran ਵਿਗਿਆਨਕ ਗਣਨਾ ਲਈ ਬਹੁਤ ਵਧੀਆ ਉਦਾਹਰਣ ਹੈ। ਵੱਡੀਆਂ ਸਿਮੂਲੇਸ਼ਨਾਂ, ਲੀਨੀਅਰ ਐਲਜੀਬਰਾ, HPC ਵਿਚ Fortran ਕੰਪਾਇਲਰ ਅਤੇ ਲਾਇਬ੍ਰੇਰੀਆਂ ਸਾਲਾਂ ਤੱਕ ਅਪਟੀਮਾਈਜ਼ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ। ਟੀਮਾਂ ਆਮ ਤੌਰ 'ਤੇ ਵੱਧ ਫੈਸ਼ਨਬਲ ਸਿੰਟੈਕਸ ਦੀ ਬਜਾਏ ਸਥਿਰ ਤੇ ਤੇਜ਼ ਨਤੀਜੇ ਚਾਹੁੰਦੀਆਂ ਹਨ।
ਐਂਬੈਡਡ ਸਿਸਟਮਾਂ ਲਈ C ਅਜੇ ਵੀ ਮੌਜੂਦ ਹੈ: ਇਹ ਮੈਸ਼ੀਨ ਦੇ ਨੇੜੇ ਹੈ, ਮਾਈਕ੍ਰੋਕਂਟਰੋਲਰਾਂ 'ਤੇ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਸਪੋਰਟ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਸ੍ਰੋਤਾਂ ਦੀ ਵਰਤੋਂ ਅਨੁਕੂਲ ਹੈ। ਜਦ ਤੁਹਾਡੇ ਕੋਲ ਕਠੋਰ ਮੈਮੋਰੀ ਜਾਂ ਰੀਅਲ-ਟਾਈਮ ਜ਼ਰੂਰਤਾਂ ਹੁੰਦੀਆਂ ਹਨ, ਤਾਂ ਇਹ ਅਨੁਕੂਲਤਾ ਵਿਕਲਪਾਂ ਤੋਂ ਜ਼ਿਆਦਾ ਮੁੱਲਵਾਨ ਹੁੰਦੀ ਹੈ।
ਡੇਟਾ ਕੁਐਰੀ ਲਈ SQL ਇਸ ਲਈ ਚੱਲਦਾ ਰਹਿੰਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹ ਸਮੱਸਿਆ ਨਾਲ ਮਿਲਦਾ ਹੈ: ਤੁਸੀਂ ਜੋ ਡੇਟਾ ਚਾਹੁੰਦੇ ਹੋ ਉਹ ਦਰਸਾਉਂਦੇ ਹੋ, ਨਾ ਕਿ ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੈ। ਨਵੇਂ ਡੇਟਾ ਪਲੇਟਫਾਰਮ ਵੀ ਆਮ ਤੌਰ 'ਤੇ SQL ਇੰਟਰਫੇਸ ਰੱਖਦੇ ਹਨ ਕਿਉਂਕਿ ਇਹ ਟੂਲਾਂ, ਟੀਮਾਂ ਅਤੇ ਦਹਾਕਿਆਂ ਦੇ ਗਿਆਨ ਦਰਮਿਆਨ ਇੱਕ ਸਾਂਝੀ ਭਾਸ਼ਾ ਹੈ।
ਇੱਕ ਸਿਹਤਮੰਦ ਇੰਜੀਨੀਅਰਿੰਗ ਸੰਸਕ੍ਰਿਤੀ ਇੱਕ ਭਾਸ਼ਾ ਨੂੰ ਹਰ ਕੰਮ ਲਈ ਜਬਰਦਸਤੀ ਨਹੀਂ ਲਗਾਉਂਦੀ। ਇਹ ਭਾਸ਼ਾ ਨੂੰ ਟੂਲ ਦੀ ਤਰ੍ਹਾਂ ਚੁਣਦੀ ਹੈ—ਮੁਲਭੂਤ ਰੋਕਾਂ, ਫੇਲ੍ਹ ਹੋਣ ਦੇ ਢੰਗਾਂ ਅਤੇ ਦੰਘ-ਮਰੰਦਾ ਦਿਖਕੇ। ਇਹੀ ਤਰੀਕਾ ਹੈ ਜਿਸ ਨਾਲ "ਪੁਰਾਣੀਆਂ" ਭਾਸ਼ਾਵਾਂ ਆਪਣੀ ਨਿਸ਼ ਵਿੱਚ ਪ੍ਰਯੋਗੀ ਰਹਿੰਦੀਆਂ ਹਨ—ਕਿ ਉਹ ਅਜੇ ਵੀ ਸਭ ਤੋਂ ਭਰੋਸੇਯੋਗ ਚੋਣ ਹਨ।
ਭਾਸ਼ਾ ਨੂੰ ਲੋਕਪ੍ਰਿਯਤਾ ਚਾਰਟ 'ਚ ਜਿੱਤਣ ਦੀ ਲੋੜ ਨਹੀਂ ਕਿ ਉਹ ਦੂਜੀ ਜ਼ਿੰਦਗੀ ਪ੍ਰਾਪਤ ਕਰੇ। ਰਿਵਾਈਵਲ ਆਮ ਤੌਰ 'ਤੇ ਉਸ ਵੇਲੇ ਹੁੰਦੇ ਹਨ ਜਦੋਂ ਭਾਸ਼ਾ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਕੁਝ ਬਦਲ ਜਾਵੇ—ਕਿਵੇਂ ਇਹ ਚੱਲਦੀ ਹੈ, ਕਿਵੇਂ ਪੈਕੇਜ ਹੁੰਦੇ ਹਨ, ਜਾਂ ਇਹ ਆਧੁਨਿਕ ਵਰਕਫਲੋਜ਼ ਵਿੱਚ ਕਿੱਥੇ ਫਿੱਟ ਹੁੰਦੀ ਹੈ।
ਜ਼ਿਆਦਾਤਰ ਵਾਪਸੀ ਇੱਕ ਦੋਹਰਾਓ ਵਾਲੇ ਪੈਟਰਨ ਨੂੰ ਫਾਲੋ ਕਰਦੀਆਂ ਹਨ:
ਨਵੇਂ ਨਿਸ਼ ਆਮ ਤੌਰ 'ਤੇ ਇਸ ਵੇਲੇ ਬਣਦੇ ਹਨ ਜਦੋਂ ਭਾਸ਼ਾ ਕਿਸੇ ਖ਼ਾਸ ਸਰਫੇਸ ਏਰੀਆ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਫਿੱਟ ਬਣ ਜਾਂਦੀ ਹੈ, ਭਾਵੇਂ ਇਹ ਮੁੱਖ ਐਪਲੀਕੇਸ਼ਨ ਭਾਸ਼ਾ ਨਾ ਹੋਵੇ। ਆਮ ਮਾਰਗ:
ਜਦੋਂ ਇੱਕ ਨਿਸ਼ ਟਿਕਦੀ ਹੈ, ਤਾਂ ਟਿਊਟੋਰਿਅਲ, ਲਾਇਬ੍ਰੇਰੀਆਂ ਅਤੇ ਭਰਤੀ ਪਾਇਪਲਾਈਨ ਉਸ ਨਿਸ਼ ਦੇ ਅਨੁਕੂਲ ਹੋ ਜਾਂਦੇ ਹਨ।
ਓਪਨ-ਸੋਰਸ ਮੇਨਟੇਨਰ ਅਤੇ ਸਮੁਦਾਇਕ ਇਵੈਂਟ ਵਧੇਰੇ ਮਹੱਤਵ ਰੱਖਦੇ ਹਨ ਜਿੰਨਾ ਉਨ੍ਹਾਂ ਨੂੰ ਕ੍ਰੈਡਿਟ ਮਿਲਦਾ ਹੈ। ਕੁਝ ਸਮਰਪਿਤ ਮੈਂਟੇਨਰ ਟੂਲਿੰਗ ਨੂੰ ਅਧੁਨਿਕ ਬਣਾਉਂਦੇ ਹਨ, ਰਿਲੀਜ਼ ਸਮੇਂ 'ਤੇ ਰੱਖਦੇ ਹਨ, ਅਤੇ ਸੁਰੱਖਿਆ ਮੁੱਦਿਆਂ 'ਤੇ ਜਵਾਬ ਦਿੰਦੇ ਹਨ। ਕਾਨਫਰੰਸ, ਮੀਟਅਪ ਅਤੇ ਹੈਕ-ਹਫ਼ਤੇ ਸ਼ੇਅਰਡ ਮੋਮੈਂਟਮ ਰਚਦੇ ਹਨ—ਨਵੇਂ ਯੋਗਦਾਨੀ ਆਉਂਦੇ ਹਨ, ਬੈਸਟ ਪ੍ਰੈਕਟਿਸ ਫੈਲਦੇ ਹਨ, ਅਤੇ ਕਾਮਯਾਬੀਆਂ ਦਸਤਾਵੇਜ਼ ਹੁੰਦੀਆਂ ਹਨ।
ਅਕੈਲ, ਖ਼ਾਲੀ ਹਾਈਪ ਲੰਬੇ ਸਮੇਂ ਲਈ ਕਾਫੀ ਨਹੀਂ ਹੁੰਦੀ। ਇੱਕ ਸਥਾਈ ਰਿਵਾਈਵਲ ਉਸ ਵੇਲੇ ਟਿਕਦਾ ਹੈ ਜਦੋਂ ਭਾਸ਼ਾ ਮੁੱਕਮਲ ਤੌਰ 'ਤੇ ਇੱਕ ਮੁੜ-ਆਉਣ ਵਾਲੀ ਸਮੱਸਿਆ ਨੂੰ ਹੋਰਾਂ ਨਾਲੋਂ ਬਿਹਤਰ ਹੱਲ ਕਰਦੀ ਹੈ—ਅਤੇ ਸਾਲਾਂ ਤੱਕ ਇਹ ਕਰਦੀ ਰਹਿੰਦੀ ਹੈ।
ਲੰਬੇ ਸਮੇਂ ਵਾਲੇ ਕੰਮ ਲਈ ਭਾਸ਼ਾ ਚੁਣਨਾ ਫੈਸ਼ਨ ਦੀ ਭਵਿੱਖਵਾਣੀ ਨਹੀਂ—ਇਹ ਇਸ ਗੱਲ 'ਤੇ ਧਿਆਨ ਦੇਣਾ ਹੈ ਕਿ ਟੂਲ ਚਲਾਉਣਯੋਗ, ਰੱਖਿਆ-ਯੋਗ ਅਤੇ ਭਰਤੀਯੋਗ ਰਹੇਗਾ।
ਜਾਣਚ-ਪੜਤਾਲਯੋਗ ਪਾਬੰਦੀਆਂ 'ਤੇ ਧਿਆਨ ਦਿਓ:
ਭਾਸ਼ਾ ਚੋਣ ਉਹ ਖ਼ਰਚ ਜੁੜਦਾ ਹੈ ਜੋ hello-world ਡੈਮੋ ਵਿੱਚ ਨਹੀਂ ਦਿਖਦਾ:
ਇੱਕ "ਸਸਤਾ" ਭਾਸ਼ਾ ਮਹਿੰਗੀ ਹੋ ਸਕਦੀ ਹੈ ਜੇ ਇਹ ਨਿਸ਼ੇ ਵਿਸ਼ੇਸ਼ ਮਾਹਿਰ ਮੰਗਦੀ ਹੋਵੇ ਜਾਂ ਮੁੜ-লਿਖਨ ਆਵ੍ਰਤੀ ਹੋਵੇ।
ਅਣਿਸ਼ਚਿਤਤਾ ਘਟਾਉਣ ਲਈ ਛੋਟੇ, ਸੋਚ-ਵਿਚਾਰ ਵਾਲੇ ਕਦਮ ਲਓ:
ਜੇ ਤੁਹਾਡਾ ਸਭ ਤੋਂ ਵੱਡਾ ਜੋਖਿਮ ਸਿਰਫ "ਅਸੀਂ ਇਸ ਨੂੰ ਕਿੰਨਾ ਤੇਜ਼ ਤਸਦੀਕ ਕਰ ਸਕਦੇ ਹਾਂ?" ਹੈ, ਤਾਂ ਪ੍ਰੋਟੋਟਾਈਪ ਤੇਜ਼ ਰਾਹ ਹੈ—ਖ਼ਾਸ ਕਰਕੇ ਜਦ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਆਖਿਰਕਾਰ ਇਹ ਸਧਾਰਣ ਕੋਡਬੇਸ ਵਾਂਗ ਚੱਲ ਸਕੇ। ਉਦਾਹਰਣ ਲਈ, Koder.ai ਇੱਕ vibe-coding ਪਲੇਟਫਾਰਮ ਹੈ ਜੋ ਟੀਮਾਂ ਨੂੰ ਚੈਟ ਰਾਹੀਂ ਵੈੱਬ, ਬੈਕਐਂਡ ਅਤੇ ਮੋਬਾਈਲ ਪ੍ਰੋਟੋਟਾਈਪ ਬਣਾਉਣ ਦਿੰਦਾ ਹੈ, ਫਿਰ ਸਰੋਤ ਕੋਡ ਐਕਸਪੋਰਟ ਕਰਨ ਦੀ ਸੁਵਿਧਾ ਦਿੰਦਾ ਹੈ (React ਫਰੰਟ-ਐਂਡ, Go + PostgreSQL ਬੈਕਐਂਡ, Flutter ਮੋਬਾਈਲ)। ਇਸ ਨੂੰ ਧਿਆਨ ਨਾਲ ਵਰਤਿਆਂ, ਇਹ ਇੱਕ ਵਿਚਾਰ ਤੋਂ ਕਾਰਜਕਾਰੀ ਪ੍ਰੂਫ-ਆਫ-ਕਾਂਸੈਪਟ ਤਕ ਸਮਾਂ ਘਟਾ ਸਕਦੀ ਹੈ, ਨਾਲ ਹੀ ਨਿਕਾਸ ਦਾ ਰਾਹ ਵੀ ਰੱਖਦੀ ਹੈ।
ਲੌਕ-ਇਨ ਤੋਂ ਪਹਿਲਾਂ ਇਹ ਪੁਸ਼ਟੀ ਕਰੋ:
ਇੱਕ ਭਾਸ਼ਾ ਅਸਲ ਵਿੱਚ "ਮਰਦੀ" ਓਦੋ ਹੁੰਦੀ ਹੈ ਜਦੋਂ ਉਹ ਹਕੀਕਤ ਵਿੱਚ ਵਰਤੋਂ ਯੋਗ ਨਾ ਰਹੇ—ਇਸ ਦਾ مطلب ਹੈ ਕਿ ਮੌਜੂਦਾ ਸਿਸਟਮਾਂ 'ਤੇ ਇਸ ਵਿੱਚ ਵਾਜਬ ਤਰੀਕੇ ਨਾਲ ਕੋਡ ਨਹੀਂ ਬਣਾਇਆ, ਚਲਾਇਆ ਜਾਂ ਰੱਖਿਆ ਜਾ ਸਕਦਾ।
ਲੋੜ ਕੇਵਲ ਲੋਕਪ੍ਰਿਯਤਾ ਜਾਂ ਬੂਟਕੈਂਪ ਕਵਰেজ ਖਤਮ ਹੋਣਾ ਹੈ—ਇਹ ਦਰਸਾਵਾਂਦਾ ਹੈ ਕਿ ਵਿਜ਼ੀਬਿਲਟੀ ਘੱਟ ਹੋ ਗਈ ਹੈ, ਪਰ ਹਕੀਕਤੀ ਜ਼ਿੰਦਗੀ ਵਿੱਚ ਵਰਤੋਂ ਬੰਦ ਹੋਣ ਦਾ ਮਤਲਬ ਨਹੀਂ।
ਕਿਉਂਕਿ ਟ੍ਰੈਂਡ ਧਿਆਨ ਨੂੰ ਮਾਪਦੇ ਹਨ, ਨਾਂ ਕਿ ਚਲਾਉਣ ਯੋਗ ਅਸਲ ਹਾਲਤ ਨੂੰ। ਇੱਕ ਭਾਸ਼ਾ ਸਰਵੇਖਣਾਂ ਵਿੱਚ ਥੱਲੇ ਆ ਸਕਦੀ ਹੈ ਪਰ ਫਿਰ ਵੀ ਜ਼ਰੂਰੀ ਪੇਰੋਲ, ਬਿੱਲਿੰਗ, ਲੋਜਿਸਟਿਕਸ ਜਾਂ ਇੰਫ਼ਰਾਸਟ੍ਰੱਕਚਰ ਸਿਸਟਮਾਂ ਨੂੰ ਚਲਾ ਰਹੀ ਹੋ ਸਕਦੀ ਹੈ।
ਫੈਸਲਾ ਲੈਣ ਵਾਲਿਆਂ ਲਈ ਮੁੱਖ ਸਵਾਲ ਇਹ ਹੈ: ਕੀ ਅਸੀਂ ਉਸ ਵਿੱਚ ਬਣੇ ਪ੍ਰਣਾਲੀਆਂ ਨੂੰ ابھی ਵੀ ਚਲਾ ਅਤੇ ਸਮਰਥਨ ਕਰ ਸਕਦੇ ਹਾਂ?
ਇੱਕ ਭਾਸ਼ਾ ਕਰੀਬ-ਮਰਤੀ ਹੋਣ ਦੀਆਂ ਪ੍ਰੈਕਟਿਕਲ ਨਿਸ਼ਾਨੀਆਂ ਇਹ ਹਨ:
ਫਿਰ ਵੀ, ਫੋਰਕ, ਸੰਰੱਖਿਅਤ ਟੂਲਚੇਨ ਜਾਂ ਪੇਡ ਸਪੋਰਟ ਰਾਹੀਂ ਭਾਸ਼ਾ ਨੂੰ ਦੁਬਾਰਾ ਜ਼ਿੰਦਾ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
ਕਿਉਂਕਿ ਕੀਮਤੀ ਸਾਫਟਵੇਅਰ ਫੈਸ਼ਨ ਤੋਂ ਜ਼ਿਆਦਾ ਲੰਬੇ ਸਮੇਂ ਤੱਕ ਕਿਰਦਾਰ ਨਿਭਾਂਦਾ ਹੈ। ਜੇ ਕੋਈ ਸਿਸਟਮ ਭਰੋਸੇਯੋਗ ਤਰੀਕੇ ਨਾਲ ਕਾਰੋਬਾਰੀ ਮੁੱਲ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਸੰਸਥਾਵਾਂ ਅਕਸਰ ਉਸਨੂੰ ਬਦਲਣ ਦੀ ਭੁੰਨੀ ਨਹੀਂ ਲੈਂਦੀਆਂ।
ਜਿਵੇਂ-ਜਿਵੇਂ ਉਹ ਸਿਸਟਮ ਚੱਲਦਾ ਰਹਿੰਦਾ ਹੈ, ਇਸਦੇ ਨਾਲ ਜੁੜੀ ਭਾਸ਼ਾ "ਸਹਿੱਤ" ਵਿੱਚ ਬਣੀ ਰਹਿੰਦੀ ਹੈ।
ਰੀਰਾਈਟ ਸਿਰਫ ਕੋਡ ਬਦਲਣਾ ਨਹੀਂ ਹੁੰਦਾ—ਇਹ ਕਾਰੋਬਾਰੀ ਅਨੇਕਾਂਤਾ ਦਾ ਪ੍ਰੋਜੈਕਟ ਵੀ ਹੁੰਦਾ ਹੈ। ਆਮ ਛੁਪੇ ਖ਼ਰਚੇ:
ਇਸ ਵਜ੍ਹਾ ਨਾਲ ਅਕਸਰ ਇੰਕ੍ਰਿਮੈਂਟਲ ਮਾਡਰਨਾਈਜੇਸ਼ਨ ਵਧੀਆ ਰਾਹ ਹੁੰਦਾ ਹੈ।
ਕਿਉਂਕਿ ਭਾਸ਼ਾ ਸਿਰਫ ਸਿੰਟੈਕਸ ਨਹੀਂ—ਇਹ ਉਸਦੇ ਆਲੇ-ਦੁਆਲੇ ਦੇ ਟੂਲਿੰਗ ਅਤੇ ਇਕੋਸਿਸਟਮ ਨਾਲ ਜੀਉਂਦੀ ਹੈ। ਜ਼ਰੂਰੀ ਟੂਲਿੰਗ:
ਇੱਕ ਪੁਰਾਣੀ ਭਾਸ਼ਾ ਵੀ ਤਾਜ਼ਗੀ ਮਹਿਸੂਸ ਕਰਾ ਸਕਦੀ ਹੈ ਜੇ ਇਹ ਟੂਲਚੇਨ ਬਚੇ ਰਹਿਣ।
ਜਦੋਂ ਭਾਸ਼ਾ ਦੀ ਇੱਕ ਸਪਸ਼ਟ, ਸਥਿਰ ਵਿਵਰਣਾ (spec) ਹੋਵੇ—ਖਾਸ ਕਰਕੇ ਜੇ ਕੋਈ standards body ਇਸਨੂੰ ਸੰਭਾਲਦਾ ਹੋਵੇ—ਤਾਂ ਇਹ ਇਕੋ ਵਿਕਾਸਕਾਂ 'ਤੇ ਨਿਰਭਰ ਨਹੀਂ ਰਹਿੰਦੀ।
ਪਿਛਲੇ ਵਰਜ਼ਨਾਂ ਨਾਲ ਅਨੁਕੂਲਤਾ (backward compatibility) ਉਦਯੋਗ ਲਈ ਕੀਮਤੀ ਹੈ ਕਿਉਂਕਿ ਇਹ ਅਪਗਰੇਡ ਨੂੰ ਇੱਕ ਵੱਡੇ ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਣ ਦੀ ਬਜਾਏ ਸੁਰੱਖਿਅਤ ਅਤੇ ਪੂਰਕ ਬਣਾਉਂਦੀ।
ਅਕਸਰ ਟੋਟਲ ਕਾਸਟ ਓਨਰਸ਼ਿਪ ਘੱਟ ਹੁੰਦਾ ਹੈ ਅਤੇ ਨਿਯਮਤ ਵਾਤਾਵਰਨਾਂ ਵਿੱਚ ਇਹ ਵਾਪਰਨਾ ਬਹੁਤ ਜ਼ਰੂਰੀ ਹੁੰਦਾ ਹੈ।
ਇੰਟਰੋਪਰੇਬਿਲਿਟੀ ਭਾਸ਼ਾ ਨੂੰ ਨਵੇਂ ਸਟੈਕਾਂ ਵਿੱਚ ਪਲੱਗ ਇਨ ਕਰਨ ਦੇ ਯੋਗ ਬਣਾਂਦੀ ਹੈ। ਆਮ ਰੁਦਜਾਨ:
ਇਸ ਤਰ੍ਹਾਂ "ਪੁਰਾਣੀ" ਭਾਸ਼ਾ ਆਮ ਤੌਰ 'ਤੇ ਅਲੱਗ-ਥੱਲਗ ਨਹੀਂ ਰਹਿੰਦੀ; ਇਹ ਗਲੂ, ਪਲੱਗਇਨ ਜਾਂ ਕੋਰ ਕੰਪੋਨੈਂਟ ਵਜੋਂ ਅਹਮ ਰਹਿ ਸਕਦੀ ਹੈ।
ਉੱਚ-ਖ਼ਤਰੇ ਵਾਲੇ ਖੇਤਰਾਂ ਵਿੱਚ ਨਵਾਂ ਚੁਣਨਾ ਘੱਟ ਲੋਭਦਾਇਕ ਹੁੰਦਾ ਹੈ ਕਿਉਂਕਿ ਬਦਲਾਅ ਮਹਿੰਗੇ ਜਾਂ ਖਤਰਨਾਕ ਹੋ ਸਕਦੇ ਹਨ। ਉਦਾਹਰਣਾਂ: ਫਾਇਨੇਨਸ, ਟੈਲੀਕੌਮ, ਐਅਰੋਸਪੇਸ/ਡੀਫੈਂਸ, ਹੈਲਥਕੇਅਰ।
ਨਿਯਮ, ਆਡਿਟ, ਅਤੇ ਸਰਪਲਾਇਰ ਸਪੋਰਟ ਸਾਈਕਲ ਭਾਸ਼ਾ ਅਤੇ ਟੂਲਿੰਗ ਨੂੰ "ਸਟਿੱਕੀ" ਬਣਾ ਦਿੰਦੇ ਹਨ—ਜੋ ਕਿ ਨਵੇਂ ਵਿਕਲਪਾਂ ਨੂੰ ਤੁਰੰਤ ਲੈ ਕੇ ਆਉਣਾ ਮੁਸ਼ਕਲ ਕਰ ਦਿੰਦੇ ਹਨ।
ਭਾਸ਼ਾ ਨੂੰ ਨੌਕਰੀਆਂ 'ਚ ਪ੍ਰਮੁੱਖ ਹੋਣਾ ਲਾਜ਼ਮੀ ਨਹੀਂ ਕਿ ਉਹ ਜੀਵੰਤ ਰਹੇ। ਯੂਨੀਵਰਸਿਟੀਆਂ, ਟੈਕਸਟਬੁੱਕ ਅਤੇ ਰਿਸਰਚ ਲੈਬਾਂ ਕਈ ਭਾਸ਼ਾਵਾਂ ਨੂੰ ਸਾਲਾਂ ਤੱਕ ਆਗਾਹ ਰੱਖਦੀਆਂ ਹਨ—ਕਈ ਵਾਰੀ ਇੱਕ ਪੈਡਾਗੌਜਿਕ ਟੂਲ ਵਜੋਂ।
ਇਸ ਨਾਲ ਅਗਲੇ ਪੀੜ੍ਹੀ ਲਈ ਇੱਕ ਪਾਈਪਲਾਈਨ ਬਣਦੀ ਹੈ: ਡਿਵੈਲਪਰ ਭਾਸ਼ਾ ਦੀ ਸੋਚ ਸਿੱਖਦੇ ਹਨ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਉਹਨਾਂ ਵਿਚਾਰਾਂ ਨੂੰ ਹੋਰ ਸਟੈਕਾਂ ਵਿੱਚ ਲਿਆਉਂਦੇ ਹਨ।
ਕਈ ਭਾਸ਼ਾਵਾਂ ਇਸ ਕਰਕੇ ਵੀ ਟਿਕੀਆਂ ਰਹਿੰਦੀਆਂ ਹਨ ਕਿਉਂਕਿ ਕੁਝ ਕੰਮਾਂ ਲਈ ਉਹ ਅਜੇ ਵੀ ਸਭ ਤੋਂ ਵਧੀਆ ਹਨ—ਇਸਦੇ ਕਾਰਨ ਹਨ ਪ੍ਰਦਰਸ਼ਨ, ਭਵਿੱਖਵਾਣੀ ਪੈਟਰਨ ਅਤੇ ਹਾਰਡਵੇਅਰ-ਨਜ਼ਦੀਕੀ ਨਿਯੰਤਰਣ।
ਉਦਾਹਰਣਾਂ:
ਹਰੇਕ ਖੇਤਰ ਵਿੱਚ "ਸਹੀ ਉਪਕਾਰ" ਫੈਸਲਾ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇਹੀ ਕਾਰਨ ਹੈ ਕਿ ਕੁਝ ਪੁਰਾਣੀਆਂ ਭਾਸ਼ਾਵਾਂ ਅਜੇ ਵੀ ਬਿਹਤਰ ਚੋਣ ਰਹਿੰਦੀਆਂ ਹਨ।
ਭਾਸ਼ਾ ਨੂੰ ਦੂਜੀ ਜ਼ਿੰਦਗੀ ਮਿਲਣ ਦੀਆਂ ਆਮ ਕਾਰਨ:
ਜਦੋਂ ਕੋਈ ਨਵਾਂ ਨਿਸ਼ ਬਣ ਜਾਂਦਾ ਹੈ (ਸਕ੍ਰਿਪਟਿੰਗ, ਇੰਫ੍ਰਾਸਟ੍ਰੱਕਚਰ ਟੂਲਿੰਗ, ਗਲੂ ਕੋਡ), ਤਾਂ ਟਿਊਟੋਰਿਅਲ, ਲਾਇਬ੍ਰੇਰੀ ਅਤੇ ਭਰਤੀ ਰਾਹੀਂ ਆਪਣਾ ਵੇਕਟਰ ਬਣਾਉਂਦਾ ਹੈ।
ਹਾਈਪ ਆਪਣੇ ਆਪ ਵਿੱਚ ਲੰਬੇ ਸਮੇਂ ਲਈ ਨਹੀਂ ਚੱਲਦੀ—ਲੰਬਾ ਰਹਿਣ ਲਈ ਸਥਿਰ ਟੂਲਿੰਗ, ਵਾਇਦੇ ਅਤੇ ਰੀਲ-ਵਰਕ ਸੁੱਕਿਆਂ ਦੀ ਲੜੀ ਜ਼ਰੂਰੀ ਹੈ।
ਲੰਬੇ ਸਮੇਂ ਲਈ ਭਾਸ਼ਾ ਚੁਣਨਾ ਫੈਸ਼ਨ ਭਵਿੱਖਾਂ ਦੀ ਭਵਿੱਖਵਾਣੀ ਨਹੀਂ—ਇਹ ਇਸ ਗੱਲ 'ਤੇ ਆਧਾਰਿਤ ਹੈ ਕਿ ਕੀ ਉਹ ਕੰਮ ਯੋਗ, ਰੱਖਿਆ-ਯੋਗ ਅਤੇ ਭਰਤੀਯੋਗ ਰਹੇਗੀ।
ਮੁੱਢਲਾ ਮਾਪਦੰਡ:
-Hiring market: ਕੀ ਸਥਾਨਕ ਜਾਂ ਰਿਮੋਟ ਤੌਰ 'ਤੇ ਮੁਹੱਤਵਪੂਰਨ ਤਜਰਬੇਕਾਰ ਮਿਲਦੇ ਹਨ? -Library maturity: ਕੀ ਮੁੱਖ ਲਾਇਬ੍ਰੇਰੀਆਂ ਸਥਿਰ ਅਤੇ ਵਧੀਆ ਦਸਤਾਵੇਜ਼ ਵਾਲੀਆਂ ਹਨ? -Deployment targets: ਇਹ ਕਿੱਥੇ ਚੱਲਣਾ ਚਾਹੀਦਾ ਹੈ (ਬ੍ਰਾਊਜ਼ਰ, ਮੋਬਾਇਲ, ਐਂਬੈਡਡ, ਸਰਵਰਲੇਸ, ਆਦਿ)? -Integration needs: ਕੀ ਇਹ ਤੁਹਾਡੇ ਮੌਜੂਦਾ ਸਿਸਟਮਾਂ ਨਾਲ ਚੰਗੀ ਤਰ੍ਹਾਂ ਗੱਲ ਕਰ ਸਕਦੀ ਹੈ?
ਅਤੇ ਜੋਖਮ ਘਟਾਉਣ ਲਈ:
ਇਸ ਵਿੱਚ Koder.ai ਵਰਗੇ ਟੂਲ ਪ੍ਰੋਟੋਟਾਈਪ ਤਿਆਰ ਕਰਨ 'ਚ ਤੇਜ਼ੀ ਲਿਆ ਸਕਦੇ ਹਨ—ਪਰ ਸਦਾ ਨਿਰਯਾਤ ਕੀਤੇ ਕੋਡ ਅਤੇ ਇੰਕ੍ਰਿਮੈਂਟਲ ਰੀਫੈਕਟਰਿੰਗ ਲਈ ਰਾਹ ਰੱਖੋ।
