แแแแฅแกแแแแ แ แฉแแกแขแแแแแแ แแแแจแแ แจแแ, แแ แแแ แแแฎแแ แแแแแ แแ แแแแแงแแแแแ 9 แฌแแแก 2019 แกแแฃแแแแแกแ แขแแฅแแแแแแแฃแ แ แแแแแแแแก แจแแกแแฎแแ.
แฉแแแ แจแแคแแกแแแแ, แแ แฃแคแ แ แฉแแแก แแแแแแแแแแก แแแงแ แแแแแแแ, แแแแ แ แแฅแกแแแ แขแแแแก แแแ แก. แแแแขแแ, แแ แกแแแจแ, แแแแแแแแแ, แแ แจแแแแก แฃแแแ แแแแ แแแแฅแแแแแ, แ แแแแแ แแ แขแแฅแแแแแแแแจแ แคแฃแแแแแแแขแฃแ แแ แแฎแแแ แแ แแแกแแแแแ แ แแ แแคแแ แแ.
แกแแแจแ แแแแแแแแแก แแ แแแแแฎแแ แแกแฎแแแแ แแแแจแแแแแแแแก แแ แแแแก แแคแแฅแขแแก แแแฎแแแแแ, แ แแแแแ แแแแ แแแแจแแแแแแแ แแ แฌแแแแฌแแแจแ แแแแ แแแแแ, แแแแก แแคแแฅแขแ แแ แซแแแแแ แฎแแแแแแแแ, แฃแแ แแแแ แจแแแแชแแแ แแก แแแแแแ แแแแแแแแแแ แฃแแ แงแแคแแแแงแ.
1. แแแ แขแแขแฃแแ แกแแ แแแ แแก แแแแแแแชแแแแ Rust แแ แแแ แแแแ แแแแก แแแแแ WebAssembly-แกแแแแก
แแแแฎแแแแแก แแแแแฌแงแแ แแ แ แแแฎแกแแแแแแ:
1. แแแฎแกแแแแแ , แฌแแแแแแฎแ แแแก แแแแ แฏแแ แแแแแ 2018 แฌแแแก.
แแแฎแกแแแแแแก แฌแแแแแฎแแแก แแ แแก, แแ แแแแ แแแแขแ แแแ แแฃแจแแแแแ Joyent-แจแ, แ แแแแ แช CTO แแ แฌแแ แแแแแแแ แแ แฐแฅแแแแ, แ แแแแ แแแกแ แฃแแแแแแแ 2019 แฌแแแ แแแกแแแแก แแ แฏแแแแแขแแกแแแแก.
2. , Rust แแแแก แซแแ แแแแแ แแฃแแแแก แฌแแแ แ แแ แฌแแแแแก "The Rust Programming Language" แแแขแแ แ, แ แแแแแแช แแฃแจแแแแก Cloudflare-แจแ, แกแแแแช แกแแฃแแ แแแก Rust แแแแกแ แแ WebAssembly แขแแฅแแแแแแแแก แแแฎแแกแแแแแแแแแแ, แ แแช แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแงแแแแ แแแ แแ แแฃแแแ แแแ, แ แแแแ แช แแแแขแคแแ แแแแ แแแแแแแชแแแแแก แแแกแแจแแแแแ.
2019 แฌแแแก WebAssembly แแแแแกแแแ แแ แแแ , แ แแแแแแช แฃแแ แฃแแแแแงแแคแก แฌแแแแแแก แแแแ แแชแแฃแแ แกแแกแขแแแแก แแแแแฅแขแแแแ, แ แแแแ แแชแแ แคแแแแแแ แแ แกแแแแขแแแ, แแแแแแแแ แแ แแฃแแแ แแแแก แคแแ แแแแแก แแแ แแ แแ แแแแแแ แแกแแฎแแแก แกแแ แแแ แแก แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแแแ แก.
แแแ แฆแแแแแก แแ แกแ แแจแแแ แแ - แแแชแแแ แแแแแก แแฅแแก แแแแแ แแ แแ แแแจแแแแแก แแ แ, แ แแแแแกแแช แจแแฃแซแแแ แแแ แขแแขแฃแแ แแแแแแแชแแแแแก แแแขแแ แแแขแจแ แแแจแแแแ (แแฎแกแแแก แแแแแแก WORA แแ แแแชแแแ, แ แแแแแแช แแแแแแแแแแก Java แแแแก แแแขแแ แแแแ?).
แฉแแแ แแกแแแ แแแแฅแแก แจแแแแ แแแแ แฃแกแแคแ แแฎแ แแแ แแ แแแแแแแชแแแแแก แจแแกแแฅแแแแแแ Rust แแแแก แฌแงแแแแแแ, แ แแแแแก แแ แกแแแแแแก แแแแแแ แแ แแก แจแแชแแแแแแแก แแแแแ แแแแกแแก แแฆแแแคแฎแแ แ แแแแแแแแชแแแก แแ แแก.
WebAssembly แแกแแแ แแแแแจแแก แฉแแแแฏแแ แแ, แ แแ Solomon Hikes, Docker-แแก แแ แ-แแ แแ แจแแแฅแแแแแ, แฌแแ แแ, แ แแ WebAssembly แแ WASI แ แแ แแ แกแแแแแแแแ 2008 แฌแแแก, Docker แฃแแ แแแแ แแ แแแแแแแแแแแ.

