Ferrugem para desenvolvedor web - início rápido e vôo rápido

Olá pessoal! Hoje, quero compartilhar minha experiência em aprender o idioma e a rápida implementação de um projeto de rede de alta carga, usando as tão populares e populares conexões de rede assíncrona, agora sem bloqueio, na nova, bonita, elegante e muito eficaz linguagem Rust.
Darei ênfase especial no post a uma explicação rápida e clara dos recursos da linguagem e da plataforma para especialistas que possuem ampla experiência em desenvolvimento web, porque eu mesmo sou. Há um equívoco de que a curva de entrada no Rust seja muito, muito íngreme. Mas vou mostrar que isso está longe de ser o caso. Despeje o café e dirigi!

Uma Breve História dos Valores de Programação

Para que o material fique bem na cabeça e no coração, é bom lembrar brevemente o que as pessoas queriam fazer na programação nos últimos 50 anos e com o que acabaram. Sem ofensa, apenas opinião subjetiva pessoal e holivar, apoiados por 20 anos de experiência em desenvolvimento.

Idiomas de baixo nível: C, C ++

É claro que você pode escrever o programa imediatamente na forma de números em códigos de máquina e muitos o fizeram no ZX Spectrum, BK0010-01 e no PC - o código acaba sendo muito rápido :-) Mas somos pessoas, muita informação não cabe em nossas cabeças, estamos distraídos e, portanto, distraídos. mesmo a invenção do assembler não ajudou muito - código em um nível tão baixo é muito raramente escrito e com muita precisão e, provavelmente, se você não estiver desenvolvendo drivers, microcontroladores ou sistemas embarcados complicados, isso não será útil na vida.


No início dos anos 70, o Bell Labs inventou a linguagem C, que se enraizou graças à sintaxe lacônica e a abstrações muito "baratas", quase se tornando um "montador portátil". É claro que se você tomar uma tonsura, escrever por 10 anos nas noites C, não comer carne, rezar e não se distrair com as redes sociais e o sexo justo, poderá escrever programas muito úteis e rápidos, como o GNU demonstra com eloquência, excelentes jogos produtivos, amada, mas não alternativa na qualidade do Windows, e muitos outros exemplos podem ser dados.
Mas o outro lado da moeda está constantemente se fazendo sentir - abrindo regularmente buracos na segurança (uma indústria inteira para "buracos no software" foi criada), causada por buracos no próprio conceito da linguagem C - o compilador é como um touro irresponsável, com poder incrível, orgasmo intenso e pouca memória. Qualquer negligência - e você não pode simplesmente abandonar o programa (desreferenciar um ponteiro nulo, liberar o ponteiro duas vezes, sair da matriz), mas arruinar irreparavelmente os dados e não notá-los por um longo tempo até que os clientes comecem a ligar e quando for tarde demais ("comportamento indefinido", diferente do compilador para o compilador).

Björn Straustrup apenas confundiu ainda mais a situação no início dos anos 80, acrescentando recursos de POO a C. Apesar de sua grande popularidade, o C ++, em geral, é visto como uma série de experimentos de programação, como tal, com diferentes resultados de sucesso, incluindo letal. Às vezes até parece que não havia sentido no C ++ desde o início, ou foi gradualmente perdido, dando origem a um monte de conceitos objetivamente complicados e conflitantes, que estão se tornando cada vez mais a cada novo padrão. Apesar do excelente objetivo de "abstrações de custo zero", permitindo obter código rápido, criar uma solução confiável, como em C, são necessárias as seguintes condições:

• experiente, da palavra “muito”, equipe (anos de prática, “monges” de programação)
• bom analisador de código estático
• departamento de testes (no código pode haver falhas deixadas por um compilador irresponsável, que pode ser sentido por um longo tempo)
• requisitos acordados por todos os membros da equipe que são monitorados com cuidado (ponteiros brutos, encapsulamento rigoroso, a disciplina mais severa para nomear variáveis, inicializar objetos etc. não são usados)

