Entrando na Indústria!!

Jan 04 2023
Olá pessoal, como estou começando minha carreira como desenvolvedor de software em fintech, tenho algumas percepções sobre como a codificação aqui é diferente dos meus projetos de faculdade/hackathon. Normalmente, quando trabalhamos em projetos pessoais, eles são pequenos protótipos de nossos pensamentos.

Olá pessoal, como estou começando minha carreira como desenvolvedor de software em fintech, tenho algumas percepções sobre como a codificação aqui é diferente dos meus projetos de faculdade/hackathon.

Normalmente, quando trabalhamos em projetos pessoais, eles são pequenos protótipos de nossos pensamentos. Mas, à medida que trabalhamos em projetos de grande escala, além de escrever lógica de negócios / implementar algoritmos de estrutura de dados, há outras áreas em que nosso código trava e pode ser frustrante resolver esses problemas.

Mesmo que alguém seja bom em codificação e algoritmos, ter uma ideia geral do sistema leva a uma experiência mais suave. Algumas práticas em que se pode fazer um brainstorming como calouros são-

Desenvolvimento Orientado a Testes

Essa abordagem pode ajudá-lo a escrever um código limpo, que é uma obrigação da indústria hoje em dia. Em cenários onde há uma compensação entre O(N) + código limpo v/s O(logN) código algorítmico, geralmente, as pessoas tendem a aceitar códigos mais limpos e legíveis.

  • Como calouros, tendemos a refatorar nosso código depois de ver casos de teste com falha em Leetcode/CodeChef/IB ou qualquer outra plataforma de codificação, por exemplo, mas ao trabalhar em um projeto, alterar o código ao encontrar bugs durante o controle de qualidade pode levar a um código confuso e ilegível. Ter discussões de ponta a ponta com gerentes de projeto de antemão, definindo todos os casos de ponta/teste para o recurso e definindo várias entradas/saídas das funções que você vai escrever, pode ajudar na construção de uma melhor compreensão e habilidades de colaboração entre equipes, reduzindo bugs e melhorando seu tempo de capacidade de entrega.
  • É claro que não escrevemos UTs em todos os lugares da indústria por causa de sua complexidade adicional e prazos rígidos, mas mesmo ter um projeto bruto no papel antes de iniciar a codificação eventualmente leva a um código mais limpo com poucos bugs.
  • Além disso, escrever UT protegerá seu recurso de ser quebrado devido a desenvolvimentos futuros.

Quando entramos em uma nova empresa, queremos entrar na codificação e nos projetos o mais rápido possível para criar um impacto e ignorar a importância de gastar algum tempo aprendendo sobre a estrutura que a empresa está usando e aprimorando o básico.

Gastar um ou dois dias criando conhecimento de ponta a ponta sobre a estrutura e seus métodos/práticas de injeção de dependências. Geralmente, não tendemos a ver a ordem ao injetar módulos ou o número de módulos que estamos injetando e perdemos pequenos detalhes, tornando-nos mais propensos a encontrar problemas como dependências circulares e problemas de diamante. Isso pode ser frustrante de resolver nos primeiros dias de trabalho com a nova estrutura.

Por exemplo, em Nest.js é uma boa prática importar módulos em vez de serviços, pois você aumentará suas chances de erros

Depois de passar pelos logs, pode-se ir para o RootTestModule apenas para descobrir que todos os serviços são importados para lá e, portanto, ficar confuso. Esse problema de dependência circular pode ser facilmente corrigido usando forwardRef() , mas se você quiser praticar um código limpo, tente evitar tais práticas de codificação.

PS - Eu errei muito enquanto escrevia AWS Lambda uma vez. Injeções indesejadas podem levar a tempos de inicialização elevados e, portanto, aumentar os custos e o tamanho do servidor. Este artigo da amazon AWS para lambdas é uma boa leitura para saber como evitar contratempos de injeção de dependência, o que leva a melhores otimizações de desempenho. Embora seja específico para Lambdas, você pode consultar isso para ter uma visão geral e entender a importância.

Manipulação de erros

Erros sem cache podem levar a grandes bugs que podem ser difíceis de detectar durante o controle de qualidade também.

A implementação de um wrapper de erro personalizado na camada do controlador pode ser benéfica a longo prazo. Você pode ter vários wrappers diferentes para diferentes tipos de erros, como erros de validação, erros de servidor e erros em operações de rede, podemos precisar de HTTPError, para operações de banco de dados DBErrors e assim por diante.

Em JavaScript, temos uma classe Error integrada

