ਪਾਈਥਨ ਕੋਡ ਦੀਆਂ 4 ਮਿਲੀਅਨ ਲਾਈਨਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਦਾ ਮਾਰਗ। ਭਾਗ 1

ਅੱਜ ਅਸੀਂ ਤੁਹਾਡੇ ਧਿਆਨ ਵਿੱਚ ਸਮੱਗਰੀ ਦੇ ਅਨੁਵਾਦ ਦਾ ਪਹਿਲਾ ਹਿੱਸਾ ਲਿਆਉਂਦੇ ਹਾਂ ਕਿ ਕਿਵੇਂ ਡ੍ਰੌਪਬਾਕਸ ਪਾਈਥਨ ਕੋਡ ਦੇ ਟਾਈਪ ਕੰਟਰੋਲ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ।

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

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

→ ਦੂਜਾ ਭਾਗ ਪੜ੍ਹੋ

ਟਾਈਪ ਜਾਂਚ ਕਿਉਂ ਜ਼ਰੂਰੀ ਹੈ?

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

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

• ਕੀ ਇਹ ਫੰਕਸ਼ਨ ਵਾਪਸ ਕਰ ਸਕਦਾ ਹੈ None?
• ਇਹ ਦਲੀਲ ਕੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ? items?
• ਗੁਣ ਦੀ ਕਿਸਮ ਕੀ ਹੈ id: int ਕੀ ਇਹ ਹੈ, str, ਜਾਂ ਸ਼ਾਇਦ ਕੁਝ ਕਸਟਮ ਕਿਸਮ?
• ਕੀ ਇਹ ਦਲੀਲ ਇੱਕ ਸੂਚੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ? ਕੀ ਇਸ ਨੂੰ ਇੱਕ ਟੂਪਲ ਪਾਸ ਕਰਨਾ ਸੰਭਵ ਹੈ?

ਜੇ ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਟਾਈਪ-ਐਨੋਟੇਟਿਡ ਕੋਡ ਸਨਿੱਪਟ ਨੂੰ ਦੇਖਦੇ ਹੋ ਅਤੇ ਸਮਾਨ ਸਵਾਲਾਂ ਦੇ ਜਵਾਬ ਦੇਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋ, ਤਾਂ ਇਹ ਪਤਾ ਚਲਦਾ ਹੈ ਕਿ ਇਹ ਸਭ ਤੋਂ ਆਸਾਨ ਕੰਮ ਹੈ:

class Resource:
    id: bytes
    ...
    def read_metadata(self, 
                      items: Sequence[str]) -> Dict[str, MetadataItem]:
        ...

• read_metadata ਵਾਪਸ ਨਹੀਂ ਆਉਂਦਾ None, ਕਿਉਂਕਿ ਵਾਪਸੀ ਦੀ ਕਿਸਮ ਨਹੀਂ ਹੈ Optional[…].
• ਦਲੀਲ items ਲਾਈਨਾਂ ਦਾ ਕ੍ਰਮ ਹੈ। ਇਸ ਨੂੰ ਬੇਤਰਤੀਬੇ ਦੁਹਰਾਇਆ ਨਹੀਂ ਜਾ ਸਕਦਾ।
• ਗੁਣ id ਬਾਈਟਾਂ ਦੀ ਇੱਕ ਸਤਰ ਹੈ।

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

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

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

ਅਜਿਹੀਆਂ ਪ੍ਰਣਾਲੀਆਂ ਦੀ ਵਰਤੋਂ ਦੇ ਹੋਰ ਫਾਇਦੇ ਹਨ, ਅਤੇ ਉਹ ਪਹਿਲਾਂ ਹੀ ਪੂਰੀ ਤਰ੍ਹਾਂ ਗੈਰ-ਮਾਮੂਲੀ ਹਨ:

• ਟਾਈਪ ਚੈਕਿੰਗ ਸਿਸਟਮ ਕੁਝ ਛੋਟੀਆਂ (ਅਤੇ ਇੰਨੀਆਂ ਛੋਟੀਆਂ ਨਹੀਂ) ਗਲਤੀਆਂ ਦਾ ਪਤਾ ਲਗਾ ਸਕਦਾ ਹੈ। ਇੱਕ ਆਮ ਉਦਾਹਰਣ ਹੈ ਜਦੋਂ ਉਹ ਇੱਕ ਮੁੱਲ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨਾ ਭੁੱਲ ਜਾਂਦੇ ਹਨ None ਜਾਂ ਕੋਈ ਹੋਰ ਵਿਸ਼ੇਸ਼ ਸਥਿਤੀ।
• ਕੋਡ ਰੀਫੈਕਟਰਿੰਗ ਨੂੰ ਬਹੁਤ ਸਰਲ ਬਣਾਇਆ ਗਿਆ ਹੈ ਕਿਉਂਕਿ ਟਾਈਪ ਚੈਕਿੰਗ ਸਿਸਟਮ ਅਕਸਰ ਇਸ ਬਾਰੇ ਬਹੁਤ ਸਹੀ ਹੁੰਦਾ ਹੈ ਕਿ ਕਿਹੜੇ ਕੋਡ ਨੂੰ ਬਦਲਣ ਦੀ ਲੋੜ ਹੈ। ਉਸੇ ਸਮੇਂ, ਸਾਨੂੰ ਟੈਸਟਾਂ ਦੇ ਨਾਲ 100% ਕੋਡ ਕਵਰੇਜ ਦੀ ਉਮੀਦ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ, ਜੋ ਕਿ ਕਿਸੇ ਵੀ ਸਥਿਤੀ ਵਿੱਚ, ਆਮ ਤੌਰ 'ਤੇ ਸੰਭਵ ਨਹੀਂ ਹੁੰਦਾ ਹੈ। ਸਮੱਸਿਆ ਦੇ ਕਾਰਨ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਸਾਨੂੰ ਸਟੈਕ ਟਰੇਸ ਦੀ ਡੂੰਘਾਈ ਵਿੱਚ ਜਾਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।
• ਵੱਡੇ ਪ੍ਰੋਜੈਕਟਾਂ 'ਤੇ ਵੀ, mypy ਅਕਸਰ ਇੱਕ ਸਕਿੰਟ ਦੇ ਇੱਕ ਹਿੱਸੇ ਵਿੱਚ ਪੂਰੀ ਕਿਸਮ ਦੀ ਜਾਂਚ ਕਰ ਸਕਦਾ ਹੈ। ਅਤੇ ਟੈਸਟਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ ਕਈ ਸਕਿੰਟ ਜਾਂ ਮਿੰਟ ਲੱਗਦੇ ਹਨ। ਟਾਈਪ ਚੈਕਿੰਗ ਸਿਸਟਮ ਪ੍ਰੋਗਰਾਮਰ ਨੂੰ ਤੁਰੰਤ ਫੀਡਬੈਕ ਦਿੰਦਾ ਹੈ ਅਤੇ ਉਸਨੂੰ ਆਪਣਾ ਕੰਮ ਤੇਜ਼ੀ ਨਾਲ ਕਰਨ ਦਿੰਦਾ ਹੈ। ਉਸ ਨੂੰ ਹੁਣ ਇਕਾਈ ਟੈਸਟਾਂ ਨੂੰ ਕਾਇਮ ਰੱਖਣ ਲਈ ਨਾਜ਼ੁਕ ਅਤੇ ਸਖ਼ਤ ਲਿਖਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ ਜੋ ਕੋਡ ਟੈਸਟ ਦੇ ਨਤੀਜਿਆਂ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਅਸਲ ਇਕਾਈਆਂ ਨੂੰ ਨਕਲੀ ਅਤੇ ਪੈਚਾਂ ਨਾਲ ਬਦਲਦੇ ਹਨ।

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

ਮਾਈਪੀ ਦਾ ਪਿਛੋਕੜ

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

ਟਾਈਪ ਚੈਕਿੰਗ ਵਿੱਚ ਮੇਰਾ ਅਸਲ ਕੰਮ ਪਾਈਥਨ ਦਾ ਉਦੇਸ਼ ਨਹੀਂ ਸੀ। ਇਸਦੀ ਬਜਾਏ, ਮੈਂ ਇੱਕ ਛੋਟੀ ਜਿਹੀ "ਘਰੇਲੂ" ਭਾਸ਼ਾ ਵਰਤੀ ਅਲੋਰ. ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਨ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਇਹ ਸਮਝਣ ਦੇਵੇਗੀ ਕਿ ਅਸੀਂ ਕਿਸ ਬਾਰੇ ਗੱਲ ਕਰ ਰਹੇ ਹਾਂ (ਟਾਈਪ ਐਨੋਟੇਸ਼ਨ ਇੱਥੇ ਵਿਕਲਪਿਕ ਹਨ):

def Fib(n as Int) as Int
  if n <= 1
    return n
  else
    return Fib(n - 1) + Fib(n - 2)
  end
end

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

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

