ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು

ವಿಷಯಗಳು:

• ಸಾರಾಂಶ
  • ಸಮಸ್ಯೆ
  • ನಿರ್ಧಾರ
  • ಸ್ಥಿತಿ
• ವಿವರಗಳು
  • ಊಹೆಗಳು
  • ನಿರ್ಬಂಧಗಳು
  • ನಿಲುವುಗಳು
  • ವಾದ
  • ಪರಿಣಾಮಗಳು
• ಸಂಬಂಧಿತ
  • ಸಂಬಂಧಿತ ನಿರ್ಧಾರಗಳು
  • ಸಂಬಂಧಿತ ಅವಶ್ಯಕತೆಗಳು
  • ಸಂಬಂಧಿತ ಆರ್ಟಿಫ್ಯಾಕ್ಟುಗಳು
  • ಸಂಬಂಧಿತ ತತ್ವಗಳು
• ಟಿಪ್ಪಣಿಗಳು

ಸಾರಾಂಶ

ಸಮಸ್ಯೆ

ನಮ್ಮ ತಂತ್ರಾಂಶಕ್ಕಾಗಿ ನಾವು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳನ್ನು ಆರಿಸಬೇಕು. ನಮಗೆ ಎರಡು ಪ್ರಮುಖ ಅಗತ್ಯಗಳಿವೆ: ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಸೂಕ್ತವಾದ ಫ್ರಂಟ್-ಎಂಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ, ಮತ್ತು ಸರ್ವರ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಸೂಕ್ತವಾದ ಬ್ಯಾಕ್-ಎಂಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ.

ನಿರ್ಧಾರ

ಫ್ರಂಟ್-ಎಂಡ್‌ಗೆ ನಾವು TypeScript ಆರಿಸುತ್ತಿದ್ದೇವೆ.

ಬ್ಯಾಕ್-ಎಂಡ್‌ಗೆ ನಾವು Rust ಆರಿಸುತ್ತಿದ್ದೇವೆ.

ಸ್ಥಿತಿ

ನಿರ್ಧರಿಸಲಾಗಿದೆ. ಹೊಸ ಪರ್ಯಾಯಗಳು ಬಂದಂತೆ ಅವಕ್ಕೆ ನಾವು ಮುಕ್ತರಾಗಿದ್ದೇವೆ.

ವಿವರಗಳು

ಊಹೆಗಳು

ಫ್ರಂಟ್-ಎಂಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ವಿಶಿಷ್ಟವಾದವು:

• ವಿಶಿಷ್ಟ ಬಳಕೆದಾರರು ಮತ್ತು ಸಂವಹನಗಳು

• ವಿಶಿಷ್ಟ ಬ್ರೌಸರ್‌ಗಳು ಮತ್ತು ವ್ಯವಸ್ಥೆಗಳು

• ವಿಶಿಷ್ಟ ಅಭಿವೃದ್ಧಿಗಳು ಮತ್ತು ನಿಯೋಜನೆಗಳು

ಫ್ರಂಟ್-ಎಂಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ವೇಗವಾಗಿ ವಿಕಸನಗೊಳ್ಳುವ ಸಾಧ್ಯತೆಯಿದೆ:

• ವೇಗದ ಸುಲಭ ಅಭಿವೃದ್ಧಿಗಳು, ನಿಯೋಜನೆಗಳು, ಪುನರಾವರ್ತನೆಗಳು ಇತ್ಯಾದಿಗಳನ್ನು ಖಚಿತಪಡಿಸಲು ನಾವು ಬಯಸುತ್ತೇವೆ.

• ಟೈಪ್ ಸುರಕ್ಷತೆಯಂತಹ ಸಾಬೀತುಪಡಿಸುವಿಕೆಯನ್ನು ನಾವು ಮೌಲ್ಯೀಕರಿಸುತ್ತೇವೆ, ಮತ್ತು ಅದನ್ನು ಸಾಧಿಸಲು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಕೆಲಸ ಮಾಡಲು ನಮಗೆ ಅಭ್ಯಂತರವಿಲ್ಲ.

• ನಮಗೆ ಪರಂಪರೆ ಹೊಂದಾಣಿಕೆಯ ಅಗತ್ಯವಿಲ್ಲ.