แแแกแแแแแ แ แแ แแ แแก, แ แแ Rust แแงแ แแฎแแแ แแแ แขแแขแฃแแ แขแแฅแแแแแแแแก แแแแฆแแแแ แจแแ แแก - แแแกแ แแแแกแแกแขแแแ แแแแแแแฃแ แแ แแแแแ แแแแ แแ Rust แ แแแแแแแแ แฌแแแก แแแแแแแแแแแจแ แงแแแแแแ แกแแงแแแ แแแ แแ แแแ แแแแ แแแแก แแแแ, แจแแแแแแแแก แแแฎแแแแแ. .
แแก แแ แแก แกแขแแแแก แกแแฃแแ แแแแ แกแแแแแ, แ แแแแแแช แแแแแแ แแฉแแแแแแก Rust-แแก แแแแแงแแแแแแ แกแ แฃแแแ แแแแแแแ แแชแแแแแฃแแ แฃแกแแคแ แแฎแแแแแก แจแแชแแแแแแแก แ แแแแแแแแแก แแแแแคแแ แแแแแก MS-แจแ แแ แกแแแฃแแ แจแแชแแแแแแแก แกแแแ แแ แ แแแแแแแแแกแแแ. Windows, แ แแแแแแช แแแแ แแแฌแแแฃแแแก แแ แแแฎแแแ แแก แแแแแแแแแแแจแ แแฆแแแแฉแแแแก.

แแแแแ แแกแแคแขแก แ แแแแ แแ แฃแแแกแฃแฎแ แแกแแ แแแแแฌแแแแแก แแ แแก แแแแแแแ.
2. Microsoft-แแก แแ แแแฅแขแ Verona, แ แแแแแแช แแแแแแแแก Windows แแ แแแแแกแแแแ แ แแแแ แแชแแฃแแ แกแแกแขแแแแก แแกแขแแ แแแก แแฎแแ แแแแ แแก แแแฎแกแแแก
Microsoft-แแก แแแ แแแจแ แแ แกแแแฃแแ แจแแชแแแแแแแก แ แแแแแแแแ Windows แแ แแแแฎแแแ แแแแแก แแ แแแ แแแแแแก แฃแแแขแแกแแแ แแแแ 12 แฌแแแก แแแแแแแแแแแจแ แแแแฅแแแก แฌแ แคแแแแ แแแแแแ แแ.

2019 แฌแแแก แแแแแ แแกแแคแขแแก แแแแแฃ แแแ แแแแกแแแ , แ แแแแช แจแแแซแแแแ แแแแ แแแฃแฆแแก แแแแก.
แแก แแ แแก Microsoft-แแก แแแแชแแแขแแแ, แ แแแแแแช แแแแแแ แแกแแฎแแแก Rust แแแแก แแแแแแแ แแแคแฃแซแแแแฃแแ แฃแกแแคแ แแฎแ แแ แแแ แแแแ แแแแก แแแแก แจแแฅแแแแก: Microsoft Research-แแก แแแแแแแแแ แแฆแแแแฉแแแแก, แ แแ แฃแกแแคแ แแฎแแแแแก แแ แแแแแแแแแก แฃแแแขแแกแแแ แแแแแแจแแ แแแฃแแแ C แแแแก แแซแแแ แแแแแแแแ แแแแแกแแแ, แ แแแแแจแแช แฃแแแขแแกแแแ Windowsแแแแแแก แแกแแแแกแ แแแ Verona แแแ แแแแก แแแฎแกแแแ แแแแก แแ แ แแกแฃแ แกแแแแ แแ แแแ แแฃแ แฌแแแแแแก แแแแแงแแแแแแ . แแฃ แแกแฃแ แ แแแขแแแฃแ แแ แแแแแแ แ แแแแ แแฃแจแแแแก, แแแแแฎแแแแ .
แกแแแแขแแ แแกแแ, แ แแ Microsoft แขแ แแแแชแแฃแแแ แแฆแแฅแแแแ แ แแแแ แช แแแ แแขแแแแก แแแแแ แแ แแ แงแแแแแคแ แแก แแฎแแแก แแแฌแแแแแฆแแแแแ, แแแฃแฎแแแแแแ แแแแกแ, แ แแ Glasgow Haskell Compiler-แแก แแแแแแ แ แแแแแแแแแ แ, แแฃแจแแแแก Microsoft-แจแ.

