Esse é o primeiro post de uma série onde serão abordadas as novas funcionalidades da versão 8 do C#. 

Começaremos por uma funcionalidade chamada Nullable Reference Types, que permite ao desenvolvedor evitar os conhecidos NullReferenceException. Esse tipo de erro ocorre quando tentamos acessar um membro em um tipo cujo valor é null ou sem instanciar o objeto previamente. 

Esse problema pode aparecer por descuido ou inexperiência na linguagem, mas agora  podemos identificar esse problema durante a codificação e não mais na hora de testar ou pior, em alguns casos, em  produção.

Abaixo temos os principais métodos deste exemplo. O código completo pode ser baixado aqui.

public static string ExibirDadosAluno(Aluno aluno)
        {
            return 
$"Nome: {aluno.Nome} 
Sobrenome: {aluno.Sobrenome[0]}., 
Idade: {aluno.Idade}";
        }

public static IEnumerable<string> ListarAlunos(IList<Aluno> alunos)
        {
            foreach (var aluno in alunos)
            {
                yield return ExibirDadosAluno(aluno);
            }
        }

O método ListarAlunos itera sobre uma coleção e exibe os dados de cada um dos alunos no formato {Nome} {S.}, {Idade}. Ex.: Fernando F., 38.

Para exibir apenas a primeira letra do sobrenome, utilizamos a sintaxe aluno.Sobrenome[0]. Ao executar esse código, teremos o erro da figura abaixo, pois estamos tentando acessar um valor null.

O contexo #nullable

Agora podemos dizer ao compilador que estamos trabalhando com tipos que podem ser null e deixar que ele nos alerte sobre potenciais problemas. Para isso vamos submeter nosso código a um contexto de tipos anuláveis. Para fazer isso, basta inserir #nullable enable no início do arquivo.

Para fins didáticos, a classe Aluno – Imagem 3 – foi deixada no arquivo principal, portanto esta também faz parte do contexto, que verifica o arquivo completo em busca de inconsistências.

A parte legal começa agora, podemos notar que o construtor está sinalizado por um alerta, informando que há um membro não inicializado que este poderá causar problemas no futuro.

P.S. Por se tratar de um alerta, este também também aparece na janela de erros (Error List).

Vamos inicializar esta propriedade e ver como se comportará nosso código.

Nesse caso estamos associando um null para um tipo que não aceita este valor. Agora marcaremos a propriedade “Sobrenome” com o símbolo “?” para que esta possa receber null, conforme imagem abaixo:

Note que após os devidos ajustes terem sido feitos, ainda temos um alerta para tratar no método ExibirDadosAluno.

Esse alerta informa uma possível “desreferência” de null, ou seja, o compilador está nos avisando que em algum momento a referência desta propriedade pode se tornar null. Neste caso, basta que façamos um tratamento condicional no retorno do método.

Assim podemos evitar aqueles bugs bobos e indesejados que podem nos trazer muita dor de cabeça, pois quando eles ocorrem, são nos piores momentos.

É possível também configurar a verificação de tipos nulos para todo o projeto, para isso é preciso adicionar a linha destacada no arquivo “.csproj”, conforme a imagem 9.

O operador “!”

Este operador serve para dizer ao compilador que você tem certeza do que está fazendo. O que isso significa? Significa que quando você receber um alerta de uma possível “desreferência” – situação em que o retorno poderá ser null e sem um tratamento adequado – e você quiser inibir este alerta, basta colocar o operador “!” – sem aspas – imediatamente após a propriedade e/ou campo que retornará o valor.

Lembre-se que maiores poderes carregam consigo maiores responsabilidades!

Cada vez mais a web se torna uma plataforma de serviços ao passo que necessitamos estar conectados para que possamos fazer o uso destes. A grande maioria dos serviços hoje são hospedados na nuvem e a comunicação entre a aplicação e o serviço é extremamente crítica neste cenário. Os servidores que oferecem serviços de nuvem são servidores de alta disponibilidade e robustos o suficiente para minimizar ao máximo uma possível paralisação. Porém o caminho até um servidor pode não ser tão estável assim, visto que há outros recursos durante o percurso que podem impactar a utilização de um serviço, como infra interna da empresa e a operadora por exemplo.  Diante deste cenário, cada vez mais é exigido que as aplicações consigam lidar com esta instabilidade e garantam uma responsividade (capacidade de dar repostas) aceitável num cenário que pode ser imprevisível. 

