Node.js 26.5.0 ಈಗ ಲಭ್ಯವಿದೆ. ಇದು Current release ಆಗಿದೆಯೇ, LTS branch ಅಲ್ಲ, ಆದ್ದರಿಂದ ಇದು ಪ್ಲಾಟ್ಫಾರ್ಮ್ ಮಾಡಬಲ್ಲ ಅತ್ಯಾಧುನಿಕ ತಂತ್ರಜ್ಞಾನದ ಮುಂಚೂಣಿಯಲ್ಲಿದೆ. ಈ ವ್ಯತ್ಯಾಸವು ಮುಖ್ಯವಾಗಿದೆ. ಹದಿನೆಂಟು ತಿಂಗಳ ಸ್ಥಿರತೆಯನ್ನು ನಿರೀಕ್ಷಿಸುವ production fleet ಗೆ ಇದನ್ನು ಕುರುಡಾಗಿ ಬದಲಾಯಿಸಬಾರದು. ಆದರೆ ಇಂತಹ ಸಣ್ಣ, ವೇಗದ ಬಿಡುಗಡೆಗಳು ಭವಿಷ್ಯವು ಹೇಗೆ ರೂಪಗೊಳ್ಳುತ್ತಿದೆ ಎಂಬುದನ್ನು ನೋಡಲು ಸಹಕಾರಿಯಾಗಿವೆ. ನಿರ್ವಾಹಕರು (maintainers) ಯಾವ APIಗಳನ್ನು ಚುರುಕುಗೊಳಿಸುತ್ತಿದ್ದಾರೆ ಮತ್ತು runtime ಮುಂದಿನ ಹಂತಕ್ಕೆ ಎಲ್ಲಿ ಸಾಗುತ್ತಿದೆ ಎಂಬುದನ್ನು ಇವು ತೋರಿಸುತ್ತವೆ. 26.5.0 ರಲ್ಲಿ, ಪ್ರಮುಖ ಕೆಲಸವು Web Streams API ನಲ್ಲಿ ಕಂಡುಬರುತ್ತದೆ, ಇದು browser parity ಗೆ Node ಅನ್ನು ಹತ್ತಿರವಾಗಿಸುವ ಎರಡು ಗುರಿಬಂದ ತಿದ್ದುಪಡಿಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಈ ಬಿಡುಗಡೆಯು file system ಮತ್ತು URL handling layers ನಲ್ಲಿನ ಎರಡು ಸಮಸ್ಯೆಗಳನ್ನು ಸಹ ಸರಿಪಡಿಸುತ್ತದೆ.
Node.js ನಲ್ಲಿ Web Streams ಏನು ಮಾಡುತ್ತಿವೆ?
ನೀವು Node ನಲ್ಲಿ ದೀರ್ಘಕಾಲದಿಂದ streaming code ಬರೆಯುತ್ತಿದ್ದರೆ, ಅಂತರ್ಗತ stream module ತನ್ನದೇ ಆದ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಹೊಂದಿದೆ ಎಂಬುದು ನಿಮಗೆ ತಿಳಿದಿರಬಹುದು. Readable, Writable, Transform, ಮತ್ತು Duplex ವರ್ಷಗಳಿಂದ ಈ ecosystem ನ ಕೆಲಸಗಾರರಾಗಿವೆ. ಅವು ಶಕ್ತಿಯುತವಾಗಿವೆ, ಆದರೆ ಬ್ರೌಸರ್ನಲ್ಲಿ ನೀವು ಕಾಣುವ streams ನಂತೆಯಲ್ಲ. ನೀವು front-end service worker ಮತ್ತು back-end route handler ನಡುವೆ logic ಅನ್ನು ಹಂಚಿಕೊಳ್ಳಲು ಪ್ರಯತ್ನಿಸಿದಾಗ, ಆ ಅಂತರವು ಅಡಚಣೆಯಾಗುತ್ತದೆ. ನೀವು ಅಡಾಪ್ಟರ್ಗಳನ್ನು (adapters) ಮತ್ತೆ ಬರೆಯಬೇಕಾಗುತ್ತದೆ, ಡೇಟಾವನ್ನು ಪರಿಚಿತವಲ್ಲದ ರೂಪಗಳಿಗೆ ನಕಲಿಸಬೇಕಾಗುತ್ತದೆ ಅಥವಾ shared code ಅನ್ನು ಬಳಸುವುದನ್ನೇ ಬಿಡಬೇಕಾಗುತ್ತದೆ.
ಆ ಅಂತರವನ್ನು ಮುಚ್ಚಲು Web Streams API ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ. ಬ್ರೌಸರ್ನಲ್ಲಿ fetch body handling ಅನ್ನು ಚಲಾಯಿಸುವ ಅದೇ ಮಾನದಂಡ (standard) ಇದಾಗಿದೆ. ಇದನ್ನು Node ಗೆ ತರುವ ಮೂಲಕ, ಈ ಪ್ರಾಜೆಕ್ಟ್ ನಿಮಗೆ ಒಮ್ಮೆಲೇ streaming logic ಬರೆಯಲು ಮತ್ತು ಅದನ್ನು ಯಾವುದೇ ಪರಿಸರದಲ್ಲಿ (environment) ಬಳಸಲು ಅನುಮತಿಸುತ್ತದೆ. ಈ API ReadableStream, WritableStream, ಮತ್ತು TransformStream ಆಬ್ಜೆಕ್ಟ್ಗಳ ಮೂಲಕ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಇವು ಏಕರೂಪದ ಇಂಟರ್ಫೇಸ್ ಮೂಲಕ ಚಂಕ್ಗಳನ್ನು (chunks) ವರ್ಗಾಯಿಸುತ್ತವೆ. Version 26.5.0 ಆ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಮರುಬರೆಯುವುದಿಲ್ಲ, ಆದರೆ ಎರಡು ಪ್ರಮುಖ ಅಂಶಗಳನ್ನು ಗಟ್ಟಿಗೊಳಿಸುತ್ತದೆ.
releaseLock ಅನ್ನು ಸರಿಪಡಿಸುವುದು ಮತ್ತು BYOB Readers ಅನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸುವುದು
ಈ ಬಿಡುಗಡೆಯ ಒಂದು ನಿರ್ದಿಷ್ಟ ಬದಲಾವಣೆಯೆಂದರೆ WritableStreamDefaultWriter ಮೇಲಿನ releaseLock ಮೆಥಡ್ನ ತಿದ್ದುಪಡಿ. Web Streams ಮಾಡೆಲ್ನಲ್ಲಿ, writer lock ಎಂಬುದು ಏಕಕಾಲದಲ್ಲಿ ಅನೇಕ ಬಳಕೆದಾರರು (consumers) ಒಂದೇ stream ಅನ್ನು ಬಳಸದಂತೆ ತಡೆಯುತ್ತದೆ. ನೀವು releaseLock() ಅನ್ನು ಕರೆದಾಗ, ನಿಮ್ಮ writer ಕೆಲಸ ಮುಗಿಸಿದೆ ಮತ್ತು ಮೂಲ stream ಮುಂದಿನ ಕಾರ್ಯಾಚರಣೆಗಾಗಿ ಮುಕ್ತವಾಗಿದೆ ಎಂದು ನೀವು ಸೂಚಿಸುತ್ತೀರಿ. ಇಲ್ಲಿನ ದೋಷಪೂರಿತ ಅನುಷ್ಠಾನವು (implementation) stream ಅನ್ನು ಅನಿಶ್ಚಿತ ಸ್ಥಿತಿಯಲ್ಲಿ ಬಿಡಬಹುದು, ಅಂದರೆ writer ಇಲ್ಲದಿದ್ದರೂ ಅದು ಇನ್ನೂ ಮಾಲೀಕತ್ವದಲ್ಲಿದೆ ಎಂದು ಭಾವಿಸಬಹುದು. ಅಪ್ಲೋಡ್ಗಳನ್ನು ಪಾರ್ಸ್ ಮಾಡುವ ಅಥವಾ ಡೇಟಾವನ್ನು ಸ್ಟೋರೇಜ್ಗೆ ವರ್ಗಾಯಿಸುವ (piping) ಕಾರ್ಯನಿರತ ಸರ್ವರ್ನಲ್ಲಿ, ಅಂತಹ ಹಳೆಯ (stale) lock ಒಂದು ಪೈಪ್ಲೈನ್ ಅನ್ನು ನಿಲ್ಲಿಸಬಹುದು ಅಥವಾ ಮೂಲವನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಕಷ್ಟವಾಗುವ ದೋಷಗಳನ್ನು ಉಂಟುಮಾಡಬಹುದು. 26.5.0 ರ ತಿದ್ದುಪಡಿಯು ಈ ಹಸ್ತಾಂತರವನ್ನು (handoff) ಮತ್ತೆ ಮುನ್ಸೂಚನೆಗೆ ಒಳಪಡುವಂತೆ (predictable) ಮಾಡುತ್ತದೆ.
ಎರಡನೇ Web Streams ಬದಲಾವಣೆಯು ReadableStream ಮತ್ತು TransformStreamಗಳು BYOB readers ನೊಂದಿಗೆ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತವೆ ಎಂಬುದನ್ನು ಸುಧಾರಿಸುತ್ತದೆ. BYOB ಎಂದರೆ Bring Your Own Buffer ಎಂದರ್ಥ. ಪ್ರತಿ ಬಾರಿ ಡೇಟಾವನ್ನು ನೀಡುವಾಗ stream ಹೊಸ ಮೆಮೊರಿ ಚಂಕ್ ಅನ್ನು ಹಂಚಿಕೆ ಮಾಡುವ ಬದಲಿಗೆ, ನೀವು ಈಗಾಗಲೇ ಸಿದ್ಧಪಡಿಸಿಟ್ಟ ಬಫರ್ ಅನ್ನು ಅದಕ್ಕೆ ನೀಡುತ್ತೀರಿ. Stream ಆ ಬಫರ್ ಅನ್ನು ತುಂಬುತ್ತದೆ, ನೀವು ಬೈಟ್ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತೀರಿ ಮತ್ತು ನಂತರ ಅದೇ ಬಫರ್ ಅನ್ನು ಮರುಬಳಕೆಗಾಗಿ ಹಿಂತಿರುಗಿಸುತ್ತೀರಿ. ನೀವು ದೊಡ್ಡ ಪ್ರಮಾಣದ ಡೇಟಾವನ್ನು ವರ್ಗಾಯಿಸುವಾಗ ಇದು ಸಣ್ಣ ಯಾಂತ್ರಿಕ ವ್ಯತ್ಯಾಸವಾಗಿದ್ದರೂ, ದೊಡ್ಡ ಮಟ್ಟದ ಫಲಿತಾಂಶವನ್ನು ನೀಡುತ್ತದೆ.
Node ನಲ್ಲಿ ಸ್ವಲ್ಪ ಸಮಯದಿಂದ BYOB ಬೆಂಬಲವಿದೆ, ಆದರೆ BYOB reader ಅನ್ನು ಅಳವಡಿಸಿದಾಗ ReadableStream ಮತ್ತು TransformStream ನಲ್ಲಿನ ಕೆಲವು ಅಂಚಿನ ಸಂದರ್ಭಗಳು (edge cases) ತಪ್ಪಾಗಿ ವರ್ತಿಸಬಹುದು. ತಿದ್ದುಪಡಿಯ ವಿವರಗಳಿಗಿಂತ ಅದರ ಪ್ರಾಯೋಗಿಕ ಫಲಿತಾಂಶವೇ ಮುಖ್ಯವಾಗಿದೆ: ಈಗ ಸ್ಪಷ್ಟವಾದ ಬಫರ್ಗಳನ್ನು ಬಳಸುವ streams ಓದುವ ಮತ್ತು ಪರಿವರ್ತಿಸುವ (transformation) ಎರಡೂ ಹಂತಗಳಲ್ಲಿ ಹೆಚ್ಚು ವಿಶ್ವಾಸಾರ್ಹವಾಗಿವೆ. backpressure ಘಟನೆಗಳ ಸಮಯದಲ್ಲಿ ವಿಚಿತ್ರ ದೋಷಗಳಿಂದಾಗಿ ನೀವು BYOB readers ಅನ್ನು ತಪ್ಪಿಸುತ್ತಿದ್ದರೆ, ಈ ಬಿಡುಗಡೆಯು ಅದರಿಂದ ದೂರವಿರಲು ಮತ್ತೊಂದು ಕಾರಣವನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ.
BYOB ವಾಸ್ತವವಾಗಿ ಎಲ್ಲಿ ಕಂಡುಬರುತ್ತದೆ
ಬಫರ್ ಮರುಬಳಕೆಯ ಬಗ್ಗೆ ಸೈದ್ಧಾಂತಿಕವಾಗಿ ಮಾತನಾಡುವುದು ಸುಲಭ. ಆದರೆ ಅದು ಎಲ್ಲಿ ಮುಖ್ಯವಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಯೋಚಿಸುವುದು ಹೆಚ್ಚು ಉಪಯುಕ್ತ.
ನೀವು telemetry ಅಪ್ಲೋಡ್ಗಳನ್ನು ಸ್ವೀಕರಿಸುವ ಸೇವೆಯನ್ನು ಬರೆಯುತ್ತಿದ್ದೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಆ ಅಪ್ಲೋಡ್ಗಳು ಸಂಕುಚಿತಗೊಳಿಸಿದ (compressed) ಲಾಗ್ಗಳು ಅಥವಾ ಕಚ್ಚಾ ಸೆನ್ಸರ್ ಡಂಪ್ಗಳಾಗಿರಬಹುದು, ಪ್ರತಿಯೊಂದೂ ನೂರಾರು ಮೆಗಾಬೈಟ್ಗಳಿರಬಹುದು. ಪ್ರತಿ ಡೇಟಾ ಸ್ಲೈಸ್ಗಾಗಿ stream ಹೊಸ Node Buffer ಅನ್ನು ಹಂಚಿಕೆ ಮಾಡಿದರೆ, garbage collector ಅತಿಯಾಗಿ ಕೆಲಸ ಮಾಡಬೇಕಾಗುತ್ತದೆ ಮತ್ತು ಮೆಮೊರಿ ಏರಿಕೆ (memory spikes) ವೇಗವಾಗಿ ಹೆಚ್ಚಾಗುತ್ತದೆ. BYOB reader ನೊಂದಿಗೆ, ನೀವು ಪ್ರಾರಂಭದಲ್ಲಿಯೇ ಬಫರ್ಗಳ ಒಂದು ಸಣ್ಣ ಪೂಲ್ ಅನ್ನು ಹಂಚಿಕೆ ಮಾಡುತ್ತೀರಿ. Stream ಅವುಗಳನ್ನು ತುಂಬುತ್ತದೆ, ನಿಮ್ಮ ಪಾರ್ಸರ್ ಅವುಗಳನ್ನು ಬಳಸುತ್ತದೆ ಮತ್ತು ಅವು ಮತ್ತೆ ಮರುಬಳಕೆಗೆ ಬರುತ್ತವೆ. ಮೆಮೊರಿ ಸ್ಥಿರವಾಗಿರುತ್ತದೆ. ಎರಡು ಸಾಕೆಟ್ಗಳ (sockets) ನಡುವೆ ನೆಟ್ವರ್ಕ್ ಟ್ರಾಫಿಕ್ ಅನ್ನು ಪ್ರೊಕ್ಸಿ ಮಾಡುವಾಗ ಅಥವಾ ಇಡೀ ಫೈಲ್ ಅನ್ನು RAM ಗೆ ಲೋಡ್ ಮಾಡದೆ ದೊಡ್ಡ CSV ಫೈಲ್ಗಳನ್ನು ಸಾಲು ಸಾಲಾಗಿ ಪಾರ್ಸ್ ಮಾಡುವಾಗಲೂ ಇದೇ ಮಾದರಿಯು ಅನ್ವಯಿಸುತ್ತದೆ.
ಇಲ್ಲಿ ಟ್ರಾನ್ಸ್ಫಾರ್ಮ್ ಸ್ಟ್ರೀಮ್ಗಳು ಕೂಡ ಅಷ್ಟೇ ಮುಖ್ಯವಾಗಿವೆ. ಒಂದು TransformStream ಪೈಪ್ಲೈನ್ನ ಮಧ್ಯದಲ್ಲಿ ಇರುತ್ತದೆ, ಬಹುಶಃ gzip ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಡಿಕಂಪ್ರೆಸ್ ಮಾಡುವುದು ಅಥವಾ ಚಂಕ್ಗಳನ್ನು ಎನ್ಕ್ರಿಪ್ಟ್ ಮಾಡುವುದು ಇರಬಹುದು. ಒಂದು ವೇಳೆ ಟ್ರಾನ್ಸ್ಫಾರ್ಮ್ ಹಂತವು BYOB ಬಫರ್ಗಳನ್ನು ತಪ್ಪಾಗಿ ನಿರ್ವಹಿಸಿದರೆ, ನೀವು ದೋಷಪೂರಿತ ಔಟ್ಪುಟ್, ಡ್ರಾಪ್ ಆದ ಚಂಕ್ಗಳು ಅಥವಾ ಲೋಡ್ ಅಡಿಯಲ್ಲಿ ಸ್ಥಗಿತಗೊಳ್ಳುವಿಕೆಯನ್ನು (stalls) ನೋಡಬಹುದು. 26.5.0 ಸರಿಪಡಿಸುವಿಕೆಗಳು ನಿಖರವಾಗಿ ಅಂತಹ ಪೈಪ್ಲೈನ್ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುತ್ತವೆ, ಆದ್ದರಿಂದ ಹೆಚ್ಚಿನ ಥ್ರೂಪುಟ್ I/O ನಡೆಸುವವರು ಇದರ ಬಗ್ಗೆ ಗಮನ ಹರಿಸಬೇಕು.
ಮೌನ ಗೆಲುವುಗಳು: ಫೈಲ್ ಸಿಸ್ಟಮ್ ಮತ್ತು ದೋಷದ ಸ್ಪಷ್ಟತೆ
26.5.0 ರಲ್ಲಿ ಎಲ್ಲವೂ ಸ್ಟ್ರೀಮಿಂಗ್ ಬಗ್ಗೆ ಮಾತ್ರವಲ್ಲ. ಈ ಬಿಡುಗಡೆಯು recursive ಆಯ್ಕೆಯನ್ನು false ಎಂದು ಹೊಂದಿಸಿದಾಗ fs.rm ಮತ್ತು fs.rmSync ನಲ್ಲಿನ ವರ್ತನೆಯನ್ನು ಸಹ ಸರಿಪಡಿಸುತ್ತದೆ. ಈ ಹಿಂದೆ, ಡೈರೆಕ್ಟರಿ ಪಾತ್ ಜೊತೆಗೆ recursive: false ಅನ್ನು ಬಳಸಿದಾಗ ಕ್ಲೀನಪ್ ಸಮಯದಲ್ಲಿ ಅನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶಗಳು ಬರಬಹುದಿತ್ತು. ಈ ವಿಧಾನವು ಕರೆಯುವವರ (caller) ಸ್ಪಷ್ಟ ಉದ್ದೇಶಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗದ ರೀತಿಯಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸಬಹುದು, ಅಂದರೆ ನಿರೀಕ್ಷಿತಕ್ಕಿಂತ ಹೆಚ್ಚು ಡಿಲೀಟ್ ಮಾಡುವುದು ಅಥವಾ ಪ್ಲಾಟ್ಫಾರ್ಮ್ ಅವಲಂಬಿತವಾಗಿ ಅಸ್ಥಿರ ರೀತಿಯಲ್ಲಿ ವಿಫಲವಾಗುವುದು. ಫೈಲ್ಗಳನ್ನು ಕ್ಲೀನ್ ಮಾಡುವುದು ಎಂಬುದು ತುಂಬಾ ಸರಳ ಮತ್ತು ಮುನ್ಸೂಚಿಸಬಹುದಾದ (predictable) ಪ್ರಕ್ರಿಯೆಯಾಗಿರಬೇಕು. ಸರಳತೆಯೇ ಉತ್ತಮ. ಈ ಸರಿಪಡಿಸುವಿಕೆಯು ಆ ಮುನ್ಸೂಚನೆಯನ್ನು ಮರುಸ್ಥಾಪಿಸುತ್ತದೆ, ಇದರಿಂದಾಗಿ ನಿಮ್ಮ ತಾತ್ಕಾಲಿಕ ಡೈರೆಕ್ಟರಿ ಕ್ಲೀನಪ್ ಸ್ಕ್ರಿಪ್ಟ್ಗಳು ಅಥವಾ ಡಿಪ್ಲಾಯ್ಮೆಂಟ್ ಟಿಯರ್ಡೌನ್ ಲಾಜಿಕ್ ಕೋಡ್ ಸೂಚಿಸುವಂತೆಯೇ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ.
URL.canParse ವೈಫಲ್ಯವನ್ನು ವರದಿ ಮಾಡುವ ರೀತಿಯಲ್ಲಿ ಗುಣಮಟ್ಟದ ಸುಧಾರಣೆಯೂ ಇದೆ. ಈ ವಿಧಾನವು ತಪ್ಪಾದ ಇನ್ಪುಟ್ ಬಂದಾಗ ಎರರ್ (error) ಎಸೆಯದೆ, ಸ್ಟ್ರಿಂಗ್ ಒಂದು ಮಾನ್ಯವಾದ URL ಆಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. 26.5.0 ರಲ್ಲಿ, ಏನಾದರೂ ತಪ್ಪಾದಾಗ ಇದು ಈಗ ಉತ್ತಮವಾದ Error.cause ಮಾಹಿತಿಯನ್ನು ನೀಡುತ್ತದೆ. ಮೂಲ ಕಾರಣವನ್ನು ಮರೆಮಾಡುವ ಬದಲು, ಎರರ್ ಆಬ್ಜೆಕ್ಟ್ ಕಾರಣದ ಸರಪಳಿಯನ್ನು (causal chain) ಉಳಿಸಿಕೊಳ್ಳುತ್ತದೆ. ಅಂದರೆ, ವ್ಯಾಲಿಡೇಶನ್ ಹೆಲ್ಪರ್ನ ಒಳಗಡೆ URL ಪಾರ್ಸ್ ವಿಫಲವಾದಾಗ, ನೀವು ಲಾಗ್ ಮಾಡುವ ಸ್ಟ್ಯಾಕ್ (stack) ಸಮಸ್ಯೆಯು ಕೆಟ್ಟ ಪ್ರೋಟೋಕಾಲ್ ಆಗಿದೆಯೇ, ಮಿಸ್ಸಿಂಗ್ ಹೋಸ್ಟ್ನೇಮ್ ಆಗಿದೆಯೇ ಅಥವಾ ಬೇರೆ ಯಾವುದಾದರೂ ರಚನಾತ್ಮಕ ಸಮಸ್ಯೆಯೇ ಎಂದು ತಿಳಿಸುತ್ತದೆ. ಇದರಿಂದ ನೀವು ಪ್ರತಿಯೊಂದು ಕಡೆ ಮ್ಯಾನುಯಲ್ ಡೀಬಗ್ ಲಾಗ್ಗಳನ್ನು ಹಾಕಲು ಸಮಯ ವ್ಯಯಿಸಬೇಕಾಗಿಲ್ಲ.
ನೀವು ಅಪ್ಗ್ರೇಡ್ ಮಾಡಬೇಕೇ?
ಉತ್ತರವು ನೀವು ಏನನ್ನು ರನ್ ಮಾಡುತ್ತಿದ್ದೀರಿ ಎಂಬುದರ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ.
ನಿಮ್ಮ ಪ್ರೊಡಕ್ಷನ್ ವರ್ಕ್ಲೋಡ್ಗಳು v20.x ನಂತಹ LTS ವರ್ಷನ್ನಲ್ಲಿ ಇದ್ದರೆ, ಅಲ್ಲಿಯೇ ಇರಿ. ಈ ಸರಿಪಡಿಸುವಿಕೆಗಳು ಅಂತಿಮವಾಗಿ ಬ್ಯಾಕ್ಪೋರ್ಟ್ (backport) ಆಗುತ್ತವೆ ಅಥವಾ ಮುಂದಿನ ಸಕ್ರಿಯ LTS ನಲ್ಲಿ ಬರುತ್ತವೆ. ಈಗಾಗಲೇ ಕೆಲಸ ಮಾಡುತ್ತಿರುವ ಸರ್ವರ್ನಲ್ಲಿ ಸ್ವಲ್ಪ ಸುಗಮವಾದ ಸ್ಟ್ರೀಮ್ ಲಾಕ್ ಅಥವಾ ಸ್ಪಷ್ಟವಾದ URL ಎರರ್ನ ಪ್ರಯೋಜನಕ್ಕಿಂತ ಸ್ಥಿರತೆ ಮತ್ತು ಮುನ್ಸೂಚಿಸಬಹುದಾದ ಸಪೋರ್ಟ್ ಸಮಯಗಳು ಹೆಚ್ಚು ಮುಖ್ಯವಾಗಿವೆ.
ನೀವು ಹೊಸ ಸೇವೆಯನ್ನು ನಿರ್ಮಿಸುತ್ತಿದ್ದರೆ, ರಿಯಲ್-ಟೈಮ್ ಡೇಟಾ ಪೈಪ್ಲೈನ್ನ ಪ್ರೊಟೊಟೈಪ್ ಮಾಡುತ್ತಿದ್ದರೆ ಅಥವಾ ಪರ್ಫಾರ್ಮೆನ್ಸ್-ಕ್ರಿಟಿಕಲ್ I/O ಗಾಗಿ Web Streams API ಅನ್ನು ಸಕ್ರಿಯವಾಗಿ ಬಳಸುತ್ತಿದ್ದರೆ, 26.5.0 ಗೆ ಅಪ್ಗ್ರೇಡ್ ಮಾಡುವುದು ಉತ್ತಮ. Node ಸ್ಟ್ರೀಮ್ಗಳು ಮತ್ತು ಬ್ರೌಸರ್ Web Streams ನಡುವಿನ ಈ ಹಂತದ ಹೊಂದಾಣಿಕೆಯು ಕೇವಲ ಕಾಂಪ್ಯಾಟಿಬಿಲಿಟಿ ಗೆಲುವಲ್ಲ. ಇದು ಹೆಚ್ಚು ಏಕೀಕೃತವಾದ JavaScript runtime ಗಾಗಿ ಮಾಡುವ ಪಣವಾಗಿದೆ, ಅಲ್ಲಿ ಅದೇ ಡೇಟಾ-ಪುಶಿಂಗ್ ಲಾಜಿಕ್ ಅನ್ನು ಅನುವಾದಕ ಪದರಗಳಿಲ್ಲದೆ (translation layers) ಸರ್ವರ್ ಮತ್ತು ಕ್ಲೈಂಟ್ ನಡುವೆ ಬಳಸಬಹುದು. ಇದು ಕಾಾಗ್ನಿಟಿವ್ ಲೋಡ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ನಿಮ್ಮ ತಂಡವು ಎರಡೂ ಪರಿಸರಗಳಿಗೆ ಕೋಡ್ ಅನ್ನು ಕಳುಹಿಸುವಾಗ ಬಗ್ಗಳ ಸಾಧ್ಯತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
ಈ ಬಿಡುಗಡೆಯು ಚಿಕ್ಕದಾಗಿದ್ದರೂ, ಅದರ ದಿಕ್ಕು ಸ್ಪಷ್ಟವಾಗಿದೆ. JavaScript ಎಲ್ಲೆಡೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಸ್ಟ್ಯಾಂಡರ್ಡ್ಸ್ ಆಧಾರಿತ APIs ಗಳಲ್ಲಿ Node ಹೂಡಿಕೆ ಮಾಡುವುದನ್ನು ಮುಂದುವರಿಸುತ್ತಿದೆ. Web Streams ಸುಧಾರಣೆಗಳು ಪ್ರಮುಖ ಫೀಚರ್ಗಳಲ್ಲದಿದ್ದರೂ, ವರ್ಷಗಳಿಂದ ಕಠಿಣವಾಗಿದ್ದ ಹಾದಿಯನ್ನು ಸುಗಮಗೊಳಿಸುತ್ತವೆ. ನೀವು Current ಲೈನ್ನಲ್ಲಿ ಇದ್ದರೆ 26.5.0 ಅನ್ನು ಬಳಸಿ, ಮತ್ತು ಸರಿಯಾದ ಸಮಯ ಬಂದಾಗ ನಿಮ್ಮ LTS ಪ್ರಪಂಚಕ್ಕೆ ಈ ಸರಿಪಡಿಸುವಿಕೆಗಳು ಬರುವುದನ್ನು ಗಮನಿಸಿ.
ಮೂಲ: Dev.to – Node.js 26.5.0: What's New for Web Streams and Error Handling
ಚರ್ಚೆಯಲ್ಲಿ ಭಾಗವಹಿಸಿ ಮತ್ತು GyaanSetu community on Telegram ಮೂಲಕ ಕಲಿಯುವುದನ್ನು ಮುಂದುವರಿಸಿ.