แแ แแแแ แแแแขแ แแแแก แจแแแแแฎแแ แแแ แแแแ แแแแแชแแแแ: โแแ แแ แแก แแ แ แแแแ แแชแแฃแแ แกแแกแขแแแแก แแแ แแแแก แแแแแฌแแ แ Rust-แจแ?โ แแแแฆแ แแแฃแแแแแแแ แแแกแฃแฎแ - แแจแแแ แแ, แ แแ แฏแแ แแ แแ แแก แจแแกแแซแแแแแแ แแแแ แแชแแฃแแ แกแแกแขแแแแก แแแ แแแแก แแแแแฌแแ แ, แแแแ แแ แแแแฎแแแ แแแแแแแก แกแแแ แชแแจแ แแแจแแแแฃแแ แแ แแแ แแแแแ แฃแแแ แฎแแแแฎแแ แแฌแแ แแแ. แจแแฃแฉแแ แแแแแ แแ แแชแแกแ แแแแฌแงแ แแ แแก แแแฎแกแแแก แแแแแแแแก แแฎแแ แแแแ แแก แงแแแแ แแแแ แแชแแฃแแ แกแแกแขแแแแกแแแแก.
3. Dart แแ แแแ แแแแ แแแแก แแแแก แแแแฃแแแ แแแแก แแ แแ Flutter-แแก แคแ แแแแแ แแก แฌแงแแแแแแ
แแแ แฌแแฃแแแแฃแแ แแแ , แจแแแแแแ แกแแแฎแแ แแแแ แกแแฃแ แแ แแแแ แแ แ แแฎแแแแ แฉแแแแแแแก แแ แคแแ แแ แกแแแแแแแแแแแกแแแแก, แแ แแแแ แแแกแ แคแแ แแแ แแแแก แแ แแชแแกแจแ แฃแจแฃแแแ แแแแแฌแแแแแ แฃแแแขแแกแแแแกแแแแก. Dart แแ แแแ แแแแ แแแแก แแแแ, แ แแแแแแช Google-แจแ แ แแ แฌแแแก แฌแแ แแแแแฉแแแ, แฌแแแก แแแแฃแแแ แแแแก แกแฌแ แแคแ แแ แแ แแแแแชแแแ.
แแ แแแงแแแแ แแ แแแ แแแแ แแแแก แแแแแแก แแแแฃแแแ แแแแก แจแแคแแกแแแแก แฉแแแก แแแแแแก Github-แแ แกแแชแแแแแแก แแแแแแแแ, แแแแจแ แแ แแฎแแ . แแฃ แฌแแแก แแแกแแฌแงแแกแจแ Dart-แแ แแฎแแแแ 100 แแแแฃแแแ แฃแแ แกแแชแแแ แแงแ, แแฆแแก แฃแแแ 313 แแแแแแแแ.
Dart-แแ แแแแฃแแแ แแแแ แแแฃแกแฌแ แ Erlang, PowerShell, R, Perl, Elixir, Haskell, Lua แแ CoffeeScript. แแ แช แแ แแ แกแฎแแ แแ แแแ แแแแ แแแแก แแแ แแ แแแแแแ แแ แฃแคแ แ แกแฌแ แแคแแ แฌแแแก. แ แแขแแ แแแฎแแ แแก?
แแ แฌแแแก แแ แ-แแ แแ แแแแจแแแแแแแแแ แแแแแ แแจแ แฌแแแแแแฎแ แ แแฉแแ แ แคแแแแแแแแ แแ แแแฃแ แแแ แแแฎแกแแแแแแก แแแแจแแแแแแแแแ แแแฌแแแ แแซแฆแแแแแ แแแแแแแก, แแฃ แ แแแแ แฎแแแแ แแ แแแ แแแแ แแแแก แแแแแ แแแแฃแแแ แฃแแ. แกแฎแแ แกแแขแงแแแแแ แ แแ แแแฅแแแ, แ แแฉแแ แแแก แแแ แแ, แแ แ-แแ แแ แแแแแแ แ แแแแแแ แแ แแก แแแแฃแแแ แฃแแ แแแแแแแชแแแก แแ แฉแแ แฉแแก แแ แกแแแแแ แแแแแแแ แแแแแแแชแแ.
Dart แแแแกแแแแก, แแแกแ แแแแฃแแแ แแแแก แแแแแแ แแ แแก แแแแแแฃแ แ แแแแแแแชแแแแแก แแแแแแแแ แแแแก แฉแแ แฉแ , แ แแแแแก แแแแฃแแแ แแแแก แแ แแ, Google Trends-แแก แแแฎแแแแแ, แกแฌแแ แแ แแ แฌแแแก แแแกแแฌแงแแกแจแ แแแฎแแ.

แฉแแแ แแ แแคแแ แ แแแชแแ Dart-แแก แจแแกแแฎแแ, แ แแแแแ แฉแแแ แแ แแแแแแแแ แแแแแแฃแ แแก แแแแแแแแ แแแแก, แแแแ แแ แแแแแแ แแแแแกแแแแแแแ แกแขแแขแแแฃแ แแ แแแ แแคแแ แแ แแแ แแแแ แแแแก แกแฎแแ แแแแก.
4. แแแ แแแแก แแแแแ แฉแแแแก แจแแแกแ Linux แแ แแแกแ แกแแแแแแแแแแ eBPF แแแ แขแฃแแแฃแ แ แแแแฅแแแแก แฌแงแแแแแแ
แฉแแแ VDSina-แแ แแแแงแแแ แก แแแแคแแ แแแชแแแแ: แฌแแแก แแแแแแ DevOops-แแก แแแแคแแ แแแชแแแแ แกแแแแข-แแแขแแ แแฃแ แแจแ แแ แแแแแฌแแแแแแ แแแแแฆแ แแ แแแแ แแแแแแแจแ, แ แแแแแแช แแซแฆแแแแแแแ แแแแฃแกแขแ แแแก แขแแแแแแชแแแแกแ แแ แชแฎแแ แกแแแแแแก. 2019 แฌแแแก แแกแแ แกแแฃแแ แแแจแ แฌแแแงแแแแ แแแกแแแ แแแแแ แแงแ:
- แแแแแ แ แแแแแแ, แ แแแแแ แซแแแแแ แแแกแแฌแงแแแแ
- Kubernetes แชแแชแฎแแแแ แแ แแแแฎแแแแแแ แแ แแ แฌแแแ แแแแ แซแแแแแแ - แแแกแแ 2020 แฌแแแก แแแแคแแ แแแชแแแแแ แแแแแ แแฅแแแแ แกแแฃแแแ แ
- แแแแกแแแแจแ, แแแ แแแจแ Linux แแแแ แฎแแแแ แแ แชแแ แ แชแแชแฎแแ แแแแแแแแก แแ แจแแแแฃแฎแแแแแก
แฉแแแ แแแแแกแแแ แแกแแ, แแแ แแแแก แจแแแฃแจแแแแแแก แแแแ แแฃแแฅแขแก แแ แแแแแแ แแ. Linux แแแแแแแ แฎแแแแ แแกแแแ แ แแ, แ แแช แแ แ แแฎแแแแ แกแแแแขแแ แแกแแ, แแ แแแแ แ แแแแแฃแชแแฃแ แแช. แงแแแแแแ แแฆแกแแแแจแแแแแ eBPF แแแ แขแฃแแแฃแ แ แแแแฅแแแ, แ แแแแแแช แแแแแแแแ แแแแแ แจแแแฅแแแ แฅแกแแแฃแ แ แแแแแขแแแแก แคแแแขแ แแชแแแก แแแแฆแแแแ แแแแชแแแแก แแแแแกแแญแ แแแแ แแ แแแก แจแแแแแ แแแแแแแแ แแ แแแแแแ แแแแแจแแฃแแแแแก แแแ แแแแก แแแแแก แแแ แขแฃแแแฃแ แแแแฅแแแแ.