É claro que a conformidade com esses requisitos, especialmente no contexto de uma crescente necessidade comercial de um "código que funcione sem surpresas repentinas", é muito cara. O código nesses projetos é escrito por um longo tempo, precisa ser testado por um longo tempo e com cuidado, mas, às vezes, sem C / C ++, antes da invenção do Rust, era realmente difícil de fazer.

Mais uma vez, um resumo do C / C ++ - temos um compilador poderoso, mas "irresponsável", com "abstrações atuais", o que ajuda muito pouco o desenvolvedor. Como resultado, todos os problemas são passados ​​para os ombros do programador. Se pelo menos um programador da equipe não tiver experiência, não for muito cuidadoso e não souber todas as sutilezas do compilador (na verdade, ninguém conhece todas as sutilezas e os usuários as encontrarão mais tarde) - aguarde o problema. Mas então o programa funciona rapidamente e provavelmente corretamente :-) Isso, é claro, gerou todo um mercado de “muletas” - analisadores estáticos, que, como se viu, deveriam ser pagos pelo Cliente. Surge a pergunta - não seria possível escrever um compilador mais rigoroso e seguro que ajude o desenvolvedor e dê origem a programas sem surpresas e brechas de segurança de baixo nível?

Java, C #, Kotlin

A situação com controle francamente fraco do "comportamento indefinido" e requisitos muito altos para desenvolvedores em C / C ++ deu origem ao desejo de criar um ambiente de desenvolvimento seguro, incluindo para a Internet, acessível à maioria dos participantes. Então, no final dos anos 90, o Java apareceu.
Em princípio, agora qualquer pessoa com um nível diferente de treinamento pode escrever tudo e qualquer coisa, e TRABALHOU e não foi incluído no programa - não havia "brechas" de baixo nível em segurança e falhas espontâneas (quase, mas elas já foram causadas por bugs) em uma máquina virtual e corrigida centralmente). Havia apenas “brechas” lógicas ou código lento oculto (nascido da ignorância de algoritmos, do conceito de custo algorítmico e da desaceleração quando o volume de dados aumentava), que não era mais tão assustador e permite que você crie programas rapidamente e, se necessário, reescreva pequenos pedaços com uma equipe qualificada de C / C C ++.
As coisas interessantes e valiosas que o mundo Java trouxe são as seguintes:

• o código foi escrito uma vez para uma máquina virtual que funciona em qualquer arquitetura (windows, linux, mac)
• o desenvolvedor não gerencia mais a memória diretamente, como em C / C ++ - isso é passado para os ombros do "coletor de lixo"; isso elimina o risco de comportamento indefinido, corrupção discreta de dados e possíveis falhas de segurança de baixo nível
• o código é compilado rapidamente, enquanto o programa está em execução (compilação Just_In_Time), porque sabe-se que apenas uma pequena parte é ativada e frequentemente executada no programa; portanto, não faz sentido compilar tudo
• ficou mais fácil escrever código multiencadeado eficiente, como o modelo de memória foi rigorosamente especificado (muito mais cedo do que em C ++), mas mais ainda, nem todos os problemas com a "confiabilidade lógica de vários encadeamentos" foram resolvidos (conflitos, por exemplo, ou corridas de dados ainda eram possíveis)

Obviamente, o advento de uma plataforma tão amigável tornou possível escrever muitos programas úteis e inúteis, dos quais a empresa imediatamente se aproveitou. E o suporte à compatibilidade com versões anteriores em Java por 15 anos ou mais tornou a tecnologia tão popular no mundo corporativo.

Sim, eu também tenho analogias com mulheres sem cerveja e borracha.

No entanto, longe de imediato, os seguintes problemas surgiram em Java:

• devido ao “buraco” lógico no sistema de digitação, que foi herdado do C / C ++, o tipo “Nulo” entrou no Java, que até hoje causa muitos problemas e constantemente leva ao travamento de programadores “não muito experientes” que não conhece o tipo opcional e não está interessado em mônadas da programação funcional
• Projetos Java, às vezes trabalhando um pouco mais devagar, exigem ordens de magnitude mais RAM que C / C ++ necessárias para o coletor de lixo (temos vários projetos que consomem dezenas ou centenas de gigabytes de RAM); isso geralmente não é um problema direto, pois Os preços da RAM estão caindo, mas o "sedimento permaneceu"
• Apesar da compilação jit e dos grandes investimentos em acelerar o coletor de lixo (que muitos novos aparecem regularmente e dizem constantemente: “tente um novo GC, é muito melhor”), por cerca de 20 anos, alguns projetos Java altamente carregados vêm trabalhando com pausas regulares por vários segundos, que não pode ser removido de forma alguma (existe uma coleta de lixo forçada e, como os parafusos no GC não se torcem, o coletor de lixo simplesmente não tem tempo para limpar tudo, mesmo trabalhando em paralelo e devorando mais recursos do que o próprio programa)
• sabe-se que, às vezes, os aplicativos Java GUI congelam e desaceleram, causando raiva dos usuários, devido à mesma coleta de lixo e não há esperança e não se espera
• a sintaxe da linguagem é muito detalhada e redundante (você precisa escrever e ler as palavras "função pública estática" em vez de, por exemplo, "pub fn" ou "def"), forçando algumas vezes a quebrar os dedos nas unhas e causar dor objetiva e sangramento dos olhos
• uma queda acentuada nos requisitos para o nível de qualificações dos desenvolvedores e uma curva de entrada suficientemente baixa deram origem a muitos códigos de "grau de frescura estranho", que constantemente se fazem sentir ao longo da minha vida com um fedor memorável

Após a leitura, deve ficar claro que tudo não pode ser gravado em Java, será gravado lentamente, depois desacelera regularmente e fica travado por um segundo sob carga, às vezes “consome” muita RAM (geralmente pelo menos metade da RAM do servidor é consumida), jogos produtivos Você também não será capaz de fazê-lo, mas algumas lógicas de negócios que não exigem muito desempenho e RAM, especialmente as multiencadeadas, são bastante possíveis, úteis e, portanto, vemos tanta popularidade da tecnologia no mundo corporativo. E nós mesmos usamos Java regularmente e ativamente para os serviços da empresa.

C #, Scala, Kotlin

“E quando será a Ferrugem?” - espere um minuto, você precisa de um pouco mais de preparação para comer esse doce caqui. Se você não falar sobre os recursos de outras tecnologias, não entenderá por que o Rust apareceu e por que é tão popular e procurado .

Então, tentando tornar o Java melhor e mais progressivo, a Microsoft, na pessoa do autor TurboPascal / Delphi, no início do zero surgiu o C # e o conceito de .NET. Objetivamente, de acordo com muitos especialistas respeitáveis, e nas salas de fumantes dos desenvolvedores, o “C #” é mais sexy que o Java, embora, é claro, até agora, apesar do Mono, esteja fortemente ligado à Microsoft com todos os influxos e consequências :-)

Scala é sem dúvida um grande passo em frente, pois a linguagem, é claro, acabou sendo cientificamente obscura e sofisticada, retirando muitas coisas úteis e inúteis do mundo da programação funcional. Mas, de alguma forma, algo não está muito claro com a popularidade. No entanto, o Apache Spark é realmente bom e popular, nada a dizer.

Kotlin é popular porque torna o Java mais eficiente e fácil para iniciantes, especialmente em plataformas móveis que não têm tempo para estudar seriamente a programação :-)

Mas o principal problema em C # (na plataforma .NET), bem como em Scala, Kotlin e em outras linguagens da JVM - permaneceu. Coletor de lixo, Carl, criando uma carga perceptível no servidor e interrompendo a execução do código por segundos sob requisitos de carga e glutão de RAM! E quantas outras linguagens com um coletor de lixo e compilação de jits não surgirão, esses problemas permanecerão e ainda não há esperança, mesmo na teoria.

