A armadilha da pressa com IA: Clean Code e Arquitetura ainda separam juniores de seniores

A velocidade da IA e o custo invisível

A Inteligência Artificial já se consolidou como uma ferramenta indispensável no arsenal do desenvolvedor moderno. Copilots e assistentes de código prometem e entregam uma aceleração notável na digitação de linhas, transformando a forma como interagimos com nossas IDEs. É tentador delegar a essas ferramentas a maior parte do trabalho braçal, focando apenas na funcionalidade.

No entanto, essa velocidade tem um custo se não for guiada por princípios sólidos de engenharia de software. O código gerado pode ser funcional, mas se não seguir um design cuidadoso, ele se torna rapidamente um emaranhado de dependências e responsabilidades mal definidas. É o débito técnico em esteroides, construído na velocidade da luz.

Por que Clean Code e Arquitetura são a bússola

Mesmo com toda a capacidade de geração de código da IA, os princípios fundamentais de software continuam sendo a espinha dorsal de qualquer sistema sustentável. Eles são a bússola que impede a pressa de nos levar a um pântano de manutenção.

  • Coesão e Desacoplamento

    Ferramentas de IA ainda não são arquitetos. Elas não compreendem o contexto macro do sistema, a divisão estratégica de responsabilidades entre módulos ou a necessidade de desacoplamento. Um desenvolvedor sênior usa a IA para implementar um módulo coeso, não para definir o que é coeso. A decisão sobre a granularidade e as fronteiras de um componente é uma tarefa de design, não de digitação.

  • Clareza de Domínio

    O código deve refletir o domínio do negócio de forma clara e expressiva. A IA pode gerar padrões sintáticos ou algoritmos conhecidos, mas a interpretação e a modelagem do domínio são tarefas humanas, que exigem profunda compreensão do problema a ser resolvido. Um código que expressa bem o domínio é mais fácil de entender, manter e evoluir.

  • Sustentabilidade

    Sistemas sustentáveis são aqueles que podem evoluir sem quebrar a cada nova funcionalidade ou requisito. Isso é fruto de um design que prioriza a manutenibilidade, a testabilidade e a escalabilidade. A IA pode escrever testes unitários para um trecho de código, mas a arquitetura que permite testes eficazes e a evolução fluida é projetada por humanos, com base em princípios como Inversão de Dependência e Segregação de Interfaces.

O abismo entre juniores e seniores

É aqui que a distinção entre desenvolvedores juniores e seniores se acentua de forma dramática:

Um júnior pode ver a IA como um atalho para entregar código, focando na funcionalidade imediata sem se preocupar com as implicações de longo prazo na base de código. A dependência excessiva pode impedir o desenvolvimento do senso crítico de design e a compreensão profunda dos princípios de software.

Um sênior enxerga a IA como uma ferramenta poderosa para aumentar a produtividade na implementação, liberando tempo para focar no design de software, na arquitetura, na refatoração estratégica e na mentoria. Ele usa a IA para validar ou acelerar a escrita de código que já foi arquitetado mentalmente ou em diagramas. Para o sênior, a IA vira um copiloto, não o piloto.

A IA não veio para substituir a engenharia de software, mas para amplificá-la. A diferença entre um desenvolvedor que constrói sistemas robustos e um que apenas “faz funcionar” será cada vez mais marcada pela maestria em Clean Code e Arquitetura. A pressa pode ser inimiga da perfeição, e com a IA, ela pode ser a amiga íntima do débito técnico.

Deixe um comentário

Arquivado em Engenharia de Software

IA Generativa em Microsserviços: O Dilema do Acoplamento Inesperado

A Inteligência Artificial Generativa chegou com a promessa de uma produtividade sem precedentes. Quem não gostaria de ter um assistente que escreve código em segundos? Para arquiteturas monolíticas, a integração pode ser mais direta. Mas quando falamos de microsserviços, a história é um pouco mais complexa, e o atalho pode ter um custo invisível: o acoplamento.

A Tentação do Código Rápido e o Custo Oculto

Imagine a cena: um desenvolvedor, sob pressão, usa uma ferramenta de IA para gerar um fragmento de código que interage com um serviço existente. A IA, em sua ânsia de ser útil, pode interpretar intenções ou convenções que não estão explicitamente documentadas ou que fogem do contrato formal da API. O resultado? Um código que funciona, mas que implicitamente cria uma nova dependência.

Onde o Contrato Encontra o Caos

