Permitir o uso de sistemas externos reais, como bancos de dados e serviços Web, em testes unitários, o que também permite reproduzir ambientes de execução realistas e melhorar a cobertura dos testes. 

Gerar dados de teste aleatorizados em cada execução, de modo a aumentar a variabilidade dos dados de entrada e, dessa forma, melhorar a confiabilidade, cobertura e robustez dos testes unitários.

Utilizar extensivamente a espera temporizada, como em Thread.sleep(), em testes concorrentes, de modo a estabilizar falhas relacionadas com temporização e reduzir a incidência de comportamentos intermitentes.

Lançar mão de implementações simuladas (mockups) em lugar do acesso ao relógio local e a serviços externos, isolando a unidade em teste e garantindo que cada teste seja independente de efeitos externos.

Declarar PixTransfer como subclasse tanto de AbstractTransaction quanto de outra classe concreta responsável por logging, resolvendo eventuais conflitos de métodos por meio de sobrescrita explícita.

Declarar PixTransfer como subclasse de AbstractTransaction e fazendo-a implementar, simultaneamente, Auditable e Reversible, sobrescrevendo explicitamente eventuais métodos default conflitantes definidos nas interfaces.

Declarar Auditable e Reversible como classes abstratas em vez de interfaces, permitindo que PixTransfer herde múltiplas implementações e confiando na ordem de resolução de métodos da linguagem para tratar conflitos.

Declarar PixTransfer de forma que ela simplesmente implemente Auditable e Reversible, uma vez que a herança de interfaces permite reutilização implícita de estado e comportamento equivalente à herança de uma classe abstrata.

No lado do cliente, o que é suficiente para verificar se as requisições estão corretas e evitar que requisições malformadas sejam enviadas para o servidor, melhorando a usabilidade e eliminando tráfego desnecessário.

No API Gateway, para verificar a conformidade com o esquema de requisições, evitando a necessidade de verificação de erros pelo servidor e padronizando a validação entre os vários microsserviços. 

No lado do cliente para verificar regras de formatação, melhorando a usabilidade e reduzindo tráfego desnecessário, assim como no lado servidor para garantir segurança e conformidade com a interface do serviço.

No lado do servidor, em se tratando de requisições a APIs publicamente acessíveis, ao passo que requisições internas entre os microsserviços da aplicação podem ser validadas apenas pelo microsserviço chamador.

gerenciar os contêineres em um nó, garantindo que todos os contêineres descritos na especificação de pods do nó estejam ativos e funcionando corretamente. 

escalonar contêineres para executarem em pods específicos visando à otimização do uso de recursos e ao balanceamento de carga em um nó.

armazenar informações de estado do cluster para uso na recuperação dos nós após a ocorrência de falhas.

controlar o mapeamento de endereços IP e números de porta para tornar os contêineres acessíveis externamente.

Apenas as camadas de Aplicação e Dados.

Apenas as camadas de Middleware e Sistema de Tempo de Execução. 

Apenas as camadas de Virtualização e Servidores. 

Apenas as camadas de Aplicação, Dados e Sistema de Tempo de Execução.

hardware (bare metal) de processamento e dispositivos de armazenamento instalados e administrados na infraestrutura de um provedor e que podem ser alocados aos clientes por meio de contratos de prestação de serviço.

sistemas de suporte ao desenvolvimento e operação de aplicações, os quais são hospedados na infraestrutura de um provedor e podem ser utilizados como serviço pelos clientes, sendo que o faturamento é realizado com base na quantidade de uso.

contêineres, máquinas virtuais e recursos de armazenamento, alocados elasticamente aos clientes por meio de APIs de serviço que permitem o faturamento com base no tipo de recurso e no tempo de alocação.

máquinas virtuais e capacidade de armazenamento, que podem ser escalados de forma elástica para atender a demanda dinâmica das aplicações, podendo sua alocação aos clientes ser gerenciada automaticamente por meio de APIs de serviços Web.

CI encorajar o uso de repositórios distintos para evitar interferência entre as diferentes tarefas de desenvolvimento em um projeto, com integração frequente dos repositórios e uso de testagem automática para garantir a ausência de erros, enquanto CD requer o empacotamento e deployment automáticos para reduzir o impacto de mudanças. 

CI envolver o uso de um repositório compartilhado, com automação de build e testagem a cada commit, enquanto CD envolve o empacotamento automático de cada build bem-sucedida, gerando uma nova release e deixando-a pronta para implantação (deployment) nos diferentes ambientes de produção.

CI requerer a realização contínua e automática de testes de integração para garantir que mudanças no código-fonte realizadas nos diferentes ramos (branches) do repositório não comprometam o comportamento correto dos componentes do sistema, enquanto CD envolve a implantação em ambiente de produção para a realização de testes em ambiente real.