ಬ್ಯಾಕ್-ಎಂಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ವಿಶಿಷ್ಟಕ್ಕಿಂತ ಹೆಚ್ಚಿನವು:

• ವಿಶೇಷವಾಗಿ ಸಾಬೀತುಪಡಿಸುವಿಕೆ, ವಿಶ್ವಾಸಾರ್ಹತೆ, ಭದ್ರತೆ ಇತ್ಯಾದಿ ಗುಣಮಟ್ಟಕ್ಕೆ ವಿಶಿಷ್ಟಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಗುರಿಗಳು.

• ನೈಜ-ಸಮಯದ ಸಮೀಪಕ್ಕೆ ವಿಶಿಷ್ಟಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಗುರಿಗಳು, ಅಂದರೆ ವರ್ಚುವಲ್ ಮಷಿನ್ ಗಾರ್ಬೇಜ್ ಕಲೆಕ್ಷನ್‌ನಿಂದಾಗಿ ವಿರಾಮಗಳನ್ನು ನಾವು ಬಯಸುವುದಿಲ್ಲ.

• ವಿಶೇಷವಾಗಿ ಸಮಾನಾಂತರೀಕರಣ, ಬಹು-ಕೋರ್ ಸಂಸ್ಕರಣೆ ಮತ್ತು ಮೆಮೊರಿ ಸುರಕ್ಷತೆಗೆ, ಫಂಕ್ಷನಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ಗೆ ವಿಶಿಷ್ಟಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಗುರಿಗಳು.

ಕಂಪೈಲ್-ಸಮಯದ ಸುರಕ್ಷತೆ ಮತ್ತು ರನ್‌ಟೈಮ್ ವೇಗಗಳ ಪರವಾಗಿ ಕಡಿಮೆ ಕಂಪೈಲ್-ಸಮಯದ ವೇಗಗಳನ್ನು ನಾವು ಒಪ್ಪಿಕೊಳ್ಳುತ್ತೇವೆ.

ನಿರ್ಬಂಧಗಳು

Amazon Lambda ನಂತಹ ಫಂಕ್ಷನ್‌ಗಳಿಗಾಗಿ ಪ್ರಮುಖ ಕ್ಲೌಡ್ ಪೂರೈಕೆದಾರ ಸೇವೆಗಳೊಂದಿಗೆ ಬಳಸಬಹುದಾದ ಭಾಷೆಗಳ ಮೇಲೆ ನಮಗೆ ಬಲವಾದ ನಿರ್ಬಂಧವಿದೆ.

ನಿಲುವುಗಳು

ನಾವು ಈ ಭಾಷೆಗಳನ್ನು ಪರಿಗಣಿಸಿದೆವು:

• C

• C++

• Clojure

• Elixir

• Erlang

• Elm

• Flow

• Go

• Haskell

• Java

• JavaScript

• Kotlin

• Python

• Ruby

• Rust

• TypeScript

ವಾದ

ಪ್ರತಿ ಭಾಷೆಯ ಸಾರಾಂಶ:

• C: ಕಡಿಮೆ ಸುರಕ್ಷತೆಯ ಕಾರಣ ತಿರಸ್ಕೃತ; Rust ಬಹುತೇಕ ಎಲ್ಲವನ್ನೂ ಉತ್ತಮವಾಗಿ ಮಾಡಬಲ್ಲದು.

• C++: ಅದೊಂದು ಗೊಂದಲದ ಗೂಡು ಆಗಿರುವುದರಿಂದ ತಿರಸ್ಕೃತ; Rust ಬಹುತೇಕ ಎಲ್ಲವನ್ನೂ ಉತ್ತಮವಾಗಿ ಮಾಡಬಲ್ಲದು.

• Clojure: ಅತ್ಯುತ್ತಮ ಮಾದರಿ ರಚನೆ; ಅತ್ಯುತ್ತಮ Lisp ಅಂದಾಜು; JVM ಮೇಲೆ ಉತ್ತಮ ರನ್‌ಟೈಮ್.

• Elixir: ನಿಯೋಜನಾ ಸಾಮರ್ಥ್ಯ ಮತ್ತು ಏಕಕಾಲಿಕತೆ ಸೇರಿದಂತೆ ಅತ್ಯುತ್ತಮ ರನ್‌ಟೈಮ್; ಅತ್ಯುತ್ತಮ ಡೆವಲಪರ್ ಅನುಭವ; ತುಲನಾತ್ಮಕವಾಗಿ ಚಿಕ್ಕ ಪರಿಸರ ವ್ಯವಸ್ಥೆ.