Em um mundo de microsserviços, contratos de API bem definidos são a espinha dorsal da estabilidade. Eles garantem que os serviços possam evoluir de forma independente, sem quebrar seus consumidores. O código gerado por IA, se não for rigorosamente revisado e validado contra esses contratos, pode facilmente introduzir:

  • **Acoplamento de Dados:** Assumindo formatos de dados ou estruturas internas que não fazem parte do contrato público.
  • **Acoplamento Comportamental:** Dependendo de uma sequência específica de chamadas ou de um estado interno de outro serviço.
  • **Acoplamento Temporal:** Implicando uma ordem de execução ou latência que não é garantida.

Essas dependências ocultas são o pesadelo de qualquer arquiteto de microsserviços. Elas transformam a promessa de agilidade em um campo minado de regressões e falhas inesperadas.

O Acoplamento Disfarçado

A IA generativa é excelente em inferir padrões. O problema é que, no contexto de microsserviços, um “padrão” pode ser uma especificidade de implementação que deveria ser interna, não um contrato público. Quando o código gerado faz suposições sobre a lógica interna de outro serviço, ele está essencialmente reintroduzindo o acoplamento, transformando seus serviços distribuídos em um monólito camuflado.

Ilustração conceitual - ia-generativa-microsservicos-acoplamento-inesperado
Ilustração técnica editorial – TechPulse

A resiliência de um sistema de microsserviços depende da sua capacidade de isolar falhas. Se um serviço muda sua implementação interna (sem violar seu contrato), outros serviços não deveriam ser afetados. No entanto, se o código gerado por IA em um serviço consumidor depende de uma particularidade da implementação do provedor, uma mudança inocente no provedor pode derrubar o consumidor.

"Em arquiteturas de microsserviços, a governança de domínio e a manutenção de contratos estritos são a primeira linha de defesa contra o caos. A IA é uma ferramenta poderosa, mas não um substituto para a vigilância arquitetural."

Governança: O Escudo Contra a Anarquia

Para mitigar esses riscos, a governança rigorosa de API e a revisão humana do código gerado são mais cruciais do que nunca. Ferramentas de IA devem ser vistas como copilotos, não pilotos automáticos.

Testes e Observabilidade Reforçados

Com a IA no fluxo de trabalho, a importância de testes de contrato e testes de integração automatizados aumenta exponencialmente. Eles são a sua rede de segurança para capturar qualquer desvio não intencional. A observabilidade também se torna vital: métricas de latência, erros e rastreamento distribuído podem revelar padrões de dependência que o código gerado por IA pode ter introduzido.

A Mão Humana na Arquitetura

A IA generativa é uma ferramenta fantástica para tarefas repetitivas e para acelerar prototipagem. No entanto, a definição de contratos de serviço, a validação de arquitetura e a garantia de resiliência continuam sendo responsabilidades humanas. A expertise de engenheiros e arquitetos é indispensável para guiar a IA, garantindo que o código gerado esteja alinhado com os princípios de design de microsserviços e não crie novos pontos de falha.

Em última análise, a IA generativa não muda os fundamentos de uma boa arquitetura de microsserviços. Ela apenas adiciona uma nova camada de complexidade e a necessidade de maior diligência. Use a IA para acelerar, mas nunca para terceirizar o pensamento crítico sobre como seus serviços se comunicam e coexistem.

Deixe um comentário

Arquivado em Arquitetura de Software

Dominando a Arte do Código Limpo: Expressões Lambda em Java

A programação funcional está conquistando o mundo do desenvolvimento, e o Java, sempre antenado, abraçou essa tendência com entusiasmo. Desde a versão 8, o Java introduziu as expressões lambda, uma ferramenta poderosa e elegante para escrever código mais conciso e expressivo.

Neste artigo, vamos mergulhar no universo das expressões lambda, explorando seus benefícios, casos de uso e recursos adicionais que simplificam o desenvolvimento em Java.

Desvendando as Expressões Lambda

Imagine um mundo onde você pode encapsular um bloco de código inteiro em um objeto, pronto para ser usado a qualquer momento. Esse é o poder das expressões lambda! Também conhecidas como funções anônimas, elas permitem tratar funcionalidades como argumentos de métodos ou armazená-las em variáveis.

A sintaxe das expressões lambda é elegante e concisa:

(parâmetros) -> expressão

  • Parâmetros: Variáveis de entrada para a função.
  • ->: Operador de arrow-function), separa os parâmetros do corpo da função.
  • Expressão: Código a ser executado pela função.

Exemplo: Imagine que você precisa imprimir uma lista de nomes. Com expressões lambda, o código se torna incrivelmente simples:


Map, Reduce e a Magia das Coleções

As expressões lambda brilham ao manipular coleções, especialmente com os métodos map e reduce da classe Stream.

  • map: Aplica uma função a cada elemento de uma coleção, retornando uma nova coleção com os resultados.
List<Integer> numeros = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> quadrados = numeros.stream().map(n -> n * n).collect(Collectors.toList());

// Resultado: quadrados = [1, 4, 9, 16, 25]
  • reduce: Combina os elementos de uma coleção em um único resultado, aplicando uma função de acumulação.
int soma = numeros.stream().reduce(0, (a, b) -> a + b);

// Resultado: soma = 15

Interfaces Funcionais: A Base das Expressões Lambda

As interfaces funcionais são a fundação das expressões lambda em Java. Uma interface funcional possui apenas um método abstrato, atuando como um “contrato” para as expressões lambda.

O Java oferece diversas interfaces funcionais prontas no pacote java.util.function, como:

  • Consumer<T>: Representa uma operação que recebe um argumento do tipo T e não retorna nenhum resultado.
  • Function<T, R>: Representa uma função que recebe um argumento do tipo T e retorna um resultado do tipo R.
  • Predicate<T>: Representa um predicado, uma função que recebe um argumento do tipo T e retorna um valor booleano.

Ordenando o Caos com Expressões Lambda

A ordenação de coleções também se beneficia da elegância das expressões lambda. O método sort da classe Collections e o método sorted da classe Stream aceitam um Comparator, que pode ser implementado de forma concisa com expressões lambda.

List<String> nomes = Arrays.asList("David", "Carol", "Bob", "Alice");
nomes.sort((a, b) -> a.compareTo(b));

// Resultado: nomes = ["Alice", "Bob", "Carol", "David"] 

Conclusão: Abrace a Simplicidade e Expressividade

As expressões lambda em Java não são apenas uma abreviação sintática, mas uma mudança de paradigma na forma como escrevemos código. Ao adotá-las, você estará abraçando:

  • Código mais conciso e legível: Menos código, mais clareza.
  • Programação funcional: Um novo nível de expressividade e flexibilidade.
  • Código mais reutilizável e modular: Funcionalidades encapsuladas e prontas para serem reutilizadas.

A jornada no mundo das expressões lambda não termina aqui! Explore os recursos, pratique e descubra como essa ferramenta poderosa pode elevar seus projetos Java a um novo patamar de qualidade e elegância.

Se você deseja se aprofundar no tema de expressões lambda e programação funcional em Java, aqui estão algumas sugestões de livros para equipar o cinturão do Batman:

  1. “Java 8 in Action” de Raoul-Gabriel Urma, Mario Fusco e Alan Mycroft
  2. “Functional Programming in Java” de Pierre-Yves Saumont
  3. “Java Lambda Expressions” de Richard Warburton
  4. “Mastering Lambdas: Java Programming in a Multicore World” de Maurice Naftalin

Conclusão: As expressões lambda são uma adição poderosa ao Java, permitindo que os desenvolvedores escrevam código mais conciso, legível e expressivo. Além de simplificar a sintaxe, as expressões lambda oferecem recursos avançados, como map, reduce e ordenação, que tornam o processamento de coleções mais eficiente e elegante. Ao utilizar expressões lambda em conjunto com interfaces funcionais, você pode aproveitar os benefícios da programação funcional e criar código mais modular e reutilizável.

Esperamos que este artigo tenha fornecido uma visão abrangente das expressões lambda em Java e inspirado você a explorar mais sobre esse fascinante tópico. Não deixe de consultar os livros recomendados para aprofundar seus conhecimentos e aprimorar suas habilidades de programação funcional em Java. Com a prática e a aplicação consistente desses conceitos, você estará bem equipado para criar soluções eficientes e elegantes em seus projetos Java.

Bons códigos, t+

Deixe um comentário

Arquivado em Sem categoria

Como fazer backup da sua chave de ativação do Windows 10 de maneira simples via cmd ou powershell

Recentemente precisei reinstalar meu Windows 10 e usar minha chave de ativação, para evitar dor de cabeça fiz o meu backup. Segue duas opções pela linha de comando sem precisar instalar produtos de terceiros.

Como administrador no Powershell execute a linha:

(Get-WmiObject -query ‘select * from SoftwareLicensingService’).OA3xOriginalProductKey

Outra possibilidade é usar o cmd ou prompt de comando, execute a linha:

wmic path softwarelicensingservice get OA3xOriginalProductKey

Nota: Criatura, anote, faça print, bata foto, salve e lugar seguro a sua chave de ativação do Windows, será útil no momento de reinstalar o seu Windows.

ATENÇÃO!!! Este post tem objetivo de ajudar as pessoas leigas no assunto e é meramente educacional. Não me responsabilizou por mau uso das informações.

Deixe um comentário

Arquivado em Windows

Como pegar o último dia do mês no SQL Server

Para trazer o último dia do mês atual no SQL Server, você pode usar a seguinte consulta:

SELECT DATEADD(dd, -1, DATEADD(mm, DATEDIFF(mm, 0, GETDATE()) + 1, 0)) AS LastDayOfMonth

Aqui, estamos primeiro usando a função DATEDIFF para calcular a diferença em meses entre a data 0 (1 de janeiro de 1900) e a data atual (GETDATE()). Em seguida, usamos a função DATEADD para adicionar esse número de meses mais um à data 0, dando-nos o primeiro dia do próximo mês. Finalmente, usamos a função DATEADD novamente para subtrair um dia da data obtida, dando-nos o último dia do mês atual.

Deixe um comentário

Arquivado em Banco de Dados, SQL

Como pegar o primeiro dia do mês no SQL Server

Para pegar o primeiro dia do mês atual no SQL Server, você pode usar a seguinte consulta:

SELECT DATEADD(mm, DATEDIFF(mm, 0, GETDATE()), 0) AS FirstDayOfMonth

Aqui, estamos usando a função DATEDIFF para calcular a diferença em meses entre a data 0 (1 de janeiro de 1900) e a data atual (GETDATE()). Em seguida, usamos a função DATEADD para adicionar esse número de meses à data 0, dando-nos o primeiro dia do mês atual.

Deixe um comentário

Arquivado em Banco de Dados, SQL

Exemplo de como criar uma consulta de ordenação aleatória no SQL Server

Aqui está um exemplo de como criar uma consulta de ordenação aleatória no SQL Server:

  • Usando o NEWID():
SELECT coluna1, coluna2, coluna3
FROM nome_da_tabela
ORDER BY NEWID()
  • Usando o CHECKSUM() com RAND():
SELECT coluna1, coluna2, coluna3
FROM nome_da_tabela
ORDER BY CHECKSUM(NEWID(), RAND(CHECKSUM(NEWID())))
  • Usando a função RAND():
SELECT coluna1, coluna2, coluna3
FROM nome_da_tabela
ORDER BY RAND(CHECKSUM(NEWID()))

Note que as consultas acima são apenas exemplos e que o nome da tabela e as colunas listadas devem ser substituídas pelos nomes reais da sua tabela e colunas.

Além disso, você pode limitar o número de resultados retornados usando a cláusula TOP ou usando uma consulta com paginação.

Deixe um comentário

Arquivado em Banco de Dados, DDL (data definition language), SGBD Sql-Server, SQL

SQL Server – Query para sugerir índice para melhorar consultas

SELECT
    sys.objects.name,
    (avg_total_user_cost * avg_user_impact) * (user_seeks + user_scans) AS Impact,
    'CREATE NONCLUSTERED INDEX ix_IndexName ON ' + sys.objects.name COLLATE DATABASE_DEFAULT + ' ( ' + ISNULL(mid.equality_columns, '') + CASE
        WHEN mid.inequality_columns IS NULL THEN ''
        ELSE CASE
                WHEN mid.equality_columns IS NULL THEN ''
                ELSE ','
            END + mid.inequality_columns
    END + ' ) ' + CASE
        WHEN mid.included_columns IS NULL THEN ''
        ELSE 'INCLUDE (' + mid.included_columns + ')'
    END + ';' AS CreateIndexStatement,
    mid.equality_columns,
    mid.inequality_columns,
    mid.included_columns
FROM sys.dm_db_missing_index_group_stats AS migs
INNER JOIN sys.dm_db_missing_index_groups AS mig
    ON migs.group_handle = mig.index_group_handle
INNER JOIN sys.dm_db_missing_index_details AS mid
    ON mig.index_handle = mid.index_handle
    AND mid.database_id = DB_ID()
INNER JOIN sys.objects WITH (NOLOCK)
    ON mid.OBJECT_ID = sys.objects.OBJECT_ID