แแแ แแแแก แจแแแฃแจแแแแแ Linux: แแงแ

แแแ แแแแก แจแแแฃแจแแแแแ Linux: แแก แแแฎแแ
eBPF-แแก แกแแจแฃแแแแแแ, แแแ แแแ แแฎแแ แแคแแฅแกแแ แแแก แแแแแแแแแก, แ แแแแแแ แแแฌแแแแแ แแแ แแแแฃแจแแแแแ แแแ แแแแก แแแ แแแแช แจแแกแแซแแแแแแแ - แแแขแแ แคแแแกแ แจแแกแแซแแแแแแก แฎแแแก แแแ แแแแแ แฃแกแแคแ แแฎแแ แแ แแคแแฅแขแฃแ แแ แฃแ แแแแ แแฅแแแแแแแก แแแแฎแแแ แแแแแก แกแแแ แชแแแแ แแ แแแ แแแแก แคแฃแแฅแชแแแแแแฃแ แแแแก แแแคแแ แแแแแแก แแ แจแแแกแแแแก. Linux, แแแแฃแก แขแแ แแแแแกแแก แงแแแแแกแแฎแแแแแแ แแแแแแก แแแแ แแแก แแแแแ.
eBPF-แแแ, แแ แแแ แแแแแแก แจแแแฃแจแแแแแ, แ แแแแแแ แกแแฅแแแแแแแ แแญแแแ แ แแแแจแแ แจแแ แแแ แแแแแ แฃแ แแแแ แแฅแแแแแแแกแแแ. Linux แ แแฃแแ แแแแแแ แแงแ โ แแแแ แแแฌแงแแแแแแแแแแกแแแแก แแ แแแแแ แแแแกแ แแ แแแแฎแแแ แแแแแก แกแแแ แชแแจแ แคแแแแฃแ แ แกแแกแขแแแแแแกแแแแก แแแขแแ แคแแแกแแแแก แจแแฅแแแแก แแแแแชแแแแ แแแ แแแแก แแแแแแแแแ แแแแก แแแแ แคแแ แแแแฃแ แ แแแแฎแแแแแก แแ แแชแแกแ แกแญแแ แแแแแแ. Linux.
eBPF แแแขแแ แคแแแกแแก แแแแแฉแแแแ แกแแแ แซแแแแแแ แแแแแแ แขแแแ แแกแแแ แแ แแแ แแแแแแก แแแฌแแ แแก แแ แแชแแกแ - แจแแกแแแแก แแแ แแแ แ แแแแแแ, แฃแคแ แ แแแขแ แแแแแแแแแ แ แแฅแแแแ แแ แกแแแแแแแแแแ แแแแแ แแแชแแชแฎแแแแแ.
แแ แแ แแแ แแแ แขแ แฉแแแก แแแแฃแแแแแแจแ: แแชแฎแแแแแก eBPF-แแก แแแแจแแแแแแแแก แแแ แแแแก แแแแแแแแ แแแแก แแแแกแแกแขแแแแก แแแแแ แฉแแแแกแแแแก (!). แแแแแ แแ แแ, แแ แแแแแแแ แชแแแแแแ แแแแแแแแแ แ (แแ แแแกแ แแแแ แคแแแ แแแ ) , แ แแแแแแช 50 แฌแแแแ แแ แฃแขแแแแแแ.
แแแแกแแแแจแ, แแแแฃแก แขแแ แแแแแกแ, แ แแแแ แช แฌแแกแ, แกแแฏแแ แแ แแ แแฅแแแก แแแก แแกแแแ แ แแฆแแชแแแแก แแแแ แแ แแ แแแกแแแก - แแแก แฃแแแ แกแแฏแแ แแ แแแแ แแแแแขแแ แแแแแแงแฃแ แแแแแแก? ๐

5. Linux แแแแฅแแแก แแแแ แแฃแ แกแแแแ แฉแแแ แญแ FreeBSD-แแก แแฃแแแจแ แแแ แแแจแ แแ แกแแแฃแแ แแกแแแฅแ แแแฃแแ io_uring แแแขแแ แคแแแกแแ. Linux
แ แแแแแ แแแ แแแแ แแกแแฃแแ แแแ Linux, แแฃแชแแแแแแแแ แแฆแแแแจแแแก แแแแแ แแ แแ แแแแจแแแแแแแแแ แแแฃแแฏแแแแกแแแ, แ แแแแแแช แฌแแแก แแแฎแแ: แแฎแแแ แแแ แแแแก แฉแแ แแแ แคแแแกแแฃแฅแแก แฏแแแก แแฅแกแแแฃแก แแแแ .
แแ แแแแแ แฌแแแก แแแแแแแแแแแจแ, FreeBSD แกแแกแขแแแแก แแแแแแแกแขแ แแขแแ แแแ แแ แแแแแแแแแ แแแ แแแแแแแ แแ แฉแแแแแก แแแแ แแแแ แแแแแแแแ, แ แแ FreeBSD-แก แฃแแแแแกแ แแกแแแฅแ แแแฃแแ แจแแงแแแแ/แแแแแกแแแ แฐแฅแแแแ, แแแแ แ Linuxแแแแแแแแแ, แแก แแ แแฃแแแแขแ แแแแ แกแแแ แแแแ แแแแแฅแกแแแแ.
แแฎแแ แแแแแจแ แแแแแแงแแ แ แแแแแ. แแ แจแแกแ แฃแแแแแก แกแแแ แแแแขแแชแแ แจแแแแแแแ แจแแแแแแญแแแแแ, IOPS แแแ แแแแ 14%-แแแ 102%-แแแ, แแแแแแก แแแแแแแ แแแแแแแแแแ แ. แแ แกแแแแแก แแ แแขแแขแแแ, แ แแแแแแช แแงแแแแแก แแกแแแฅแ แแแฃแ I/O-แก PostgreSQL-แจแ (แแแแแแฃแ ), PostgreSQL-แแก แแกแแแฅแ แแแฃแ I/O-แแ แแแแแฅแชแแแแแ. แแแแ แแ แแแแแแแแแ แแ แกแแแแแแแแแแแก แแแแกแแ แแแขแแฃแแ แแฃแแแแแก แแแแแแแแกแฌแแแแแแ, แฉแแแ แแ แชแแแแแแแแแก แฏแแ แแแ แแแฎแแแแแ 2020 แฌแแแก.