Script

"Mas e o PHP?". Sim, agora vamos falar sobre scripts. Parece, por que ele está? Por volta do final dos anos 80, ficou óbvio que, se você precisar resolver rapidamente um problema usando código, não necessariamente rápido demais, e for seguro, sem comportamento indefinido e falhas de baixo nível, poderá escrever um script. Os scripts foram escritos antes, em bash, perl, awk, mas descobriu-se que em python você pode escrever scripts grandes, grandes, especialmente científicos, e por anos!

Lua encontrou seu nicho no gamedev e machine learning ( Torch ), JavaScript - no desenvolvimento da Web no lado do navegador e no servidor (eles ainda sabem que a autorização na infra-estrutura "npm" do Node.js. é reescrita no Node.js. Golang na ferrugem?). Python - em aprendizado de máquina e análise de dados, bem como em scripts de sistema. E PHP - lida perfeitamente com as tarefas do servidor para desenvolvimento na web.


As vantagens do script são óbvias:

• Código seguro e eficiente, sem comportamento indefinido e brechas de segurança de baixo nível, usando algoritmos e estruturas de dados populares (listas, dicionários, filas), é criado em literalmente minutos
• Um início muito rápido e uma curva de entrada suave. Demora vários dias para descobrir e escrever um script python útil, alterar a lógica do nginx por meio de scripts em Lua ou fazer integração de lojas online no PHP
• Se você escrever scripts de maneira disciplinada, observando o CodeStyle e o mais rigorosamente possível, poderá resolver rapidamente problemas complexos e criar grandes produtos de software: um grande número de bibliotecas científicas em python, sistemas de gerenciamento de negócios e sites em PHP, uma plataforma de rede neural Torch em LuaJit, scripts de jogos de maneira muito jogos famosos e populares, etc.
• Alguns tipos de programação multithread, onde E / S é o gargalo, são resolvidos com eficiência em python. E usando os recursos mais recentes de python com futuros como "assíncrono / aguardado", é ainda mais fácil resolver os problemas de processamento de um grande número de soquetes de rede
• Muito elegantemente, a tarefa de processar assincronamente um grande número de soquetes, mesmo sem multithreading, foi resolvida no Node.js imediatamente
• Crie páginas da web, use inúmeras bibliotecas unix, vá para o banco de dados ainda é fácil e conveniente usando PHP e produtos baseados nele
• Em python, PHP, JavaScript, é muito conveniente testar hipóteses e criar protótipos em horas, não meses
• Para análises e processamento de dados, é tradicionalmente muito conveniente usar o python / R em conjunto com um grande número de bibliotecas de alta qualidade (pandas, scikit-learn, seaborn, matplotlib ...)

No entanto, você não pode conhecer as possíveis desvantagens do script:

• Às vezes, um nível de entrada baixo e velocidade de script muito rápida, na ausência de controle adequado sobre os desenvolvedores, criam toneladas de código ineficiente e de difícil manutenção em qualquer plataforma
• A ausência de um compilador, sistema de tipos e tipagem estática requer uma verificação dinâmica de parâmetros passados ​​para funções e métodos para tipos e cobertura de código de alta qualidade com autotestes. Caso contrário, qualquer alteração no código pode interromper o programa e o cliente, e não o desenvolvedor, será o primeiro a saber (sim, eu sei sobre o TypeScript, mas são muletas e cataplasmas mortos)
• Objetiva e obviamente, em idiomas sem digitação e compilação estáticas, onde muitas coisas acontecem em tempo de execução, você não pode usar inúmeras otimizações e, portanto, em algumas tarefas, os scripts funcionam com ordens de magnitude mais lentas e consomem muitas vezes mais recursos. Apesar das tentativas de implementar a compilação jit em python (pypy), PHP (hhvm), JavaScript (tradução para código de máquina, wow, Node.js v8), LuaJIT - não nos enganemos: tudo isso parece muletas pouco eficientes. O motivo é, e deve ser entendido de uma vez por todas, que, devido à digitação fraca deliberada das linguagens, é improvável que os scripts consigam escrever um tempo de execução eficaz, aproximando-se rapidamente de Java / C # com muito mais força.
• E, em python, parece que nunca haverá multithreading eficiente, como em Java / C #, devido ao GIL