WHERE (
    migs.group_handle IN (
        SELECT TOP (500) group_handle
        FROM sys.dm_db_missing_index_group_stats WITH (NOLOCK)
        ORDER BY (avg_total_user_cost * avg_user_impact) * (user_seeks + user_scans) DESC
    )
)
AND OBJECTPROPERTY(sys.objects.OBJECT_ID, 'isusertable') = 1
ORDER BY 2 DESC, 3 DESC

Referência: Prof. Victorino Vila. Alura, Curso Administração do Microsoft SQL Server 2014. Acessado em 2022-11-15. <https://cursos.alura.com.br/course/administracao-do-sql-server-2017/task/43422&gt;

Deixe um comentário

Arquivado em Banco de Dados, DML (data manipulation language), SGBD Sql-Server, SQL

Sql Server, veja como executar um comando sql a partir do resultado de um select

Sql Server, veja como executar um comando sql a partir do resultado de um select

Nota: a execução do resultado do comando sql é linha-a-linha, ou seja, só posso executar um comando por vez, ok? vamos aos exemplos

Exemplo 1 – simples select sendo executado:

Exemplo 2 – Efetuando a chamada de procedure baseada nos resultados da consulta retornada pelo select.

No contexto, a procedure atende uma regra de negocio de mudança infrações de trânsito de um processo para outro, dito isto, no select faço a pesquisa de três infrações para escrever um comando sql que serve para rodar a procedure com os parâmetros informados dinamicamente para cada caso.

Note que na caixa de messages deu erro por conta da regra de negocio, porem o mais importante aqui é efetuou a chamada dos três comandos gerados no select dentro do loop while do cursor.

A execução linha-a-linha da string atribuída a variável @sql foi feita através da chamada “EXECUTE sp_executesql @sql”

Bom é isto, espero que seja útil vc. Dúvidas cruéis só postar nos comentários, ok?

Até o próximo post…

Deixe um comentário

Arquivado em Banco de Dados, SQL

Setting Up IDE Eclipse e Tomcat 7 para debug remoto (Windows 10)

Vamos fazer um passo-a-passo da configuração do ambiente para que seja possível efetuar um “debug” de código na IDE Eclipse, apontando para o servidor de Tomcat remoto.

O exemplo é baseado no Tomcat 7.x, Eclipse (2020-06) e no Windows 10. Não testei no Linux, mas acredito que os passos sejam similares, pois o foco das configurações são no Tomcat e Eclipse.

No Eclipse vá até o menu “Debug configurations“:

Em “Debug Configurations”, localize a opção “Remote Java Application”

Duplo clique e abrirá a tela:

Sobre os campos:

Name: Nome do Debug

Project: pode deixar vazio

Connection Type: pode manter o padrão selecionado – Standard (Socket Attach)

Connection Properties: Informe o host (exemplo: localhost, 10.10.10.236, etc…) e a porta pode manter a default 8000 (está porta não tem relação com a porta que o servidor está rodando para servir a aplicação, se estiver rodando na 8080, continua na fé e mantem a porta 8000 – é a porta padrão do JPDA, combinado?)

Deixe desmarcado Allow termination of remote VM se não quiser matar sua aplicação remota – no servidor de teste não terá impacto, mas se chegar no ponto de fazer um debug remoto no servidor de produção, vc pode acabar derrubando algo que não deve e a emoção será grande com os usuários.

Fechamos os passos de configuração na IDE, vamos para o servidor de Tomcat.

TOMCAT

Na pasta do seu Tomcat entre em /bin e clique duplo em tomcatW.exe – pode ser outro nome dependendo do nome que foi instalado, mas o final “W.exe”  – blablablaW.exe

Vá até aba “Java” e no campo textarea de “Java Options”, adicione no finalzinho os parâmetros:

-Xdebug -agentlib:jdwp=transport=dt_socket,address=8000,server=y,suspend=n

Após isto, clique em aplicar e reinicie o Tomcat.

DEBUG

Marque seus breakpoints e abra a aplicação no endereço do configurado, no meu caso  http://10.10.10.236:8080 navegue até atingir sua condição de debug.

Para debugar o processo normal de debug do dia-a-dia que vc já deve estar acostumado.

Inicie o Debug pela opção “Remote Java Application – botão Debug”, ou uma vez configurado já configurado irá aparecer a baixo do debug convencional do menu principal do Eclipse.

Com isto finalizamos o bê-á-bá do debug remoto.

Obs. Se houve algum erro de conexão recusada, certifique-se que no servidor a porta 8000 esteja liberada pelo firewall e afins.

Dúvidas cruéis, mande nos comentários

T+

Deixe um comentário

Arquivado em Sem categoria