• Erlang: ನಿಯೋಜನಾ ಸಾಮರ್ಥ್ಯ ಮತ್ತು ಏಕಕಾಲಿಕತೆ ಸೇರಿದಂತೆ ಅತ್ಯುತ್ತಮ ರನ್‌ಟೈಮ್; ಸವಾಲಿನ ಡೆವಲಪರ್ ಅನುಭವ; ತುಲನಾತ್ಮಕವಾಗಿ ಚಿಕ್ಕ ಪರಿಸರ ವ್ಯವಸ್ಥೆ.

• Elm: ಬಹಳ ಭರವಸೆಯಂತೆ ಕಾಣುತ್ತದೆ; IBM ಉತ್ತಮ ಫಲಿತಾಂಶಗಳೊಂದಿಗೆ ಪ್ರಮುಖ ಪ್ರಕರಣ ಅಧ್ಯಯನಗಳನ್ನು ಪ್ರಕಟಿಸುತ್ತಿದೆ; ಚಿಕ್ಕ ಪರಿಸರ ವ್ಯವಸ್ಥೆ.

• Flow: JavaScript ಗಿಂತ ಆಸಕ್ತಿದಾಯಕ ಸುಧಾರಣೆ; ಆದಾಗ್ಯೂ, ಡೆವಲಪರ್‌ಗಳು ಅದರಿಂದ ದೂರ ಸರಿಯುತ್ತಿದ್ದಾರೆ.

• Go: ಅತ್ಯುತ್ತಮ ಡೆವಲಪರ್ ಅನುಭವ; ಅತ್ಯುತ್ತಮ ಏಕಕಾಲಿಕತೆ; ಆದರೆ ಭಾಷೆಯನ್ನು ಕುಂಠಿತಗೊಳಿಸುವ ಕೆಟ್ಟ ನಿರ್ಧಾರಗಳ ಇತಿಹಾಸ.

• Haskell: ಅತ್ಯುತ್ತಮ ಫಂಕ್ಷನಲ್ ಭಾಷೆ; ಚಿಕ್ಕ ಡೆವಲಪರ್ ಸಮುದಾಯ; ಸಾಕಷ್ಟು ಪ್ರಕಟಿತ ಉತ್ಪಾದನಾ ಯಶಸ್ಸುಗಳನ್ನು ಸಾಧಿಸಿಲ್ಲ.

• Java: ಅತ್ಯುತ್ತಮ ರನ್‌ಟೈಮ್; ಅತ್ಯುತ್ತಮ ಪರಿಸರ ವ್ಯವಸ್ಥೆ; ಸಾಧಾರಣಕ್ಕಿಂತ ಕಡಿಮೆ ಡೆವಲಪರ್ ಅನುಭವ.

• JavaScript: ಇದುವರೆಗಿನ ಅತ್ಯಂತ ಜನಪ್ರಿಯ ಭಾಷೆ; ಅತ್ಯಂತ ವ್ಯಾಪಕ ಪರಿಸರ ವ್ಯವಸ್ಥೆ.

• Kotlin: Java ದ ಬಹಳಷ್ಟನ್ನು ಸರಿಪಡಿಸುತ್ತದೆ; JetBrains ನ ಅತ್ಯುತ್ತಮ ಬೆಂಬಲ; Java ದಿಂದ Kotlin ಗೆ ಪೋರ್ಟ್ ಮಾಡಿದ ಉತ್ತಮ ಪ್ರಕಟಿತ ಪ್ರಕರಣಗಳು.

• Python: ವ್ಯವಸ್ಥೆ ನಿರ್ವಹಣೆಗೆ ಅತ್ಯಂತ ಜನಪ್ರಿಯ ಭಾಷೆ; ಉತ್ತಮ ವಿಶ್ಲೇಷಣಾ ಸಾಧನಗಳು; ಉತ್ತಮ ವೆಬ್ ಚೌಕಟ್ಟುಗಳು; ಆದರೆ Google Go ಪರವಾಗಿ ಅದನ್ನು ಕೈಬಿಟ್ಟಿದೆ.