6. AMD-แแก แขแ แแฃแแคแแแฃแ แ แแแแ แฃแแแแ Ryzen แแ แแชแแกแแ แแก แฎแแแแ
แแ แแคแแ แ แฃแฉแแแฃแแ, แฃแแ แแแแ AMD, แ แแแแแแช แแแแฃแกแขแ แแแจแ แแแแ แฎแแแก แแแแแแแแแแแจแ แแแแก, แ แแแแ แแก แแ แฆแแแแก.
Ryzen แแ แแชแแกแแ แแแแก แแฎแแแแ แฎแแแแ แแฉแแแแ แฌแแ แแแฃแแแแแแแ แคแแกแ/แแคแแฅแขแฃแ แแแแก แแแแแคแแ แแแแ: แแกแแแ แแ แแแแแแ แ แ แแแแแแจแ . แแแแแฃแ แแแชแแแจแ Intel แแซแฃแแแแฃแแแ : แแฌแแแแก แกแแแฃแแแ แ แจแแแแแแแแแแ แแแแแฃแแ แแ แแแ แแแแแแก แแแแแแ แแคแแฅแขแฃแ แแฃแจแแแแแก แแแแแฃแ แแแขแแก แแ แแชแแกแแ แแ. แแแฃแฎแแแแแแ Intel-แแก แแ แซแแแแก แแแแซแฃแ แ แแแแแแกแ, .
7. AMD-แแก แจแแแแแ, Apple แแแแแแ แแกแแฎแแแก แแแฆแแ Intel-แแก แขแแ แขแแก แแแฌแแแ iPadOS-แแ แแ แแแแแกแแก แซแแแแ แฎแ แแแแแแ.
แงแแแแแก, แแแกแแช แฎแแแจแ แแแ แแฆแแก แแแญแแ แ แจแแฃแซแแแ, แฉแแแฃแแแแ แแ แชแแแแแแก แแแแแฌแแแแแแ แแแแฆแแก แแแแแแขแแแแก แแ แซแแแแแจแ แแ แแ แ แแฎแแแแ AMD แแแ แซแแแก Intel-แแก แแแแแแก แแแแแแ. Apple แฎแฃแแ แแแแจแ แแแฎแฃแชแ แฎแแ แแแแ แแฅแชแแแแ.
แแแ-แแแแ แฉแแแแแ แแแแแแแแแก แฌแแแ แแ แแแฎแฃแชแ แแ แแฎแแแแแแ แแ แฎแแ แ แแแแแแ, แฅแแแแแ แแ แซแ แแฎแแแแก แคแแ แ แซแแแก.
แแฎแแแแแแ แแ แฎแแ แ แซแแแแก แกแแแแแแแแก:
- แแแกแแแแ, แกแฌแ แแคแแ, แกแฌแ แแคแแ แฉแแแแแแ แแ แซแ แแฎแแก แแแแแแแแฃแแแ
แแ แกแฌแ แแคแแ, แกแฌแ แแคแแ, แฉแแแ แแแแแ แฃแแแแแแ!
-แแ แ!
- แแแ แแ, แแแจแแ แฉแฅแแ แ, แฉแฅแแ แ แฉแแแแแแ แฅแแแแแ, แแแแ แแ แซแ แแฎแแก แแแแฃแซแแฎแแ แแ แกแฌแ แแคแแ...
แกแฌแ แแคแแ แแแแแแ!
-แแ แ!
- แแแ แแ, แแแจแแ แ แแก แแแแแแแแ?
- แแแแ, แแแแ แฉแแแแแ แแแแแแ, แแแแ แแแฎแแ แก แแแแฎแแชแแแ แแ
แแแ-แแแแ แแแแฃแแ แฃแแแแ แฉแแแแก แแแแแแก!
แแฎแแแ iPadOS-แแก แแแแแจแแแแแ, Apple-แแ แแแแแแงแแแ แขแแฅแขแแแ Intel-แแก แฌแแแแแฆแแแแ, แกแแฎแแแฌแแแแแแ "แแแ แฆแแแแแก แแแแแแชแแ".
แแแแแแแแแแก แแแแแแ แขแแแ
"แแแ แฆแแแแแก แแแแแแชแแ" แแ แแก แแแแแแชแแ, แ แแแแแแช แชแแแแก แฆแแ แแแฃแแแแแแแก แแแแแแกแก แแแแแ แแ. แแแแแแ แแฃแแแ, แซแแแแ แแ แแแฃแฅแชแแ แฎแแแแ แแ แแแแแแฃแ แแแขแฃแแแ แแแแ แแฎแแแแ แแแแขแแ, แ แแ แแแ แแแแขแ แแแ, แ แแแแแแแแช แแแ แ แแคแฃแซแแแแแแ แแแแแฃแ แแแชแแ, แแแ แแแแก แแแแจแแแแแแแแก.
โแแแ แฆแแแแแก แแแแแแชแแแแแกโ แแแแแแแแแแแ แขแแแแคแแแ (แจแแชแแแแ แขแแแแแ แแคแ), แแ แแฅแแแก แแแแแแ (แจแแชแแแแ แแชแฃแ แแแ แแแแแแ), แแแฎแแแแ แแแแขแแ แแแ (แจแแชแแแแแ แแแแฃแฃแแฃแ แ แแแฌแงแแแแแแแแแ), แชแแคแ แฃแแ แแแแแ แแแ (แจแแชแแแแแ แคแแ แแก แแแแแ แแแ) แแ แแแแฅแขแ แแแฃแแ แคแแกแขแ (แขแ แแแแชแแฃแแ แคแแกแขแแก แจแแคแแ แฎแแแ).
Apple แแงแแแแแก แกแแแฃแแแ แแแแแแ แกแแแซแแแแ แแก ARM-แแ แแแคแฃแซแแแแฃแ แแ แแชแแกแแ แแแก แแ แแก แฃแคแ แ แแแแจแแแแแแแแแแ แแแแฎแแแ แแแแแแแกแแแแก, แแแแ แ Intel-แแก x86-แแก แแแแแ แฉแแแแ แฉแแแแแ แจแแกแ แฃแแแแ.
Apple แแฎแแ แฎแแแก แแแแ แแก แฌแแแแก แแแขแแชแแแแก, แแฅแชแแแก iPad-แก แแแกแแ แแแแ แขแแ แแแแแแแแแ แกแ แฃแแคแแกแแแแ แกแแแฃแจแแ แแแกแขแ แฃแแแแขแแ - แฏแแ แแแแแแแก, แแแแช แฅแแแแก แแแแขแแแขแก, แแฎแแ แแ แแแแแแแแแ แแแแกแแแแก. แ แ แแฅแแ แฃแแแ, แแแแ แแแ แแแฎแแแแแ ARM-แแ แแแคแฃแซแแแแฃแ MacBook-แก, แแแแ แแ MacBook Pro แแแแแแแขแฃแ แแแแก แแแแแแแแแ แแแแแแจแแ แแแฃแแ แแชแแ แ แแ แแแแแแแแ แฎแแแก แฃแฌแงแแแก แแแขแแ แแแขแแฃแแ แแแแแฌแงแแแขแแแแแแแแก แซแแแแแก แแ แแ แ-แแ แแ แแแแแแแ แแแแแ แแแแ, แ แแ แแฅแแแแ iPad Pro iPadOS-แแ.
แ แ แจแฃแแจแแ แแแแแกแ แแ แแแแแ แแกแแคแขแ?
แแ แ แแ แแก แแแแแกแแ แแฃแกแขแแ แแแแแ แฎแ แแแ แแแแแแงแแแ IBM-แแแ แแ แแแ.
1970-แแแ แฌแแแแจแ IBM แแแแแแแ แแแแ แกแแ แแแ แแแแก แแแแแ แแ, แแแแแแฏแแ แแแฃแแแ แฃแแฃแแแแแแงแแคแแ แแแ แกแแแแแฃแ แแแแแแฃแขแแ แแแก แฉแแแฃแแแแ แแแ แแแแแแแแแกแแแแก. 1980-แแแ แฌแแแแจแ แแแแขแกแแ IBM-แแก แกแแฎแกแ แแแ แแแแแแงแแแ MS-DOS-แแก แจแแกแแฅแแแแแแ แแ แแแชแแแแแ แแแแกแแแแก, แแแแ แแชแแฃแแ แกแแกแขแแแแก แฃแคแแแแแแ แแ แแแแแ แจแแแแแ แฉแฃแแ. แแแแฎแแก แแแฆแแแแก แจแแแแแ, Microsoft-แแ แจแแฅแแแ MS-DOS-แแก แแ แแคแแแฃแแ แแแขแแ แคแแแกแ แแ แแกแ แแแแแแแ แแแแแแฃแขแแ แแแแก แกแแแงแแ แ. Windows โ แแแแแแแแ แแแแแ DOS-แแ แแ แแคแแแฃแแ แแแแแคแแ แแ, แจแแแแแ แแ แแแกแแแแกแแแแก แแแกแแฎแแ แฎแแแแแ แแแ แแแแ แแแแแแฃแขแแ แแก แแแแ แแชแแฃแแ แกแแกแขแแแ. IBM-แแ, แแแแแ, แแแฃแฎแแ แฎแแแแแแ แแแแแแแแแ, แแแ แกแแแแแฃแ แ แแแแแแฃแขแแ แแแแก แแแแแ แ แแฎแแแแแแ แแ แแ แกแฌแ แแค Microsoft-แแแ แฌแแแแ. แแก แจแแกแแแแจแแแแ แแกแขแแ แแ แซแแแแแ แแแแแแ แจแแแแฏแแแ, แแกแ แ แแ, แแฃ แแแแแขแแ แแกแแแ, แ แแแแ แแแฃแฌแแแก Apple แแแแแฃแ แแแชแแแก Intel-แก 2020 แฌแแแก iPadOS-แแ, แแแ แฉแแแ แแแก แแแแแงแแแแแแก. .
8. ZFSon-แแก แแแแแชแแแก แแแซแแแแ แแแLinux โ แแแฎแฃแชแ แชแฎแแแ แฆแแ แก แแ แแแแคแฃแญแแแก
แแแแแแแแฃแ แ แแแแแแแแ ZFS แคแแแแฃแ แ แกแแกแขแแแแก root แคแแแแฃแ แ แกแแกแขแแแแก แแแแแงแแแแแแ แแแ แแแแแ แแแกแขแแแแขแแ แแแแ. แแแแฏแแ แแคแแฅแ แแ, แ แแ Sun Microsystems-แจแ แแแแฃแจแแแ แแแแแแ แแแ แฌแแ แแแแแแแแแ Homo sapiens-แแก แชแแแแแฃแ แแแแแแแแฃแ แกแแฎแแแแแก (แแแแแ แฎแกแแแแแฃแแ แแ แแแแ แแแแขแ แแแ แแ แแ แแแแแ แแ แแแ Sun-แจแ แแฃแจแแแแแแแ). แแแแแ แแแแกแแฏแแ, แแแฃแฎแแแแแแ แแแชแแแ แแแแแก แฌแแแแแก แแชแแแแแแแกแ, แจแแแฅแแแแ ZFS แคแแแแฃแ แ แกแแกแขแแแแก แแกแแแแกแ แ แแ, แแฃแแแแช แแแแแ แแกแแแแกแ, แแแฃแฎแแแแแแ แแแแแฃแแแฎแแแ แแแชแแแแแ แแแแก แจแแแฆแฃแแแแแแกแ, แ แแแแแแแช แฎแแแก แฃแจแแแแ ZFS-แแก แกแแฌแงแแกแ แแแแแก แฉแแ แแแแก แแแ แแแแก แแแแแแแแ แแแแก แซแแ แแแแ แจแขแแจแ. Linux, แฉแแแ แแแแแ แแแงแแแแแ ZFS-แก แแ แแก แแแแ แแ แจแแแชแแแแแ.
9. Oxide Computer Company - แฉแแแ แงแฃแ แแแฆแแแแ แแแแแแแแ แแแแแ แแฃแแแก, แ แแแแแกแแช แแจแแแ แแ แแแแ แ แจแแฃแซแแแ - แแแแแแฃแ แแแแแ แ แจแแฃแก แจแแฅแแแ
แฉแแแก แกแแแก แแแแแกแ แฃแแแ แแ แแแแ แแแแขแ แแแแก แแแแแ แแ แแ แฎแกแแแแแแ, แกแแแแแแแช แแแแแฌแงแ.
แแ แแแแ แแแแขแ แแแแ แแ แกแฎแแ แแแแแแ แแแแ (แแแแแแ แแ แแแแแแแ แแกแแแ แแแ แ แแฃแจแแแแแ Sun-แจแ) แแแแแ แกแแก แกแแฌแแ แแ แ.แฌ. , แ แแแแแก แแแแแแ แ แแแแแแแ แคแแ แแแแแกแจแขแแแแแแ แแแแแงแแแแแแกแแแแก แจแแกแแคแแ แแกแ แกแแ แแแ แฃแแ แแแแขแคแแ แแแก แจแแฅแแแ. แชแแแแแแแ, แ แแ แซแแแแแ แแกแฎแแแแ แแแ แแแ แแชแแแแ, แ แแแแ แแชแแ Google, Facebook แแ Amazon, แแ แแงแแแแแแ แฉแแแฃแแแแ แแแ แกแแ แแแ แแก แแแแ แแขแฃแ แแก แแแแแแแ แกแแฅแแแแแแแแจแ. แแ แแแแแแก แแแแแแแแ แแแแแแ แแกแแฎแแแก แแ แฃแแแแแกแฌแแ แแแแก แแฆแแแคแฎแแ แแก แแ แแแ แแแฃแแ แแ แขแแฅแแแแแก แแแแขแคแแ แแแก แจแแแฃแจแแแแแแ, แ แแแแแแช แจแแกแแคแแ แแกแแ แแแแแกแแแแ แ แฆแ แฃแแแแแแแ แกแแ แแแกแแกแแแแก (แแแ แจแแ แแก Rust แแ แแแ แแแแ แแแแก แแแแกแแแแก).
แแแแ แแแแ แแฎแแแ แ แแแแแฃแชแแแก แแแแแ แแแแ แแ แแ, แกแฃแ แแชแแ แ, แกแแแแแแแแแแ แแฃแงแฃแ แแ แแแแ แแแ แแแแก แแแซแ แแแแแก แแ แแแ แแแแแแแแ แแแแก แแแแแแแ 2020 แฌแแแก.
แ แแกแ แแแแแแแแแช แแแแแฎแแ แฎแแ 2019 แฌแแแก VDSina-แจแ
แฉแแแ 2019 แฌแแแก VDSina-แกแแแ แขแแฅแแแแแแแฃแ แ แแแ แฆแแแแ แแ แแแแแแฆแฌแแแแ, แแแแ แแ แแแแแช แแแแฅแแก แ แแฆแแช แกแแแแแงแ.
แแแแแ แแแแจแ แแแแแแแขแแ แกแแ แแแ แแแก แจแแ แแก แแแแแแฃแ แ แฅแกแแแแก แแแแแงแแแแแแก แจแแกแแซแแแแแแแ แแ แแแแฃแจแแแ แแแแแแแก แ แแแแกแขแ แแชแแแก แกแแ แแแกแ. แคแแกแ แแแแแแแแ แแ แ-แแ แแ แงแแแแแแ แแแแแแ แแแแแ แแ - 179 แ แฃแแแ ru/rf-แแ, แแแ แจแแ แแก แแแแแฎแแแแแกแแแแก.
แแแ แขแจแ แแแกแแฃแแ แแ IT Global Meetup #14-แแ.
แแแ แแแจแ แฉแแแ แแแแแแ แแแ แแ แฎแแก แกแแแแแ แแแแแแฃแแ แกแแ แแแ แแกแแแแก 100-แแแ 200 แแแแแแแขแแแแ แแ แกแแแ แซแแแแแแ แแแแแแ แแแ แขแ แแคแแแแก แแแแแขแ แงแแแแ แขแแ แแคแแกแแแแก (แแแ แแ แงแแแแแแ แแแคแแกแ) - แแแแจแ 32 แขแ-แแแ.
แแแแแกแจแ แแแแฎแแแ แแแแแแก แแแแชแแ แแแขแแแแขแฃแ แ แแแกแขแแแแชแแแก แจแแกแแซแแแแแแแ Windows Server 2019. แแแกแแแแแก แแแแแชแแแแ DDoS แจแแขแแแแแแกแแแ แฃแคแแกแ แแแชแแแก แฃแแ แฃแแแแแงแแคแ แแแแฌแงแ.
แแกแแแ แแแแแกแจแ, แฉแแแแ แแแแแแแแ แแแแแฉแแแ Habrรฉ-แแ, แแแแแฃแขแแ แแ แ แแแแ แแแแแแฎแแแ แ แแแแแขแฃแ แ แแแฎแขแแแแก แแแแแแแแแจแ แแแแฎแแแ แแแแแแ แแฎแแ แแแญแแ แแจแ.
แแแแแกแขแแจแ แแแ แแแแแแขแแก แกแแแแจแแขแแแแก แจแแฅแแแแก แจแแกแแซแแแแแแแ โ แกแแ แแแ แแก แกแแ แแแแ แแ แแกแแแแ.
แกแแฏแแ แ API แแแแแแแแ.
แฉแแแ แแแแแแ แแแ แแ แฎแแก แกแแแแแ แแแแแแฃแแ แกแแ แแแ แแกแแแแก 200-แแแ 500 แแแแแแแขแแแแ.
แฉแแแ แแแแแฆแแ แแแแแฌแแแแแแ Chaos Constructions 2019-แแก แแแแคแแ แแแชแแแจแ, แแแแ แชแแแแแแแ แแแแ แแฎแแแก แแแแแแแแแก แแแแแแ, แ แแแแ แช แกแแฅแแแแแ (แแแแแแแแแก แกแแแแแแ แแงแ โแ แแชแ แแแแแแแแแ แ แแแแแแโ) แแ แแแแคแแแฅแแ แขแแแแแ แแแแก แฉแแแแแ.
แกแแฅแขแแแแแ แจแ แฉแแแ แแแแฃแจแแแ IT แแแแแแแแแก แงแแแแแแ แกแแงแแแ แแแ แแ แแแแแแ แฃแแ Instagram - VDSina-แ แแแแฌแงแ แแแแแ แแแ แกแแแฎแแแแแแ แแ แงแแแแแแฆแแฃแ แชแฎแแแ แแแแแ. .