Contexto 

Existem certos tipos de erros em uma aplicação que são momentâneos, são chamados erros Transientes. Estes erros, ou falhas, como ficar melhor, são devido a diversos fatores externos à aplicação e que muitas vezes não são previstos no desenvolvimento. Se um serviço torna-se indisponível por um certo tempo, a aplicação deveria saber tratar este problema. É comum fazer o acesso aos serviços dentro de um bloco Try catch para tratar uma possível falha. Porém, como já vimos, existem erros que são momentâneos, e nesse caso uma nova tentativa teria grande chance de obter sucesso. Simplesmente “empacotar” uma chamada de um serviço dentro de um bloco Try catch apenas impede o erro de “quebrar” a aplicação e uma abordagem mais reativa cairia bem nesses cenários. 

O padrão conhecido como Retry Pattern vem ao encontro dessa abordagem e permite que a aplicação converse com os serviços de uma forma mais responsiva num cenário de instabilidades.  

Para implementar esse padrão, deve-se levar em consideração a natureza da falha em questão, pois nem sempre tentar novamente é o procedimento apropriado naquele momento. Podem haver casos em que simplesmente abortar a operação é o mais indicado.  Para identificarmos qual será a abordagem a ser seguida, vamos considerar o seguinte: 

• Falhas que indicam não ser transitórias: falhas na autenticação ou dados inconsistentes por exemplo, devem ser abortadas após uma tentativa malsucedida, pois reenviar a mesma solicitação provavelmente não implicará num retorno bem-sucedido. 

• Falhas pouco comuns ou raras: em situações como esta, onde a falha ocorrida é incomum ou raramente acontece, tentar novamente é uma boa abordagem, pois é muito pouco provável que esta volte a ocorrer em uma nova tentativa, dada sua natureza rara. 

• Falhas recorrentes (problemas de conexão ou ocupado): essas são falhas em que uma nova tentativa provavelmente resultará em um retorno bem-sucedido, isso porque esses tipos de problemas são instabilidades momentâneas e por serem de natureza esporádica, a chance de sucesso aumenta muito em uma nova tentativa. 

Use com parcimônia 

Se o problema por exemplo for relacionado a uma sobrecarga no servidor, fazer uma nova chamada pode agravar ainda mais a situação. Isso fará com que o servidor leve mais tempo para normalizar seu funcionamento. Então como lidar com essas situações? O Gmail implementa uma forma bem interessante de resolver isso, se você estiver off-line e tentar atualizar seus e-mails, suas tentativas terão intervalos cada vez maiores. Essa abordagem de intervalos maiores ou exponenciais permite que outras requisições sejam finalizadas antes de um nova tentativa, garantindo assim que o servidor não seja sobrecarregado por inúmeras requisições em um curto espaço de tempo. Não esqueçamos também de sermos cuidadosos com a quantidade de vezes que essa requisição será solicitada, até que atinja um limite. Limites altos, podem fazer com que a aplicação sobrecarregue ainda mais o servidor que ainda não restabeleceu o serviço, acarretando em um problema ainda maior. 

Modelo de implementação 

O modelo consiste em tentativas sucessivas de requisições em caso de falha. O diagrama abaixo mostra o fluxo das requisições. 

Exemplo 

O exemplo abaixo faz o download do conteúdo de uma página e retorna a string correspondente à estrutura da página. Foram utilizadas as rotinas assíncronas do .NET (async e await), porém isso não se faz obrigatório. Existem diversas formas de implementar esse padrão, inclusive existem bibliotecas prontas para isso, um bom exemplo é a Polly.  