• Ruby: ಇದುವರೆಗಿನ ಅತ್ಯುತ್ತಮ ಡೆವಲಪರ್ ಅನುಭವ; ಅತ್ಯುತ್ತಮ ವೆಬ್ ಚೌಕಟ್ಟುಗಳು; ಅತ್ಯಂತ ಒಳ್ಳೆಯ ಸಮುದಾಯ; ಆದರೆ ಬಹಳ ನಿಧಾನ; ಪ್ಯಾಕೇಜ್ ಮಾಡಲು ಸ್ವಲ್ಪ ಕಷ್ಟ.

• Rust: ಅತ್ಯುತ್ತಮ ಹೊಸ ಭಾಷೆ; ಶೂನ್ಯ-ಅಮೂರ್ತತೆಗೆ ಒತ್ತು; ಏಕಕಾಲಿಕತೆಗೆ ಒತ್ತು; ಆದಾಗ್ಯೂ ತುಲನಾತ್ಮಕವಾಗಿ ಚಿಕ್ಕ ಪರಿಸರ ವ್ಯವಸ್ಥೆ; ಮತ್ತು ನೇರ ಮೆಮೊರಿ ಪ್ರವೇಶವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಅಸುರಕ್ಷಿತ ಎಂದು ಗುರುತಿಸಬೇಕಾದಂತೆ, ಕೆಲವು ರೀತಿಯ ಕಂಪೈಲರ್ ವೇಗವರ್ಧನೆಗಳ ಮೇಲೆ ಉದ್ದೇಶಪೂರ್ವಕ ಮಿತಿಗಳನ್ನು ಹೊಂದಿದೆ.

• TypeScript: JavaScript ಗೆ ಟೈಪ್‌ಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ; ಅತ್ಯುತ್ತಮ ಟ್ರಾನ್ಸ್‌ಪೈಲರ್; JavaScript ನಿಂದ TypeScript ಗೆ ಪೋರ್ಟ್ ಮಾಡುವ ಬಗ್ಗೆ ಬೆಳೆಯುತ್ತಿರುವ ಡೆವಲಪರ್ ಒತ್ತು; Microsoft ನ ಬಲವಾದ ಬೆಂಬಲ.

VM ಗಳು ನಮಗೆ ಈಗ ಅಗತ್ಯವಿಲ್ಲದ ಸಾಧಕ-ಬಾಧಕ ಹೊಂದಾಣಿಕೆಗಳ ಸಮೂಹವನ್ನು ಹೊಂದಿವೆ, ಉದಾಹರಣೆಗೆ ರನ್‌ಟೈಮ್ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಒದಗಿಸುವ ಹೆಚ್ಚುವರಿ ಸಂಕೀರ್ಣತೆ ಎಂದು ನಾವು ನಿರ್ಧರಿಸಿದೆವು.

ನಮ್ಮ ಮೂಲ ನಿರ್ಧಾರವು ಎರಡು ಅಡ್ಡ-ಕತ್ತರಿಸುವ ಕಾಳಜಿಗಳಿಂದ ಚಾಲಿತವಾಗಿದೆ ಎಂದು ನಾವು ನಂಬುತ್ತೇವೆ:

• ಅತ್ಯಂತ ವೇಗದ ರನ್‌ಟೈಮ್ ವೇಗ ಮತ್ತು ಅತ್ಯಂತ ಬಿಗಿಯಾದ ವ್ಯವಸ್ಥೆ ಪ್ರವೇಶಕ್ಕೆ, ನಾವು JavaScript ಮತ್ತು C ಅನ್ನು ಆರಿಸುತ್ತೇವೆ.

• ಅತ್ಯಂತ ವೇಗದ ಸಮೀಪದ ರನ್‌ಟೈಮ್ ವೇಗ ಮತ್ತು ಅತ್ಯಂತ ಬಿಗಿಯಾದ ಸಮೀಪದ ವ್ಯವಸ್ಥೆ ಪ್ರವೇಶಕ್ಕೆ, ನಾವು TypeScript ಮತ್ತು Rust ಅನ್ನು ಆರಿಸುತ್ತೇವೆ.

