Entrando na Indústria!!
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;
}
}
- Sempre pegue seus erros.
- 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.





































![O que é uma lista vinculada, afinal? [Parte 1]](https://post.nghiatu.com/assets/images/m/max/724/1*Xokk6XOjWyIGCBujkJsCzQ.jpeg)