No entanto, desde na maioria dos aplicativos de negócios, incluindo sistemas de gerenciamento de sites, CRM, etc. Como a maior parte do tempo de execução do código é gasta em consultas ao banco de dados, a vantagem do jit Java / C # é profundamente nivelada pela velocidade de escrever soluções em PHP / python / JavaScript e, pessoalmente, para criar aplicativos da web, selecionarei 10 a 20 linhas no PHP que 10.000 strings e um monte de miúdos em Java / Spring. E o PHP7, de alguma forma, com overclock para rodar mais rápido que python3 ;-)

Que conclusão pode ser feita aqui? Não é necessário resolver todos os problemas, como agora é popular, apenas por script - em alguns casos, é razoável usar outra ferramenta mais adequada, se houver boas razões para isso:

• cargas de rede muito altas e multithreading "extremo", milhares - dezenas de milhares de soquetes de rede etc.
• restrição ao uso de RAM e hardware
• processamento e computação intensivos de dados, matrizes com milhões de entidades, GPUs (embora python / numpy / pandas possam ajudar aqui)

Muitas vezes, na empresa, praticamos essa abordagem:

• tome uma decisão rápida em PHP / python / JavaScript / Node.js, inicie a batalha e comece a resolver problemas do cliente
• gerimos funcionalidades, oportunidades, melhoramos serviços
• em casos raros, por experiência, geralmente não antes de alguns anos, alguns dos serviços já estáveis ​​em funcionalidade são reescritos em C / C ++ / Java / Golang / Rust

Portanto, é melhor começar, via regra, com scripts, iniciar uma batalha e, se você precisar diretamente, precisará pegar outras ferramentas e isso ocorre, geralmente muito suavemente e sem riscos.

Programação Funcional, Lisp, Haskell, F #

Muitos, durante toda a carreira de desenvolvedor, nunca vêm aqui, mas em vão. É extremamente útil entender por que o FP (programação funcional) apareceu e por que em algumas áreas é tão popular.

Vou explicar de forma simples. Existe um problema tão insolúvel em matemática como o "problema de parada" . Se você o colocar em palavras muito simples e bastante rigorosas, mas estiver claro, não será possível criar um algoritmo que prove que o programa funcionará sem erros. Porque Porque, inicialmente, as pessoas começaram a programar de forma agressiva e imperativa, usando:

• variáveis ​​mutáveis
• ciclos com condições
• efeitos colaterais

E eles começaram a cometer erros. Vemos isso agora, observando um grande número de bugs na Web e em aplicativos para desktop e dispositivos móveis. E não importa como você cubra o código com autotestes, os bugs ainda continuam vazando, se espalhando pelo chão e rindo.
Para parar esse pesadelo do surgimento de softwares de bugs e impiedosos, no final dos anos 50, surgiu uma direção da programação funcional e da linguagem Lisp . Agora, essa família de idiomas representa, mais ou menos adequadamente, Haskell .

Apesar do fato de que um grande número de possíveis erros no código são realmente eliminados devido a:

• tipos de dados algébricos e correspondência de padrões neles
• a ausência de ciclos (apenas por recursão) e variáveis ​​mutáveis ​​ao alcance de um braço estendido (é possível encontrar muletas sobre como contornar isso, é claro)
• digitação estática muito estrita e, ao mesmo tempo, saída automática muito conveniente dos tipos Hindley-Milner
• características muito poderosas, com a divisão em "puro" e "com efeitos colaterais", com possibilidade de uso parcial
• suporte de programação simultânea seguro
• suporte para combinadores através de mônadas para todas as ocasiões (mais sobre isso na seção Ferrugem)

