ਮਿਸਿੰਗ ਐਕਸਪੋਰਟਸ ਤੋਂ ਅੱਗੇ: ਇੱਕ ਅਰਲੀ ਗਾਰਬੇਜ ਕਲੈਕਟਰ ਬਣਾਉਣਾ
ਮੈਂ Webpack ਡਾਕੂਮੈਂਟੇਸ਼ਨ ਵਿੱਚ ਮਿਸਿੰਗ ਲਿੰਕਸ ਨੂੰ ਠੀਕ ਕਰਨ ਲਈ ਇੱਕ ਸਟੈਂਡਰਡ ਪਲੱਗਇਨ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ। ਇਹ ਅਸਫਲ ਰਿਹਾ।
ਇੱਕ ਵੱਡੇ ਕੋਡਬੇਸ (codebase) ਵਿੱਚ ਪਲੱਗਇਨ ਨੂੰ ਜੋੜਨਾ ਕੋਈ ਸੌਖਾ ਕੰਮ ਨਹੀਂ ਹੈ। ਇਹ ਇੱਕ ਆਰਕੀਟੈਕਚਰਲ ਚੁਣੌਤੀ ਬਣ ਗਿਆ। ਮੈਨੂੰ Abstract Syntax Tree (AST) ਮੈਨੀਪੂਲੇਸ਼ਨ, ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਅਤੇ ਰਿਕਰਸਿਵ ਲੂਪਸ (recursive loops) ਨੂੰ ਸੰਭਾਲਣਾ ਪਿਆ।
ਸਟੈਂਡਰਡ ਪਲੱਗਇਨਾਂ ਨਾਲ ਸਮੱਸਿਆ
ਮੈਂ ਹੱਲ ਲੱਭਣ ਲਈ ਤਿੰਨ ਪ੍ਰਯੋਗ ਕੀਤੇ।
ਪ੍ਰਯੋਗ 1: ਪਲੱਗਇਨ ਨੇ 135 ਟਾਈਪਸ (types) ਨੂੰ ਰਿਕਵਰ ਕੀਤਾ। ਹਾਲਾਂਕਿ, ਇਸਨੇ ਉਹਨਾਂ ਨੂੰ ਇੱਕ ਅੰਦਰੂਨੀ ਮੋਡਿਊਲ (internal module) ਵਿੱਚ ਰੱਖ ਦਿੱਤਾ। ਸਾਡੇ ਟੂਲ ਨੇ ਉਹਨਾਂ ਲਈ ਇੱਕ ਵੱਖਰਾ ਫੋਲਡਰ ਬਣਾਇਆ। ਸਾਨੂੰ ਉਹਨਾਂ ਨੂੰ ਮੈਨੂਅਲੀ ਸੌਰਟ ਕਰਨਾ ਪਿਆ। ਡਾਕੂਮੈਂਟੇਸ਼ਨ ਦੀ ਬਣਤਰ ਵੀ ਗਲਤ ਸੀ।
ਪ੍ਰਯੋਗ 2: ਮੈਂ ਬਾਹਰੀ ਟਾਈਪਸ ਨੂੰ ਲੁਕਾਉਣ ਲਈ ਇੱਕ ਸੈਟਿੰਗ ਚਾਲੂ ਕੀਤੀ। ਇਹ ਕੁਝ ਚੀਜ਼ਾਂ ਲਈ ਕੰਮ ਕਰ ਗਈ। ਇਸਨੇ ਪੇਲੋਡ (payload) ਨੂੰ ਘਟਾ ਕੇ 60 Webpack ਟਾਈਪਸ ਤੱਕ ਕਰ ਦਿੱਤਾ। ਪਰ TypeDoc ਨੇ ਨੇਸਟਡ ਡਿਪੈਂਡੈਂਸੀਜ਼ (nested dependencies) ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰ ਦਿੱਤਾ। ਇਸਨੇ ਬਹੁਤ ਸਾਰੇ ਟਾਈਪਸ ਨੂੰ ਲੁਕਿਆ ਰੱਖਿਆ ਜਦੋਂ ਕਿ ਉਹ ਅਜੇ ਵੀ ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਸਨ।
ਪ੍ਰਯੋਗ 3: ਮੈਂ ਟਾਈਪਸ ਨੂੰ ਉਹਨਾਂ ਦੇ ਅਸਲ ਮੋਡਿਊਲਸ ਨਾਲ ਮੈਪ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ। ਇਸ ਨਾਲ ਇੱਕ ਰਿਕਰਸਿਵ ਲੂਪ (recursive loop) ਬਣ ਗਿਆ। ਪਲੱਗਇਨ ਨੇ ਨੇਸਟਡ ਇੰਟਰਫੇਸਾਂ (nested interfaces) ਨੂੰ ਉਦੋਂ ਤੱਕ ਕੱਢਣਾ ਜਾਰੀ ਰੱਖਿਆ ਜਦੋਂ ਤੱਕ ਇਸਨੇ 630 ਟਾਈਪਸ ਨਹੀਂ ਬਣਾ ਦਿੱਤੇ। ਡਾਕੂਮੈਂਟੇਸ਼ਨ ਫਾਲਤੂ ਜਾਣਕਾਰੀ (noise) ਨਾਲ ਭਰ ਗਈ ਸੀ। ਇਸਨੇ ਯੂਜ਼ਰ ਐਕਸਪੀਰੀਅੰਸ (user experience) ਖਰਾਬ ਕਰ ਦਿੱਤਾ।
ਹੱਲ: ਅਰਲੀ ਗਾਰਬੇਜ ਕਲੈਕਸ਼ਨ (Early Garbage Collection)
ਮੈਨੂੰ ਵਾਧੂ ਫਾਲਤੂ ਜਾਣਕਾਰੀ ਤੋਂ ਬਿਨਾਂ ਟਾਈਪਸ ਉਹਨਾਂ ਦੇ ਸਹੀ ਮੋਡਿਊਲਸ ਵਿੱਚ ਚਾਹੀਦੇ ਸਨ। ਮੈਂ ਆਊਟਪੁੱਟ ਨੂੰ ਠੀਕ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਦੀ ਬਜਾਏ ਪ੍ਰਕਿਰਿਆ (process) ਨੂੰ ਠੀਕ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਦਿੱਤਾ।
ਮੈਂ EVENT_RESOLVE_END ਨਾਮਕ ਇੱਕ ਹੁੱਕ (hook) ਦੀ ਵਰਤੋਂ ਕੀਤੀ। ਇਸ ਨਾਲ ਮੈਨੂੰ ਰੈਜ਼ੋਲੂਸ਼ਨ (resolution) ਤੋਂ ਤੁਰੰਤ ਬਾਅਦ AST ਨੂੰ ਇੰਟਰਸੈਪਟ (intercept) ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਮਿਲੀ। ਮੈਂ ਇਹ TypeDoc ਦੁਆਰਾ ਕੈਟੇਗਰੀਆਂ ਅਸਾਈਨ ਕਰਨ ਜਾਂ ਜ਼ਿਆਦਾ ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਕੀਤਾ।
ਮੇਰੇ ਲੌਜਿਕ (logic) ਵਿੱਚ ਤਿੰਨ ਕਦਮ ਸਨ:
- AST ਵਿੱਚ ਅੰਦਰੂਨੀ ਮੋਡਿਊਲ ਲੱਭੋ।
- ਇੱਕ ਕਸਟਮ ਯੂਟੀਲਿਟੀ (custom utility) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਹਰ ਨੋਡ ਦੀ ਜਾਂਚ ਕਰੋ।
- ਫਾਲਤੂ ਜਾਣਕਾਰੀ (noise) ਨੂੰ ਡਿਲੀਟ ਕਰੋ। ਮੈਂ 300 ਬੇਲੋੜੇ ਨੋਡਸ ਨੂੰ ਤੁਰੰਤ ਡਿਲੀਟ ਕਰਨ ਲਈ
project.removeReflectionਦੀ ਵਰਤੋਂ ਕੀਤੀ। ਇਸ ਨਾਲ Node.js ਨੂੰ ਮੈਮੋਰੀ ਖਾਲੀ ਕਰਨ ਵਿੱਚ ਮਦਦ ਮਿਲੀ। - ਮਹੱਤਵਪੂਰਨ ਟਾਈਪਸ ਨੂੰ ਮੂਵ ਕਰੋ। ਮੈਂ ਬਾਕੀ ਰਹਿੰਦੇ 300 ਟਾਈਪਸ ਨੂੰ ਰੂਟ ਸਕੋਪ (root scope) ਵਿੱਚ ਮਰਜ ਕਰ ਦਿੱਤਾ।
ਨਤੀਜਾ: ਮੈਂ 240 ਮਹੱਤਵਪੂਰਨ ਟਾਈਪਸ ਬਚਾ ਲਏ। ਉਹ ਹੁਣ ਦਿਖਾਈ ਦੇ ਰਹੇ ਹਨ ਅਤੇ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਰੂਟ ਕੀਤੇ ਗਏ ਹਨ। ਮੈਂ ਤੀਜੇ ਪ੍ਰਯੋਗ ਦੇ ਰਿਕਰਸਿਵ ਨੋਇਜ਼ (recursive noise) ਤੋਂ ਬਚਾਅ ਕੀਤਾ।
ਸਿੱਖੇ ਗਏ ਸਬਕ
• ASTs ਨੂੰ ਜਲਦੀ ਸੰਭਾਲੋ। ਬੇਲੋੜੇ ਨੋਡਸ ਨੂੰ ਹਟਾਉਣ ਨਾਲ ਬਾਅਦ ਵਿੱਚ ਮੈਮੋਰੀ ਦੀ ਬਰਬਾਦੀ ਰੁਕ ਜਾਂਦੀ ਹੈ। • ਹੈਕਸ (hacks) ਦੀ ਬਜਾਏ ਹੁੱਕਸ (hooks) ਦੀ ਵਰਤੋਂ ਕਰੋ। ਕੰਪਾਈਲਰ ਲਾਈਫਸਾਈਕਲ (compiler lifecycle) ਨੂੰ ਸਮਝਣ ਨਾਲ ਸਾਫ਼-ਸੁਥਰਾ ਕੰਮ ਕਰਨ ਵਿੱਚ ਮਦਦ ਮਿਲਦੀ ਹੈ। • ਫੀਡਬੈਕ ਆਰਕੀਟੈਕਚਰ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਂਦਾ ਹੈ। ਮੇਨਟੇਨਰ ਰਿਵਿਊਜ਼ (maintainer reviews) ਨੇ ਮੈਨੂੰ ਇੱਕ ਬਿਹਤਰ ਸਿਸਟਮ ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਕੀਤੀ। • ਜ਼ਿਆਦਾ ਡੇਟਾ ਦਾ ਮਤਲਬ ਬਿਹਤਰ ਨਹੀਂ ਹੁੰਦਾ। ਚੰਗੀ ਇੰਜੀਨੀਅਰਿੰਗ ਦਾ ਮਤਲਬ ਡੇਟਾ ਅਤੇ ਵਰਤੋਂਯੋਗਤਾ (usability) ਵਿਚਕਾਰ ਸੰਤੁਲਨ ਲੱਭਣਾ ਹੈ।