ನಾವು VM ಭಾಷೆಯನ್ನು ಬಯಸಿದರೆ ಆರಿಸುವ VM ಭಾಷೆಗಳು ಮತ್ತು ವೆಬ್ ಚೌಕಟ್ಟುಗಳಿಗೆ ಗೌರವಯುತ ಉಲ್ಲೇಖಗಳು:

• Clojure ಮತ್ತು Luminus

• Java ಮತ್ತು Spring

• Elixir ಮತ್ತು Phoenix

ಪರಿಣಾಮಗಳು

ಫ್ರಂಟ್-ಎಂಡ್ ಡೆವಲಪರ್‌ಗಳು TypeScript ಕಲಿಯಬೇಕಾಗುತ್ತದೆ. ಡೆವಲಪರ್‌ನ ಪ್ರಾಥಮಿಕ ಅನುಭವ JavaScript ಬಳಸುವುದಾಗಿದ್ದರೆ ಇದು ಬಹುಶಃ ಸುಲಭ ಕಲಿಕೆಯ ರೇಖೆ.

ಬ್ಯಾಕ್-ಎಂಡ್ ಡೆವಲಪರ್‌ಗಳು Rust ಕಲಿಯಬೇಕಾಗುತ್ತದೆ. ಡೆವಲಪರ್‌ನ ಪ್ರಾಥಮಿಕ ಅನುಭವ C/C++ ಬಳಸುವುದಾಗಿದ್ದರೆ ಇದು ಬಹುಶಃ ಮಧ್ಯಮ ಕಲಿಕೆಯ ರೇಖೆ, ಮತ್ತು ಪ್ರಾಥಮಿಕ ಅನುಭವ Java, Python, Ruby ಅಥವಾ ಅಂತಹುದೇ ಮೆಮೊರಿ-ನಿರ್ವಹಿತ ಭಾಷೆಗಳನ್ನು ಬಳಸುವುದಾಗಿದ್ದರೆ ಕಠಿಣ ಕಲಿಕೆಯ ರೇಖೆ.

TypeScript ಮತ್ತು Rust ಎರಡೂ ತುಲನಾತ್ಮಕವಾಗಿ ಹೊಸವು. ಇದರರ್ಥ ಅನೇಕ ಸಾಧನಗಳಿಗೆ ಈ ಭಾಷೆಗಳಿಗೆ ಇನ್ನೂ ದಾಖಲಾತಿ ಇಲ್ಲ. ಉದಾಹರಣೆಗೆ, ಈ ಭಾಷೆಗಳಿಗಾಗಿ devops ಪೈಪ್‌ಲೈನ್ ಅನ್ನು ಹೊಂದಿಸಬೇಕಾಗುತ್ತದೆ, ಮತ್ತು ಇದುವರೆಗೆ ನಾವು ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತಿರುವ devops ಸಾಧನಗಳಲ್ಲಿ ಯಾವುದೂ ಈ ಭಾಷೆಗಳಿಗೆ ಡೀಫಾಲ್ಟ್ ಉದಾಹರಣೆಗಳನ್ನು ಹೊಂದಿಲ್ಲ.

TypeScript ಮತ್ತು Rust ಗಳ ಕಂಪೈಲ್ ಸಮಯಗಳು ಬಹಳ ನಿಧಾನ. ಇದರಲ್ಲಿ ಕೆಲವು ಭಾಷೆಗಳ ಹೊಸತನದಿಂದಾಗಿರಬಹುದು. ಬೇಡಿಕೆಯ ಮೇರೆಗೆ ಕಂಪೈಲ್, ಕಂಪೈಲ್-ಏಕಕಾಲಿಕತೆ ಇತ್ಯಾದಿಗಳಂತೆ, ನಿಧಾನ ಕಂಪೈಲ್ ಸಮಯಗಳನ್ನು ಹೇಗೆ ತಗ್ಗಿಸಬೇಕು ಎಂಬುದನ್ನು ನಾವು ನೋಡಲು ಬಯಸಬಹುದು.