Haskell «» — , , , : . Haskell «», , , , . Haskell .

, , — Haskell , , , Java/C#.

, . Haskell , , , , . , «» — Haskell .

«C/C++» — Golang, D

, , C/C++ (, Forth). C++ , , D ( — , ).

, - /C++ c RAII , . 2009 Google Golang .
, Golang , , , . Golang Java/C# ( ) , … , Golang:

• «green threads» ( ), python
• , , (, Docker ) :-)

. Node.js python .

, Golang , Google vs Sun/Oracle, , , , :-) , « Java/C#» , — . Docker Golang . Golang — Java/C#, , .


, , Swift , c « » . macOS.

— Rust!

, , 40-50 , , , «zero-cost» , , - - :-) , , (Java/C#), , (C/C++), -, — . , ?

— . , , , 50 , 2010 Mozilla Research. , :

• «zero-cost» ( C/C++ ), .. , , ------ « » (, , )
• cargo ,
• (* — ): , — « », , , ,
• , , ( , , GC , - runtime, )
• -, Null (!),
• Haskell pattern-matching , Enumeration (Golang, , )
• ( Java, )
• ( Golang — ; Java/C#/Erlang .. , )
• , ( C/C++)

, , -. ? ! , 50 . , , «» , , .

Rust «» , , Haskell .
Rust , , , Java :-) — Nulls, pattern-matching , generics traits . . , , , « Haskell», .

.

?

! , «» («ownership») . « » ( «lifetime», Rust book, ), ( , ).
/, . /, .
C++, - move-. , rust , .

zero-cost ?

, traits, . , , Golang. , , - pattern-matching, ( Golang, ). / . : . («borrowing»). , ( «read-write locks», ). , , , , .
slice , , , . — « » , , ; , .

:

• ,
• ( , )
• , ---,
• , , ,

, ( , ) … . / , C/C++ . .

, - , - . - , . Sync/Send, , : , , , .

, , 1-2 futures . , Node.js python async/await, , . , ?

unit

, unit . .

— cargo

Java, «Maven cargo » , : , . , , , .

Heap

, , heap. , , ( ) « » ( «lifetime»). , ( Swift). , — , heap . — , .

, , , . , (2 ) , , , , , AmazonWebServices c tls/ssl, .
, , , , , - . « » ( «lifetimes») .
, . IntelliJ rust , . Notepad++ — .

Rust

• Entenda que você realmente precisa escrever um código do sistema muito rápido, trabalhando sob altas cargas e consumindo um mínimo de recursos e sem sobrecarga, como um coletor de lixo. Caso contrário, escreva um script em python / PHP / Node.js e retorne à tarefa após 2-3 anos (em 97% dos casos, você não precisa retornar).
• Não tenha medo da ferrugem. O principal destaque da linguagem é um compilador muito inteligente e matematicamente rigoroso que NÃO PERCA código perigoso e incorreto. Por tentativa e erro, evitando cantos afiados, você aprenderá a programar usando o compilador de maneira estrita e segura :-)
• Comece a aprender o idioma com um " livro Ferrugem ". Um livro bonito e sexy, fácil de ler e divertido de ler. Mas é melhor lê-lo duas vezes, "resolvendo" todos os exemplos.
• O " livro de receitas da ferrugem " ajuda muito . Também é desejável "resolvê-lo" e ver como o código funciona, senti-lo.
• Há literatura sobre o Rust para usuários avançados, como o Rustonimicon , mas não recomendo me preocupar com coisas técnicas realmente complicadas desnecessariamente.

Entenda mais uma vez - para dominar a tecnologia, você precisa começar a escrever um código útil para a empresa. O compilador Rust é tão inteligente que oferece garantias (na verdade, é muito importante, o compilador C ++ não sabe como fazê-lo) e não compila código perigoso / com danos à memória, então experimente o quanto quiser e você obterá o código rápido e seguro e, ainda melhor, começará a programar: - )