ਅਸਲ ਵਿੱਚ, ਮੇਰੇ ਟਾਈਪ ਸਿਸਟਮ ਦੁਆਰਾ ਸਮਰਥਿਤ ਭਾਸ਼ਾ ਨੂੰ ਇਸ ਸਮੇਂ ਪਾਇਥਨ ਨਹੀਂ ਕਿਹਾ ਜਾ ਸਕਦਾ ਹੈ: ਇਹ ਪਾਈਥਨ 3 ਟਾਈਪ ਐਨੋਟੇਸ਼ਨ ਸੰਟੈਕਸ ਦੀਆਂ ਕੁਝ ਸੀਮਾਵਾਂ ਦੇ ਕਾਰਨ ਪਾਈਥਨ ਦਾ ਇੱਕ ਰੂਪ ਸੀ।

ਇਹ ਜਾਵਾ ਅਤੇ ਪਾਈਥਨ ਦੇ ਮਿਸ਼ਰਣ ਵਾਂਗ ਦਿਖਾਈ ਦਿੰਦਾ ਸੀ:

int fib(int n):
    if n <= 1:
        return n
    else:
        return fib(n - 1) + fib(n - 2)

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

ਮੈਂ ਸਾਂਤਾ ਕਲਾਰਾ ਵਿੱਚ PyCon 2013 ਵਿੱਚ ਆਪਣਾ ਪ੍ਰੋਜੈਕਟ ਪੇਸ਼ ਕਰਨਾ ਸਮਾਪਤ ਕੀਤਾ। ਮੈਂ ਇਸ ਬਾਰੇ ਗੁਇਡੋ ਵੈਨ ਰੋਸਮ ਨਾਲ ਵੀ ਗੱਲ ਕੀਤੀ, ਜੀਵਨ ਲਈ ਪਰਉਪਕਾਰੀ ਪਾਈਥਨ ਤਾਨਾਸ਼ਾਹ। ਉਸਨੇ ਮੈਨੂੰ ਆਪਣਾ ਸੰਟੈਕਸ ਛੱਡਣ ਅਤੇ ਮਿਆਰੀ ਪਾਈਥਨ 3 ਸੰਟੈਕਸ ਨਾਲ ਜੁੜੇ ਰਹਿਣ ਲਈ ਯਕੀਨ ਦਿਵਾਇਆ। ਪਾਈਥਨ 3 ਫੰਕਸ਼ਨ ਐਨੋਟੇਸ਼ਨਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ, ਇਸਲਈ ਮੇਰੀ ਉਦਾਹਰਣ ਨੂੰ ਹੇਠਾਂ ਦਰਸਾਏ ਅਨੁਸਾਰ ਦੁਬਾਰਾ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਨਤੀਜੇ ਵਜੋਂ ਇੱਕ ਆਮ ਪਾਈਥਨ ਪ੍ਰੋਗਰਾਮ ਹੈ:

def fib(n: int) -> int:
    if n <= 1:
        return n
    else:
        return fib(n - 1) + fib(n - 2)

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

products = []  # type: List[str]  # Eww

ਪਾਈਥਨ 2 ਦਾ ਸਮਰਥਨ ਕਰਨ ਲਈ ਟਾਈਪ ਟਿੱਪਣੀਆਂ ਵੀ ਕੰਮ ਆਉਂਦੀਆਂ ਹਨ, ਜਿਸ ਵਿੱਚ ਟਾਈਪ ਐਨੋਟੇਸ਼ਨਾਂ ਲਈ ਬਿਲਟ-ਇਨ ਸਮਰਥਨ ਨਹੀਂ ਹੈ:

f fib(n):
    # type: (int) -> int
    if n <= 1:
        return n
    else:
        return fib(n - 1) + fib(n - 2)

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

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

ਨੂੰ ਜਾਰੀ ਰੱਖਿਆ ਜਾਵੇਗਾ…

ਪਿਆਰੇ ਪਾਠਕ! ਜੇਕਰ ਤੁਸੀਂ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਕਿਰਪਾ ਕਰਕੇ ਸਾਨੂੰ ਉਹਨਾਂ ਪ੍ਰੋਜੈਕਟਾਂ ਦੇ ਪੈਮਾਨੇ ਬਾਰੇ ਦੱਸੋ ਜੋ ਤੁਸੀਂ ਇਸ ਭਾਸ਼ਾ ਵਿੱਚ ਵਿਕਸਿਤ ਕਰਦੇ ਹੋ।

ਸਰੋਤ: www.habr.com