CI determinar o emprego de testes unitários automáticos, eliminando a necessidade de testes manuais e garantindo que o comportamento do sistema permaneça correto após cada mudança, enquanto CD implica a realização automática de testes de integração após cada build e o subsequente empacotamento para deployment.

reduzir a necessidade de idas e vindas ao banco de dados pela aplicação, sendo que stored procedures podem realizar controle de transações, enquanto stored functions podem ser chamadas dentro de consultas (queries) SQL.

alocar a lógica de negócio no próprio banco de dados, sendo que tanto stored procedures quanto stored functions podem ser chamadas dentro de consultas (queries) SQL realizadas pelas aplicações.

realizar processamento centrado nos dados dentro do próprio gerenciador de banco de dados, com a possibilidade de fazer commit ou rollback de transações no caso de stored functions.

melhorar o desempenho por meio da realização de processamento dentro do próprio banco de dados e do controle fino de transações, tanto em stored procedures quanto em stored functions.

Implementar as regras de domínio de negócio com Angular para facilitar sua adaptação a diferentes clientes, enquanto o back-end, implementado com Spring Boot, deve se limitar a operações CRUD e acesso ao banco de dados, de modo a facilitar a evolução da aplicação. 

Implementar as regras de negócio no back-end com Spring Boot para garantir segurança e reutilização por múltiplos clientes, enquanto a lógica de apresentação e de controle da interface de usuário deve ser implementada com Angular para garantir a interatividade da aplicação. 

Implementar as regras de validação e controle de acesso no front-end com Angular, pois a separação entre cliente e servidor já garante a consistência e segurança dos dados, enquanto o back-end, baseado em Spring Boot deve expor a lógica da aplicação por meio de APIs REST padronizadas.

Implementar o acesso aos dados no front-end com Angular, de modo que validações de dados específicas de usuário possam ser feitas sem gerar sobrecarga no servidor e que a lógica de negócio, implementada no back-end com Spring Boot possa ser independente do esquema do banco de dados. 

implementar a lógica de negócio, delimitar transações e compor a interface de usuário da aplicação.

representar entidades de negócio, coordenar objetos de domínio e formatar as respostas de requisições aos serviços da aplicação.

converter requisições de serviço em consultas ao banco de dados, definir o relacionamento entre objetos de domínio e coordenar a execução dos serviços.

tratar requisições HTTP, fazer o parsing dos parâmetros de entrada e delegar lógica de negócio para os serviços da aplicação.

a classe ou interface não pode ser modificada para adicionar novos membros (atributos ou métodos). 

os objetos instanciados a partir da classe ou cujo tipo seja definido pela interface não podem ser chamados fora do escopo atual.

a classe ou interface só pode ser herdada por classes explicitamente especificadas em sua declaração. 

as instâncias da classe ou da interface recebem uma assinatura que garante sua validade.

Testes unitários verificam detalhes internos de implementação dos componentes do sistema, enquanto testes de integração realizam a validação do comportamento do sistema como um todo, permitindo que a refatoração prossiga sem riscos.

Testes unitários validam comportamentos locais e testes de integração validam as interações entre componentes, criando camadas de verificação para garantir que mudanças estruturais não alterem o comportamento observável do sistema.

Testes de integração garantem a correção arquitetural, tornando redundante a realização de testes unitários durante a refatoração, desde que os workflows possam ser validados fim-a-fim.

Testes unitários protegem contra mudanças de interface, enquanto testes de integração garantem estabilidade de desempenho, o que remove a necessidade de refazer os testes após uma refatoração.

os serviços individuais podem ser liberados como artefatos que podem ser implantados independentemente, sem exigir reconstrução ou rollout sincronizado do sistema completo.

o alinhamento de versões entre microsserviços garante que suas releases ocorram simultaneamente, evitando incompatibilidades entre componentes.

a arquitetura impõe uma estratégia fixa de rollout que padroniza a implantação em todos os ambientes onde o sistema deve ser implantado.

o pipeline de implantação compartilhado garante que todos os microsserviços passem pelos mesmos estágios de release ao mesmo tempo.

um objeto pode assumir diferentes formas, com diferentes métodos e atributos, dependendo do contexto em que for instanciado.

uma classe pode herdar métodos e atributos de diferentes superclasses, podendo ser utilizada em lugar de qualquer de suas superclasses.

um método pode ter diferentes versões, sendo que cada versão pode ser definida com parâmetros e tipos de retorno diferentes.

um mesmo método definido em uma interface pode executar diferentes comportamentos, dependendo do objeto no qual for chamado.