Refletindo sobre a Evolução na Programação
Lembrando do início de nossa jornada no mundo da programação, fomos descobrindo aos poucos que não bastava o código ser apenas funcional. O que queremos dizer com isso? Inicialmente, quando estávamos aprendendo a programar, acreditávamos que apenas o funcionamento do código, ou seja, ele cumprir as funções que tínhamos em mente, era suficiente para que aquele código fosse considerado bom. Mas, com o tempo, percebemos que o software era dinâmico e exigia adaptações durante seu ciclo de vida. Essas adaptações eram ocasionadas por inúmeros fatores.
Uma primeira possibilidade era uma mudança de contexto de uso. Com o passar do tempo, algumas necessidades que aquele software atendia já não faziam mais sentido no novo contexto de mundo e tecnologia. Tudo aquilo que foi desenvolvido e que funcionava bem em um primeiro momento não fazia mais sentido no presente, e o software teria que passar por adaptações.
Lidando com Mudanças e Desempenho
Outro motivo que gerava a necessidade de alteração do software eram as alterações de serviços externos. Muitas vezes, utilizávamos uma API, que é uma interface de software desenvolvida por terceiros e suscetível a alterações. Quando a API mudava, era necessário fazer adaptações no software para acompanhar essa mudança.
Também era comum a necessidade de implementação de novas funções e de execução de novas tarefas pelo software. Por fim, outra questão que gerava necessidade de adaptações era a necessidade de maior desempenho. Muitas vezes, alguns dos módulos desenvolvidos precisavam ser otimizados para executar mais rápido e fornecer uma experiência de usuário mais interessante.
Questionando a Confiabilidade da Memória
Pensando em todas essas necessidades de alteração, podemos fazer alguns questionamentos. Será que nossa memória é uma fonte confiável de informação? Será que podemos confiar que, daqui a meses ou anos, conseguiremos lembrar o que fizemos? Conseguiremos fazer as alterações necessárias, sabendo onde está cada elemento no código? A resposta que encontramos em nossa jornada foi que não dá para confiar apenas na memória. Precisamos ter uma organização do nosso código para que a atividade de manutenção seja facilitada ao longo do tempo.
Outro ponto que percebemos ao longo dessa jornada, e que fica também como um questionamento, é se as alterações que fazemos no nosso software podem afetar partes não correlatas. Ou seja, é possível que, ao fazermos uma atualização do nosso software ou uma inclusão de funcionalidade, todas as outras partes permaneçam funcionando corretamente? Essa é uma questão crítica no desenvolvimento de software. É importante que, enquanto estamos desenvolvendo, tenhamos a garantia de que o software como um todo não deixará de funcionar porque incluímos uma nova funcionalidade.
Explorando Arquiteturas de Software
Por fim, qual foi a arquitetura que usamos enquanto estávamos desenvolvendo? Nos momentos iniciais, não pensávamos em arquitetura. Mas é importante frisar que arquiteturas não estruturadas ainda são formas de arquitetura. Ou seja, mesmo quando não tínhamos noção de arquitetura, já tínhamos um planejamento em mente. Já tínhamos pensado no que o software precisava fazer e, para a implementação, pensávamos no código para que ele executasse aquela função. Se o código está funcionando, ele tem uma certa forma de arquitetura. A diferença é que essa arquitetura pode estar estruturada ou não estruturada. A intenção é que, em nosso desenvolvimento, foquemos nas arquiteturas estruturadas para que possamos obter todas as vantagens que elas podem trazer.
Assim, como dissemos inicialmente, aquela noção de que o código não deve ser só funcional pode ser resumida na frase de que o código deve ser funcional e sustentável. Ou seja, ele tem que funcionar não só no presente, mas também no futuro. Ele tem que ser sustentável. Precisamos trabalhar na estruturação de forma que a manutenção desse software e a inclusão de funcionalidades sejam possíveis no futuro também. Para avaliar nosso código e nossa arquitetura, podemos pensar em diferentes formas.
Teoria sobre Avaliação de Arquitetura
Vamos apresentar agora um pouco de teoria relacionada à avaliação de arquitetura, começando pela modularidade. A modularidade vem de módulos, que podemos entender como partes componentes do software. Em uma arquitetura bem estruturada, é interessante que o software seja dividido em partes. Mas por que dividir em partes? Primeiramente, isso facilita a identificação de onde está cada elemento do software. Por exemplo, se temos uma parte do software responsável pela interface, todas as alterações dessa parte serão feitas naquele módulo específico, facilitando o entendimento.
Essas partes do software têm uma relação entre si, sendo necessário que se comuniquem e interajam durante a execução do algoritmo para que a função final seja executada. Uma forma de medir o nível de conexão entre essas partes é pelo acoplamento. Dizemos que dois módulos são altamente acoplados quando estão muito correlacionados, dificultando o uso separado. Por outro lado, com baixo acoplamento, conseguimos utilizá-los separadamente e, às vezes, até para outras funções, facilitando o reuso de código.
Vantagens dos Critérios de Arquitetura
Utilizar esses critérios na elaboração da arquitetura traz várias vantagens. Primeiramente, permite a escalabilidade, possibilitando o desenvolvimento e a adição de novas funcionalidades por meio da agregação de módulos. Caso haja necessidade, podemos incluir funcionalidades no software simplesmente adicionando novos módulos ou separando cada módulo de maneira coesa.
Além disso, facilita a manutenção. Podemos adicionar novas funcionalidades e alterar as antigas com mais facilidade em um código modularizado, permitindo alterações apenas na parte do software que precisa ser atualizada.
Outro ponto é a testabilidade. Ao separar em módulos, conseguimos testar cada um individualmente. Por exemplo, se tivermos uma aplicação que valida um CPF no cadastro e no sistema de pagamentos, podemos modularizar a função de validação de CPF, reaproveitando o código tanto na parte de cadastro quanto na de pagamento. Mais do que isso, conseguimos testá-la isoladamente. Criamos uma interface que permite a comunicação com outros módulos do sistema, e essa interface pode ser acoplada a um módulo de teste para realizar testes automatizados.
Por fim, a reutilização do código é uma vantagem, como no exemplo do CPF, que pode ser reaproveitado em mais de um trecho do código. A clareza e organização também são beneficiadas, facilitando a localização dos elementos e favorecendo o trabalho em grupo.