Obs.: Tratamentos na saída do resultado foram desconsiderados.

    class Program
    {
        private static int _maxTentativas = 3;
        private static readonly TimeSpan _delay = TimeSpan.FromSeconds(5);

        public static string DownloadContentFromWeb()
        {
            var client = new WebClient();
            return client.DownloadString("http://www.microsoft.com");
        }

        public static async Task<string> DownloadContentFromWebWithRetry()
        {
            int _tentativaAtual = 0;
            var client = new WebClient();
            var conteudo = string.Empty;

            for (; ; )
            {
                try
                {
                    conteudo = await client.DownloadStringTaskAsync("http://www.microsoft.com.br");
                    break;
                }
                catch (Exception ex)
                {
                    Trace.TraceError(ex.Message);
                    _tentativaAtual++;

                    if (_tentativaAtual > _maxTentativas)
                    {
                        throw;
                    }
                }
                await Task.Delay(_delay);
            }
            return conteudo;
        }

        static void Main(string[] args)
        {
            Console.WriteLine(DownloadContentFromWebWithRetry().Result);
            Console.ReadKey();
        }
    }
}

O código acima define alguns valores inciais como número máximo de tentativas e o tempo de espera entre cada tentativa. Todo o processamento ocorre dentro de uma estrutura de repetição for. Se o resultado chegar na primeira tentativa, o comando break interrompe o laço e retorna o valor, do contrário, este cairá na captura da exceção, incrementa a variável que controla a tentativa atual e em seguida verifica se o número máximo de tentativas foi atingido. Se ainda não foi, a task aguarda o delay para a próxima tentativa.  

É um processo bem simples que mostra uma forma resiliente de deixar uma aplicação mais responsiva na hora de lidar com possíveis falhas que possam vir a ocorrer. 

Fonte: Microsoft Docs 

O conteúdo deste artigo é uma tradução do original escrito por Abner Coimbre que pode ser conferido aqui. Ao final do texto há mais referências sobre ele bem como seus contatos. O texto traz algumas premissas utilizadas pela NASA no desenvolvimento dos seus softwares e na sequência algumas considerações do próprio autor sobre o mundo do desenvolvimento de softwares

Desde já agradeço ao Abner por ter permitido esta tradução.

Nearly an hour after launch, contrails from the lift-off of US space shuttle Atlantis float above the Vechicle Assembly building 08 June, 2007 at the Kennedy Space Center in Florida. The shuttle is on an 11-day mission to the International Space Station. (Photo credit should read TIM SLOAN/AFP/Getty Images)

O Mundo do software moderno

Existe um tema recorrente na comunidade de desenvolvimento que está associado a encontrar “melhores formas” de escrever “software moderno”.  Se o termo “moderno” é ou não realmente útil – programação de computadores é relativamente nova –  eu definitivamente sigo com a impressão de que sempre há algo novo ou melhor para falar. Então, se nós prestarmos atenção nos temas abordados no desenvolvimento de software hoje, rapidamente perceberemos o quão importante é separar o joio do trigo: o que é útil e o que não é.

Dada toda essa conversa sobre software moderno, eu tenho visto programadores iniciantes perguntando o que eu penso ser a questão mais importante das suas carreiras: “No que devemos prestar atenção?”, e honestamente, é um pouco cruel encorajá-los a seguir com:

• POO deve ser o futuro da programação?
• Vamos nos juntar ao Rust Evangelism StrikeForce
• Go é muito melhor que qualquer <language_with_other_design_goals>?

Pelo menos, não é assim que a NASA se posicionou para responder quando esta pergunta foi feita. A história da agência é bem conhecida, sabemos que o programa espacial pode sofrer consequências irreversíveis se alguns dos seus softwares tiver problemas, podendo ser fatal. O choque de realidade permitiu-lhes desenvolver certas atitudes a respeito do seu modelo de desenvolvimento. Vale a pena conferir o que eles têm valorizado.

Com alguns anos de trabalho lá, gostaria de apresentar em primeira mão a filosofia de trabalho que permitiu a agência espacial produzir alguns dos softwares mais confiáveis do mundo e irei elencar suas atitudes em relação a programação num conjunto de quatro premissas que eles praticam na sua força de trabalho (e que eu vivenciei diretamente).

As quatro premissas da NASA 

• Você terá acesso a um mentor.

Quem é seu mentor? É um quebra gelo comum com qualquer programador da NASA graças ao seu compromisso de garantir que todo programador possa ter um mentor. Isto poderia ser no nível de negócios, com o programa OSBP’s Mentor-Protégé, com o projeto interno NEXT ou com o Pathways Agency Cross-Center Connection (PAXC). Curiosamente, você não precisará sair procurando por um porque todos nós temos nossos mentores pessoais desde o início. A ideia de que um programador não pode ter alguém com uma experiência sênior para acompanhar seu progresso é descartada no programa espacial.

