ಕಳೆದುಹೋದ ಎಕ್ಸ್ಪೋರ್ಟ್ಗಳಿಗಿಂತ ಮಿಗಿಲಾಗಿ: ಅರ್ಲಿ ಗಾರ್ಬೇಜ್ ಕಲೆಕ್ಟರ್ ನಿರ್ಮಿಸುವುದು
Webpack ಡಾಕ್ಯುಮೆಂಟೇಶನ್ನಲ್ಲಿ ಕಳೆದುಹೋದ ಲಿಂಕ್ಗಳನ್ನು ಸರಿಪಡಿಸಲು ನಾನು ಒಂದು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಪ್ಲಗಿನ್ ಬಳಸಲು ಪ್ರಯತ್ನಿಸಿದೆ. ಅದು ವಿಫಲವಾಯಿತು.
ದೊಡ್ಡ ಕೋಡ್ಬೇಸ್ಗೆ ಪ್ಲಗಿನ್ ಅನ್ನು ಸಂಯೋಜಿಸುವುದು ಸುಲಭದ ಕೆಲಸವಲ್ಲ. ಇದು ಒಂದು ಆರ್ಕಿಟೆಕ್ಚರಲ್ ಸವಾಲಾಗಿ ಪರಿಣಮಿಸಿತು. ನಾನು Abstract Syntax Tree (AST) ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್, ಮೆಮೊರಿ ಬಳಕೆ ಮತ್ತು ರಿಸರ್ಸಿವ್ ಲೂಪ್ಗಳನ್ನು (recursive loops) ನಿರ್ವಹಿಸಬೇಕಾಯಿತು.
ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಪ್ಲಗಿನ್ಗಳೊಂದಿಗೆ ಇರುವ ಸಮಸ್ಯೆ
ಪರಿಹಾರವನ್ನು ಕಂಡುಕೊಳ್ಳಲು ನಾನು ಮೂರು ಪ್ರಯೋಗಗಳನ್ನು ಮಾಡಿದೆ.
ಪ್ರಯೋಗ 1: ಪ್ಲಗಿನ್ 135 ಟೈಪ್ಗಳನ್ನು (types) ಮರುಪಡೆಯಿತು. ಆದರೆ, ಅದು ಅವುಗಳನ್ನು ಒಂದು ಇಂಟರ್ನಲ್ ಮಾಡ್ಯೂಲ್ನಲ್ಲಿ ಇರಿಸಿತು. ನಮ್ಮ ಟೂಲ್ ಅವುಗಳಿಗಾಗಿ ಪ್ರತ್ಯೇಕ ಫೋಲ್ಡರ್ ಅನ್ನು ರಚಿಸಿತು. ನಾವು ಅವುಗಳನ್ನು ಮ್ಯಾನುಯಲ್ ಆಗಿ ವಿಂಗಡಿಸಬೇಕಾಯಿತು. ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಕೂಡ ರಚನಾತ್ಮಕವಾಗಿ ತಪ್ಪಾಗಿತ್ತು.
ಪ್ರಯೋಗ 2: ಎಕ್ಸ್ಟರ್ನಲ್ ಟೈಪ್ಗಳನ್ನು ಮರೆಮಾಚಲು ನಾನು ಒಂದು ಸೆಟ್ಟಿಂಗ್ ಅನ್ನು ಆನ್ ಮಾಡಿದೆ. ಇದು ಕೆಲವು ವಿಷಯಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡಿತು. ಇದು ಪೇಲೋಡ್ ಅನ್ನು 60 Webpack ಟೈಪ್ಗಳಿಗೆ ಇಳಿಸಿತು. ಆದರೆ TypeDoc ನೆಸ್ಟೆಡ್ ಡಿಪೆಂಡೆನ್ಸಿಗಳನ್ನು (nested dependencies) ನಿರ್ಲಕ್ಷಿಸಿತು. ಇದು ಅನೇಕ ಟೈಪ್ಗಳನ್ನು ಮರೆಮಾಚಿದರೂ, ಅವು ಮೆಮೊರಿಯನ್ನು ಬಳಸುತ್ತಲೇ ಇದ್ದವು.
ಪ್ರಯೋಗ 3: ಟೈಪ್ಗಳನ್ನು ಅವುಗಳ ಮೂಲ ಮಾಡ್ಯೂಲ್ಗಳಿಗೆ ಮ್ಯಾಪ್ ಮಾಡಲು ನಾನು ಪ್ರಯತ್ನಿಸಿದೆ. ಇದು ರಿಸರ್ಸಿವ್ ಲೂಪ್ಗೆ ಕಾರಣವಾಯಿತು. ಪ್ಲಗಿನ್ 630 ಟೈಪ್ಗಳನ್ನು ರಚಿಸುವವರೆಗೆ ನೆಸ್ಟೆಡ್ ಇಂಟರ್ಫೇಸ್ಗಳನ್ನು ಹೊರತೆಗೆಯುತ್ತಲೇ ಇತ್ತು. ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಅನಗತ್ಯ ಮಾಹಿತಿಯಿಂದ (noise) ತುಂಬಿತ್ತು. ಇದು ಬಳಕೆದಾರರ ಅನುಭವವನ್ನು (user experience) ಹಾಳುಮಾಡಿತು.
ಪರಿಹಾರ: ಅರ್ಲಿ ಗಾರ್ಬೇಜ್ ಕಲೆಕ್ಷನ್ (Early Garbage Collection)
ನನಗೆ ಅನಗತ್ಯ ಗೊಂದಲವಿಲ್ಲದೆ ಟೈಪ್ಗಳು ಅವುಗಳ ಸರಿಯಾದ ಮಾಡ್ಯೂಲ್ಗಳಲ್ಲಿ ಬೇಕಾಗಿದ್ದವು. ನಾನು ಔಟ್ಪುಟ್ ಅನ್ನು ಸರಿಪಡಿಸಲು ಪ್ರಯತ್ನಿಸುವುದನ್ನು ನಿಲ್ಲಿಸಿ, ಪ್ರಕ್ರಿಯೆಯನ್ನು (process) ಸರಿಪಡಿಸಲು ಪ್ರಾರಂಭಿಸಿದೆ.
ನಾನು EVENT_RESOLVE_END ಎಂಬ ಹೂಕ್ ಅನ್ನು ಬಳಸಿದೆ. ಇದು ರೆಸಲ್ಯೂಶನ್ ಆದ ತಕ್ಷಣವೇ AST ಅನ್ನು ಅಡ್ಡಿಪಡಿಸಲು (intercept) ನನಗೆ ಅನುಮತಿಸಿತು. TypeDoc ವರ್ಗಗಳನ್ನು (categories) ನಿಯೋಜಿಸುವ ಮೊದಲು ಅಥವಾ ಹೆಚ್ಚಿನ ಮೆಮೊರಿ ಬಳಸುವ ಮೊದಲು ನಾನು ಇದನ್ನು ಮಾಡಿದೆ.
ನನ್ನ ಲಾಜಿಕ್ ಮೂರು ಹಂತಗಳನ್ನು ಅನುಸರಿಸಿತು:
- AST ನಲ್ಲಿ ಇಂಟರ್ನಲ್ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಹುಡುಕುವುದು.
- ಕಸ್ಟಮ್ ಯುಟಿಲಿಟಿಯನ್ನು ಬಳಸಿ ಪ್ರತಿ ನೋಡ್ ಅನ್ನು ಪರಿಶೀಲಿಸುವುದು.
- ಅನಗತ್ಯ ಮಾಹಿತಿಯನ್ನು (noise) ಅಳಿಸುವುದು. 300 ಅನಗತ್ಯ ನೋಡ್ಗಳನ್ನು ತಕ್ಷಣವೇ ಅಳಿಸಲು ನಾನು
project.removeReflectionಅನ್ನು ಬಳಸಿದೆ. ಇದು Node.js ಮೆಮೊರಿಯನ್ನು ಬಿಡುಗಡೆ ಮಾಡಲು ಸಹಾಯ ಮಾಡಿತು. - ಪ್ರಮುಖ ಟೈಪ್ಗಳನ್ನು ವರ್ಗಾಯಿಸುವುದು. ಉಳಿದ 300 ಟೈಪ್ಗಳನ್ನು ನಾನು ರೂಟ್ ಸ್ಕೋಪ್ಗೆ (root scope) ವಿಲೀನಗೊಳಿಸಿದೆ.
ಫಲಿತಾಂಶ: ನಾನು 240 ಪ್ರಮುಖ ಟೈಪ್ಗಳನ್ನು ಉಳಿಸಿದೆ. ಅವು ಈಗ ಕಾಣಿಸುತ್ತಿವೆ ಮತ್ತು ಸರಿಯಾಗಿ ರೂಟ್ ಆಗಿವೆ. ನಾನು ಮೂರನೇ ಪ್ರಯೋಗದ ರಿಸರ್ಸಿವ್ ನಾಯ್ಸ್ ಅನ್ನು ತಪ್ಪಿಸಿದೆ.
ಕಲಿತ ಪಾಠಗಳು
• ASTಗಳನ್ನು ಮೊದಲೇ ನಿರ್ವಹಿಸಿ. ಅನಗತ್ಯ ನೋಡ್ಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದರಿಂದ ನಂತರ ಮೆಮೊರಿ ವ್ಯರ್ಥವಾಗುವುದನ್ನು ತಡೆಯಬಹುದು. • ಹ್ಯಾಕ್ಗಳ ಬದಲಿಗೆ ಹೂಕ್ಗಳನ್ನು ಬಳಸಿ. ಕಂಪೈಲರ್ ಲೈಫ್ಸೈಕಲ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಸ್ವಚ್ಛವಾದ ಕೆಲಸಕ್ಕೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. • ಫೀಡ್ಬ್ಯಾಕ್ ಆರ್ಕಿಟೆಕ್ಚರ್ ಅನ್ನು ಸುಧಾರಿಸುತ್ತದೆ. ಮೇಂಟೈನರ್ ರಿವ್ಯೂಗಳು ಉತ್ತಮ ವ್ಯವಸ್ಥೆಯನ್ನು ನಿರ್ಮಿಸಲು ನನಗೆ ಸಹಾಯ ಮಾಡಿದವು. • ಹೆಚ್ಚು ಡೇಟಾ ಎಂದರೆ ಉತ್ತಮ ಎಂದಲ್ಲ. ಉತ್ತಮ ಎಂಜಿನಿಯರಿಂಗ್ ಎಂದರೆ ಡೇಟಾ ಮತ್ತು ಬಳಕೆಯ ಸಾಮರ್ಥ್ಯದ (usability) ನಡುವೆ ಸಮತೋಲನವನ್ನು ಕಂಡುಕೊಳ್ಳುವುದು.