ಈ ಭಾಷೆಗಳಿಗೆ IDE ಬೆಂಬಲ ಇನ್ನೂ ಸರ್ವವ್ಯಾಪಿಯಾಗಿಲ್ಲ ಮತ್ತು ಇನ್ನೂ ಪ್ರಥಮ ದರ್ಜೆಯಲ್ಲ. ಉದಾಹರಣೆಗೆ, JetBrains Python ಗೆ ಪ್ರಥಮ ದರ್ಜೆ ಬೆಂಬಲಕ್ಕಾಗಿ PyCharm IDE ಅನ್ನು ಮಾರಾಟ ಮಾಡುತ್ತದೆ, ಆದರೆ Rust ಗೆ ಪ್ರಥಮ ದರ್ಜೆ ಬೆಂಬಲವಿರುವ IDE ಅನ್ನು ಮಾರಾಟ ಮಾಡುವುದಿಲ್ಲ; ಬದಲಿಗೆ, JetBrains Python ಭಾಷೆ ಬೆಂಬಲಕ್ಕೆ ಹೋಲಿಸಿದರೆ ಬಹುಶಃ 80% Rust ಭಾಷೆ ಬೆಂಬಲವನ್ನು ಒದಗಿಸುವ Rust ಪ್ಲಗ್-ಇನ್ ಅನ್ನು ಬಳಸಬಹುದು.

ಸಂಬಂಧಿತ

ಸಂಬಂಧಿತ ನಿರ್ಧಾರಗಳು

ಈ ಭಾಷೆಗಳೊಂದಿಗೆ ಹೊಂದುವ ಪರಿಸರ ವ್ಯವಸ್ಥೆ ಆಯ್ಕೆಗಳತ್ತ ನಾವು ಗುರಿ ಇಡುತ್ತೇವೆ.

ಉದಾಹರಣೆಗೆ, ಈ ಭಾಷೆಗಳಿಗೆ ಉತ್ತಮ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಹೊಂದಿರುವ IDE ಅನ್ನು ನಾವು ಆರಿಸಲು ಬಯಸುತ್ತೇವೆ.

ಉದಾಹರಣೆಗೆ, ನಮ್ಮ ಫ್ರಂಟ್-ಎಂಡ್ ವೆಬ್ ಚೌಕಟ್ಟಿಗಾಗಿ, ಸರಳ JavaScript ಗೆ ಗುರಿ ಇಡುವ ಚೌಕಟ್ಟಿಗಿಂತ (ಉದಾ. React) TypeScript ಗೆ ಗುರಿ ಇಡುವ ಚೌಕಟ್ಟನ್ನು (ಉದಾ. Vue) ನಾವು ನಿರ್ಧರಿಸುವ ಸಾಧ್ಯತೆ ಹೆಚ್ಚು.

ಸಂಬಂಧಿತ ಅವಶ್ಯಕತೆಗಳು

ನಮ್ಮ ಸಂಪೂರ್ಣ ಟೂಲ್‌ಚೈನ್ ಈ ಭಾಷೆಗಳನ್ನು ಬೆಂಬಲಿಸಬೇಕು.

ಸಂಬಂಧಿತ ಆರ್ಟಿಫ್ಯಾಕ್ಟುಗಳು

ಕೆಲವು ರಹಸ್ಯಗಳನ್ನು ಪರಿಸರ ಚರಗಳಿಗೆ ರಫ್ತು ಮಾಡಬಹುದು ಎಂದು ನಾವು ನಿರೀಕ್ಷಿಸುತ್ತೇವೆ.

ಸಂಬಂಧಿತ ತತ್ವಗಳು

ಎರಡು ಬಾರಿ ಅಳೆಯಿರಿ, ಒಮ್ಮೆ ನಿರ್ಮಿಸಿ. ಕೆಲವು ವೇಗಕ್ಕಿಂತ ಕೆಲವು ಸುರಕ್ಷತೆಗೆ ನಾವು ಆದ್ಯತೆ ನೀಡುತ್ತಿದ್ದೇವೆ.

ಕಂಪೈಲ್ ಸಮಯಕ್ಕಿಂತ ರನ್‌ಟೈಮ್ ಹೆಚ್ಚು ಮೌಲ್ಯಯುತ. ಡೆವಲಪರ್ ಬಳಕೆಗಿಂತ ಗ್ರಾಹಕರ ಬಳಕೆಗೆ ನಾವು ಆದ್ಯತೆ ನೀಡುತ್ತಿದ್ದೇವೆ.

ಟಿಪ್ಪಣಿಗಳು

ಯಾವುದೇ ಟಿಪ್ಪಣಿಗಳು ಇಲ್ಲಿ.