แแแแแแแ แจแ แฌแแแแแแ Highload++-แจแ, แแแแแฆแแ แแแแแฌแแแแแแ แแ แแแแ แแแแแแแแ โKubernetes-แแก แแแแแชแแแแ แแแแแแโ แแ แแแแแฌแแแแแแก แแแแแแแแก แฅแฃแแแแ แฉแแแแชแแแ.
แแแแแแแแ แจแ, แฉแแแ แแแกแแฃแแ แแ DevOps-แแก แจแแฎแแแแ แแแ GazPromNeft-แแก แแคแแกแจแ แแแฎแกแแแแแแ Kubernetes-แแก แแแแแชแแแแ แแแแแแแก แจแแกแแฎแแ แแ แแแกแแแแจแ DevOpsDays แแแแคแแ แแแชแแแแ. , แ แแแแแแช แแแแแแแแแ แแงแ แฉแแแ แฌแแแก แกแแฃแแแแแกแ แจแแกแ แฃแแแแ.
แแแกแแแแ
แ แแแแ แช แแแกแแ แขแแแแแแ แแฅแแ, แแแชแแแแแแ แแแแแแแ แแแแก แแ แแแแแแแ แแแ, แ แแกแแช แแแแแแแแแ แแแ แแแแฎแแแ. แแแแแ แแฆแแแแจแแ, แ แแ แงแแแแแคแแ แ แแฎแแแ, แ แแกแแช 2020 แฌแแแก แแแแฎแแแ, 2019, 2018 แแ แฃแคแ แ แแแ แแฃแแ แฌแแแแแแแ แแฆแแแก แกแแแแแแก. แแ แจแแแแชแแแแ แแแแแแแแก แแฃแกแขแแ แแ แแแแแแแ แแแแก, แแแแ แแ 2020 แฌแแแ แแแแแแแแแ แแ แแฅแแแแ แแก แฌแแแ, Linux แกแแแฃแจแแ แแแแแแแแ (แ แแแแก แแแฎแแ แแแแแก แกแแแฃแจแแ แแแแแแ?) แแ แฌแแแ Linux แแแแก แแแแแแฃแ แแแฌแงแแแแแแแแแแ แฃแแแ แแแแฎแแแแแแ แแแ แฌแแแแ แแฎแแแแแ.
แงแแแแ แจแแแแฎแแแแแจแ, แแแแแ แแแฅแแก, แ แแ แแ แ แฌแแแแฌแแแจแ แแกแแ แจแแแแแ แแแแแแ แแ แแแแแแฎแแแแแ, แแฃ แ แแแแ แแแแแแแแ แแ แงแแแแแคแแ แ.
แงแแแแ แแแแแแแแ แแ แแแแแแแแแ!
แแแฐแงแแแแ แฉแแแแก แแแแแแแแแ แก Instagram-แแ
แฌแงแแ แ: www.habr.com