• Nós confiamos no potencial de cada um

Existe um razoável grau de confiança quando você entra em uma equipe, devido as investigações de antecedentes a que você é submetido. Também assumimos que cada um tem algum valor para oferecer e nós confiamos no potencial do indivíduo. Mostre que você é bom e o título se torna quase sem sentido. Não é incomum um estagiário contribuir com projetos de software de alto nível da NASA.

• Você dirá “Eu não entendo”

Esta declaração é dita a todo momento. Você verá desenvolvedores experientes perguntando para estagiários “Eu não entendo essa parte do código, é um novo recurso da linguagem que eu ainda não conheço? ” ou gerentes perguntando para engenheiros “Eu não tenho certeza das implicações do seu trabalho neste momento. Poderíamos rever mais algumas vezes até que eu tenha uma boa ideia disso? ” Estas são questões que fazem parte da rotina de trabalho.

• Nós valorizamos Insights sobre como os sistemas computacionais funcionam

A NASA procura incessantemente por novas descobertas sobre os o funcionamento dos computadores, o valor desta procura está em conhecer as limitações dos sistemas para prevenir decisões ruins no desenvolvimento de softwares.

Considere Gene Amdahl. Ele foi um dos pioneiros da computação com uma interessante questão: Qual é a eficácia de melhorar um componente de um sistema? Digamos que 50% do tempo de execução do seu programa foi melhorado por apenas um fator dos quatro existentes e agora queremos saber o quão rápido a aplicação está. Em outras palavras, algo consumiu o tempo T1 para executar até o fim, agora uma parte desse algo (que consumiu uma fração f de T1) é k vezes mais rápida. Pouparei de você alguns cálculos, embora seja muito simples – definir o novo tempo T2 e expressar a melhora relativa de performance como uma razão de T1 e T2. Você terá a seguinte equação:

Continuando com o exemplo anterior para saber o quão rápido sua aplicação está,vamos aplicar na fórmula:

O resultado é 1,6. Embora você tenha otimizado para ser quatro vezes mais rápido, no geral o sistema é somente 1,6 X mais rápido. Vamos ainda mais longe. Digamos que você melhorou algum outro componente e o tempo que este leva para rodar é agora zero (k tende ao infinito). Você agora tem um tipo especial da lei de Amdahl.

Suponha que o componente responda por 60% do tempo de execução do seu sistema, e agora não consome tempo algum para executar. A velocidade máxima teórica é de 2,5… a lei de Amdahl nos diz que para melhorar significantemente a velocidade de execução, teremos que melhorar uma grande fração disso. Pura verdade, mas facilmente esquecida. A lei é usada frequentemente na computação paralela para prever acelerações utilizando processadores de vários núcleos e Julian Browne reformulou ela no seguinte contexto: “Essencialmente a lei afirma que enquanto um processador pode trabalhar com fluxos que podem então rodar em paralelo, o tempo tomado pelo processo inteiro será significativamente limitado pelos fluxos que restam sequencialmente”. Ver Artigo sobre a Lei.

Com estas suposições em mente, o resto do artigo fornece uma visão mais pessoal sobre as lições que poderiam ser aprendidas.

Evitar fontes de conhecimentos duvidosas

Alguns dos meus amigos concordam que a atividade de programar ainda precisa amadurecer, pois ela estaria no estágio pré-científico da sua existência. Eu diria que muitos de nós estamos aderindo subconscientemente a fontes tradicionais de conhecimento que tem se provado duvidosas, e posso dizer que a NASA tem feito um bom trabalho para se proteger contra isso.

Fé

Eu não quero dizer fé no sentido de esperança. Fé também é compreendida quando nós queremos acreditar em algo sem que tenhamos bons motivos para acreditar. Vejamos um exemplo:

Lead: “Gosto das novas funcionalidades das aplicações para nossos usuários, mas você disse que baixou uma biblioteca para escreve-las. ”

Junior: “Sim. Funcionaram muito bem. ”

Lead: É código aberto? De qualquer modo, quem é o fornecedor e como é o suporte que eles oferecem?