Error {
  constructor(message) {
    this.message = message;
    this.name = "Error"; // (different names for different built-in error classes)
    this.stack = <call stack>; // non-standard, but most environments support it
  }
}

export class ServerError extends Error {
    serverMessage: ServerMessages;
    statusCode: number;
    context: Record<string, string>;

    constructor(
        errorCode: ServerMessages,
        message: string,
        statusCode = 500,
        context: Record<string, string> = {},
    ) {
        super(message);
        this.name = ServerError.name;
        this.serverMessage = errorCode;
        this.statusCode = statusCode;
        this.context = context;
    }
}

  1. Sempre pegue seus erros.
  2. Evite lançar erros da parte do código que está funcionando de forma assíncrona após a conclusão da solicitação.

Como estamos atualmente dimensionando nossos sistemas, estamos procurando por diferentes plataformas/ferramentas para monitorar nosso sistema e estou ajudando com uma coisa que posso dizer com certeza é que este é um outro domínio que pode ser explorado. Ter a oportunidade de configurar painéis e alertas de monitoramento de APM ou Infra me ajudou a entender melhor a arquitetura.

P S — Não estou fornecendo detalhes aqui, pois alguns artigos interessantes sobre minha jornada neste domínio estão chegando, fique ligado!!

Base de dados

Não apenas escrever consultas e conhecimento básico sobre DBMS ( Relacional e Não Relacional ), mas conhecer as melhores práticas é uma obrigação. Alguns pontos a serem considerados ao escrever o código podem ser -

  • Seguir as práticas de segurança — Se você tiver algum dado PII com uma criptografia de camada de aplicativo, é uma boa ideia. Caso contrário, tente evitar a exposição de dados confidenciais a pontos de extremidade abertos. Seguir a arquitetura de 3 camadas e sempre implementar uma camada DAO/Banco de dados ajuda na flexibilidade para casos em que você deseja alternar ou usar vários bancos de dados.
  • Monitorando o desempenho da consulta — Sempre escreva consultas indexadas, escrever consultas em campos não indexados é um grande NÃO quando se trata de análise e monitoramento de desempenho.
  • Ter informações básicas sobre possíveis requisitos de camada superior, como um banco de dados na memória . ou seja, Redis.

Algumas perguntas para fazer aos seus desenvolvedores seniores —

Como estamos hospedando nossos serviços para os clientes?

Quais são todos os pipelines de código que você tem e quais práticas de implantação usamos?

Por que estamos usando isso?

Quais são as outras alternativas disponíveis?

Escrevendo Código Genérico

Tente escrever seu código o mais geral possível. Para um exemplo simples, você deseja escrever um código para encontrar a distância hamming entre duas strings.

export function hammingDistanceBetweenTwoStrings(
    str1: string,
    str2: string,
    comparator: (arg0: string, arg1: string) => boolean,
): number {
    const minLengthAmongTwo =
        str1.length < str2.length ? str1.length : str2.length;

    let diffCharacters = 0;
    for (let i = 0; i < minLengthAmongTwo; i++) {
        const isDifferent = str1.charAt(i).localeCompare(str2.charAt(i)) !== 0;
        if (isDifferent) diffCharacters++;
    }

    return (
        diffCharacters +
        (str1.length - minLengthAmongTwo) +
        (str2.length - minLengthAmongTwo)
    );
}

Mas e se escrevermos de forma mais genérica passando uma função de comparação aqui também? Um caso de uso simples pode ser o que acontece se alguém quiser encontrar a distância hamming com uma string que não diferencia maiúsculas de minúsculas no futuro?

export function hammingDistanceBetweenTwoStrings(
    str1: string,
    str2: string,
    comparator: (arg0: string, arg1: string) => boolean,
): number {
    const minLengthAmongTwo =
        str1.length < str2.length ? str1.length: str2.length;

    let diffCharacters = 0;
    for (let i = 0; i < minLengthAmongTwo; i++) {
        const isDifferent = comparator(str1.charAt(i), str2.charAt(i));
        if (isDifferent) diffCharacters++;
    }

    return (
        diffCharacters +
        (str1.length - minLengthAmongTwo) +
        (str2.length - minLengthAmongTwo)
    );
}

Espero que este artigo o ajude a codificar melhor, cumprir seus prazos e arrasar em seu espaço de trabalho.

Há muito mais para saber, mas isso é o que descobri no ano passado. Como explorei um pouco cada uma dessas seções, tentarei escrever mais sobre cada uma dessas estruturas/ferramentas detalhadas que estamos usando e seus prós e contras. Então fiquem ligados pessoal.