Detalhes de implementação do projeto

Vou revelar um pequeno detalhe do projeto. O Amazon SQS derrama centenas de pacotes de dados por segundo. A fila é lida, analisada localmente pelos trabalhadores, cada mensagem é processada pelo broker e redirecionada para outro servidor externo. Existem vários servidores externos. Inicialmente, a solução foi implementada por meio de script: o script, iniciando um processo no sistema operacional, lendo mensagens, processado e enviado pela rede. Em vários servidores de ferro poderosos (8 núcleos, 16 GB de RAM), centenas de scripts foram lançados (em cada um!), Lendo simultaneamente no SQS, processando e enviando dados. Simples, confiável, mas a ingestão de ferro começou a incomodar. O custo do ferro estava aumentando constantemente.

O Rust usou principalmente bibliotecas e módulos padrão de carga:

• rusoto_sqs - para trabalhar com o Amazon Web Services, sem perguntas, funciona conforme necessário imediatamente
• ferrolhos - para tls, incl. interações com os serviços TLS do Google, Apple e o uso de certificados de clientes
• gancho de sinal - para interceptar kill e levar ao final da transação para enviar dados
• futuros, tokio-rustls - trabalho “preguiçoso”, multithread e assíncrono com soquetes TLS de rede, ala Node.js
• clap - analisando argumentos da linha de comando
• serde_json - formação json, nada de interessante aqui

Infelizmente, não foi sem o uso de blocos “inseguros” e “std :: mem :: transmute” - a biblioteca padrão não conseguiu encontrar ferramentas para analisar dados binários em árvores.

Principalmente, se você pode chamar assim, "plugging" aconteceu na compilação - as bibliotecas não foram compiladas no CentOS6 por causa do "assembler desatualizado" nos binutils, mas não houve problemas no CentOS7.

A impressão geral é que o desenvolvimento no Rust se parece mais com “scripts estritos” do que com a programação do sistema, não muito mais que o script ou o desenvolvimento da Web, tanto em termos de recursos quanto de teste. Nesse caso, compilação estática estrita, ausência de um coletor de lixo e tipos de dados algebricamente.

O sentimento geral é muito positivo. Ainda assim, em vez de vários servidores de ferro (8 núcleos, 16 GB de RAM), o problema começou a ser resolvido por um processo (com dezenas de threads) que consome não mais que 5 GB de RAM e cria uma carga não muito perceptível nos núcleos, com tráfego na região de 0,5-1 gigabits .

Conclusão

Bem, isso terminou um post longo, mas, esperançosamente, inspirador e útil sobre tecnologia eficaz. Agora você conhece outra ferramenta e pode usá-la com mais segurança, se necessário. Revisamos a história do desenvolvimento de linguagens de programação, seus recursos e capacidades e podemos ter tirado ou tirado as conclusões corretas. Boa sorte com seus projetos e bom, não, bom humor!

PS:
* - Sim, eu quase esqueci. Claro, você precisa falar sobre o bloqueio não seguro. Neste bloco você pode:

• programar coisas que não estão disponíveis em ponteiros comuns "sem referência à ferrugem" e fazer coisas mais potencialmente perigosas, às vezes necessárias na programação do sistema. Mas nem tudo é tão assustador:
• blocos inseguros são visíveis e não existem nenhum, ou o código responsável está concentrado neles
• A biblioteca padrão de ferrugem é exaustivamente testada, o que significa que acreditamos que blocos inseguros trabalham nela
• bibliotecas populares de carga também são exaustivamente testadas (tudo é incorporado para testes de unidade e integração em ferrugem) e, portanto, podem ser levadas e utilizadas

I.e. no bloco "inseguro", você não pode se envolver em deboche arbitrário, disponível em C - mas apenas em certos tipos estritamente de atividades perigosas. Portanto, você pode e deve dormir em paz :-)