Junior: “Não é, mas eu tenho usado ela e por enquanto não tive nenhum problema. ”

Lead: *PLONK*

Isto acontece não apenas para downloads aleatórios, mas quando seu código não estava funcionando e então magicamente ele funcionou e você resolve utiliza-lo um dia. Pode ser difícil perceber quando alguém está confiando na fé para decidir o quão bom é o seu software, mas se isso se prolongar por muito tempo, o resultado será um software lento de cheio de bugs.

Revelação

Por revelação, quero dizer quando uma figura de autoridade revela algo como incontestavelmente verdadeiro, ou algum fato que tem sido transmitido até hoje, e você acredita ser verdade simplesmente porque se acredita ser verdade. Se você associar isso com a necessidade de as pessoas se identificarem com algum assunto aleatório da comunidade de programação, vai descobrir que essa é a causa raiz de discussões calorosas sobre qual editor de textos reina supremo e se a linguagem que usa faz de você um verdadeiro programador.

Carisma

A conferência está repleta com uma atmosfera de euforia, empolgação para o anúncio do que virá a ser o próximo framework. Um palestrante empolgado chega ao palco com uma voz altissonante.  A fala e os slides discorrem sobre os mais novos princípios que prometem práticas de programação a prova de balas – do tipo que fará de você um programador 10X melhor. Com uma habilidade natural para interagir com a plateia e conduzir muito bem o tema da palestra, pode ser difícil de perceber que passamos a acreditar em suas afirmações, e o mais importante, comprando seus livros.

Brilho

Percebo que esta é uma palavra estranha para usar, mas quando uma ideia é atraente e empolgante o suficiente isto parece dar um certo “brilho”.  É “brilhante” e, portanto, deve ser verdadeiro. Poderíamos continuar, mas afastar-se desse tipo de desejo (ou sentimento) é o que significa ser científico sobre o nosso progresso tecnológico.

Expanda seus conhecimentos na área

Uma conversa sobre a natureza do universo geralmente é mais interessante quando as pessoas envolvidas são pessoas cientificamente alfabetizadas. Igualmente, uma conversa sobre programação beneficia a todos elevando a um certo patamar os seus conhecimentos. De fato, existem conhecimentos já bem difundidos sendo utilizado em novos sistemas computacionais, e os programadores deveriam estar atentos a isso.  Se nos intitulamos profissionais, temos uma grande responsabilidade em aprender os conceitos fundamentais da computação. Isso nos protege de fontes de informação não confiáveis e nos mostra aquilo de devemos prestar atenção. A NASA percebeu isso e garantiu que a cultura da organização seja capaz de expandir rapidamente seus conhecimentos.

Recomendações

Alguma coisa lhe chamou a atenção? Você é um programador procurando melhorar seus conhecimentos? Se for, eu tenho algumas sugestões pessoais.

Computer System’s: A Programmer’s Perspective: Foi muito importante na minha carreira, e para constar, este é meu conteúdo favorito de programação. Os temas apresentados aqui são os fundamentos que eu acho que todos deveriam ter. Pelo menos um estudo mais aprofundado dos capítulos 1-3, a hierarquia de memória e os sistemas de entrada e saída são excelentes. Se você está trabalhando em qualquer coisa relacionada a web, é claro que o capítulo sobre redes é de extrema importância.

Encontrando pessoas com o mesmo interesse

Existe uma pequena comunidade chamada Handmade Network, essa comunidade possui um time incrível (eu faço parte do time) onde tentamos construir um lugar em que evitamos conversar sobre softwares modernos, em vez disso, falamos sobre coisas que eu citei aqui. Assim como em qualquer comunidade, somos passíveis de cair em um dogma (já aconteceu no passado) mas estamos cientes disso.

Na comunidade também há entrevistas com programadores conhecidos discutindo diversos assuntos independentemente de nossas ideias. Confira algumas aqui.

Blogs/sites relacionados:

• Reddit (2017)
• KillScreen Op-ed (2016)
• Hacker News (2015)
• Reddit (2015)
• JAXenter (German) (2015)

Abner Coimbre foi um estagiário do Kennedy Space Center no ano de 2015 e no ano de 2016 foi nomeado como Kennedy’s 2016 top 10 innovators. Onde encontra-lo: Twitter, Twitch ou e-mail.