Tag: object pascal

Desde a versão 2.14, o RadIA passou por uma evolução importante. O foco deixou de estar apenas na expansão do catálogo de ferramentas e avançou para algo mais ambicioso: permitir que o desenvolvedor Delphi compreenda, altere, valide, execute e investigue uma aplicação dentro de um fluxo integrado e verificável.

As versões 2.15.0 e 2.15.1 ampliaram a integração com o código Delphi, fortaleceram a automação de aplicações VCL em execução, melhoraram o processo de diagnóstico e adicionaram novas proteções às interfaces baseadas em WebView2.

Neste artigo, veremos o que mudou e como essas melhorias afetam o uso diário do RadIA.

Integrar inteligência artificial a uma IDE vai muito além de colocar um chat ao lado do editor. Para ajudar de verdade, a ferramenta precisa compreender o projeto que está aberto, reconhecer os tipos envolvidos, acompanhar arquivos ainda em edição e saber quando possui informações suficientes para sugerir uma alteração.

O RadIA 2.14.0 avança justamente nessa direção. A nova versão fortalece o motor semântico para Object Pascal e amplia a validação das decisões tomadas dentro do Delphi. O objetivo não é apenas encontrar mais símbolos ou oferecer mais sugestões, mas tornar cada resposta mais previsível, explicável e segura.

Essa evolução também muda a forma como avaliamos a qualidade do produto. Em vez de perguntar somente se uma unit compila, a validação passa a acompanhar jornadas completas: criar um projeto, abrir o formulário no Designer, editar, compilar, testar, iniciar uma sessão de depuração e interagir com a aplicação em execução.

O RadIA 2.13.0 amplia o conjunto de ferramentas integradas ao RAD Studio com foco em produtividade segura, diagnóstico e modernização de projetos existentes. A nova versão adiciona geração de documentação e mocks, análise de stack traces, gerenciamento de cache, revisão automática ao salvar, Clean Uses, assistência para threads e PPL, retrofit OpenAPI/Swagger e um fluxo controlado para adoção de DEXT e decomposição de forms.

O ponto comum entre essas funcionalidades é a segurança. Quando uma operação pode alterar arquivos, o RadIA prepara uma preview revisável, exige consentimento antes da aplicação e mantém mecanismos de reversão. O objetivo não é apenas gerar mais código, mas reduzir o trabalho repetitivo sem transformar automação em risco para o projeto.

A versão 2.10 marcou uma mudança importante no RadIA. Foi nela que o projeto ganhou uma camada semântica estrutural própria para Object Pascal, aproximando o agente do código real, dos símbolos, dos tipos, da herança e das interfaces presentes em um projeto Delphi.

Depois dessa fundação, surgiu uma pergunta inevitável: como entregar toda essa capacidade sem exigir que o usuário compreenda a arquitetura interna do produto antes de conseguir utilizá-lo?

O desafio não era remover recursos. Também não era transformar o RadIA em um assistente limitado, capaz apenas de gerar pequenos trechos de código. A proposta sempre foi mais ampla: integrar chat, agente, editor, compilação, testes, debugger, Form Designer, terminal, conhecimento local, MCP, extensões e automações dentro do Delphi.

O verdadeiro desafio era reduzir a carga cognitiva sem reduzir o produto.

Esse foi o eixo principal do trabalho realizado entre as versões 2.10 e 2.12.3. Nesse período, o RadIA ganhou uma jornada inicial mais direta, passou a explicar melhor o que está fazendo, deixou escolhas importantes visíveis, organizou sua presença dentro da IDE e recebeu novos testes de integração para situações que só aparecem quando o software encontra a vida real: uma IDE sem projeto aberto, uma janela acoplada, uma troca rápida entre projetos ou um módulo recriado internamente pela Open Tools API.

Desde o início, a proposta do RadIA nunca foi apenas colocar uma janela de chat dentro do Delphi. A ideia é construir uma experiência de desenvolvimento assistida por inteligência artificial que compreenda o ambiente da IDE, trabalhe com o projeto real e ajude o desenvolvedor desde a criação do código até a compilação, os testes e o diagnóstico de problemas.

A versão 2.10 representa um passo importante nessa direção. O principal avanço é a introdução de um motor semântico estrutural próprio para Object Pascal, integrado ao Delphi 12 e ao Delphi 13. Com ele, o RadIA passa a entender melhor a organização do código, os símbolos, os relacionamentos entre tipos, a herança e as interfaces do projeto.

Na prática, isso reduz a distância entre uma IA que apenas recebe texto e uma ferramenta que realmente compreende o contexto em que o desenvolvedor está trabalhando.

O RadIA 2.8.0 é uma release de integração fina com o editor Delphi.

Depois da versão 2.7.0 consolidar uma base funcional mais previsível, com criação de projetos por linguagem natural, navegação Code/Design, revisão por bloco e evidências reproduzíveis, a 2.8.0 avança em uma camada mais próxima do uso diário: o contexto semântico do editor.

Essa evolução é importante porque, na prática, a qualidade de uma resposta de IA dentro da IDE depende muito do contexto que ela recebe. Não basta saber que existe um projeto Delphi aberto. É preciso entender qual unit está ativa, qual símbolo está sob o cursor, quais imports estão disponíveis e quais declarações próximas ajudam a explicar a intenção do usuário.

Ao mesmo tempo, esse tipo de integração precisa ser cuidadoso. O editor Delphi já possui seu próprio CodeInsight e sua própria experiência nativa. O objetivo do RadIA 2.8.0 não é substituir isso, mas complementar o fluxo com uma camada observável, limitada e segura de contexto para a IA.

O RadIA nasceu com uma proposta simples de explicar e difícil de executar bem: levar inteligência artificial para dentro do Delphi sem transformar a IDE em apenas mais uma janela de chat. A ideia sempre foi que a IA pudesse participar do fluxo real de desenvolvimento, com acesso controlado a contexto, projeto, editor, designer, build, testes, debugger e evidências.

A versão 2.7.0 é importante porque não tenta vender uma novidade isolada. Ela fecha uma baseline funcional determinística. Em outras palavras: pega capacidades que vinham amadurecendo nas versões anteriores e as consolida em um conjunto mais previsível, mais validado e mais fácil de demonstrar.

O foco desta release é clareza operacional. O RadIA precisa entender melhor a intenção do usuário, escolher o caminho certo dentro da IDE, pedir consentimento quando houver risco, executar ações reais e deixar evidências suficientes para que o desenvolvedor confie no resultado.

O RadIA 2.9.0 representa uma mudança de escala na experiência de IA dentro do Delphi.

Na versão 2.8.0, o foco foi aproximar a IA do ponto real de trabalho. Ghost Text, ações contextuais e agente passaram a compartilhar informações como unit ativa, símbolo sob o cursor, imports e declarações próximas. Foi uma evolução fundamental: em vez de responder apenas com conhecimento genérico, o RadIA passou a compreender melhor o trecho que o desenvolvedor estava editando.

A 2.9.0 parte dessa base e avança para uma pergunta mais difícil: depois de entender o código atual, como um agente pode agir levando em conta as particularidades do Delphi?

Isso envolve muito mais do que conhecer a sintaxe de Object Pascal. Uma decisão correta pode depender da versão e da arquitetura da IDE, do framework VCL ou FMX, da plataforma de destino, dos packages, das bibliotecas presentes no projeto, do vínculo entre .pas e .dfm, das regras de ownership e até do histórico tecnológico de uma aplicação criada com BDE, ADO ou dbExpress.

É nesse espaço que a versão 2.9.0 trabalha. Ela transforma o RadIA em um agente mais consciente do ecossistema Delphi, com novas formas de observar, orientar, validar e modernizar um projeto sem abrir mão de consentimento, limites e evidências.

Desde o ultimo artigo, publicado na versao 2.3.0, o RadIA deixou de ser apenas uma plataforma com contexto compactado e avancou para uma experiencia agentiva mais completa dentro do Delphi. A sequencia 2.3.1 ate 2.6.2 trouxe rotas de execucao mais claras, ChatGPT Pro via Codex CLI, terminal de alta fidelidade, publicacao de skills para CLIs, criacao de projetos por prompt, validacao com build, debugger e DUnitX, alem de correcoes importantes de usabilidade e instalacao.

No artigo da versao 2.3.0, o foco principal foi o RTK interno do RadIA: uma camada para reduzir o volume de resultados enviados ao modelo sem perder a evidencia original. Aquela entrega tratava um problema essencial para agentes de IA: contexto nao e infinito, e um runtime serio precisa saber o que deve lembrar, o que pode resumir e o que precisa preservar integralmente.

De la para ca, o RadIA evoluiu em outra direcao igualmente importante: transformar essa base agentiva em uma experiencia mais pratica, mais visivel e mais proxima do trabalho diario no Delphi.

Entre as versoes 2.3.1 e 2.6.2, o projeto avancou em cinco frentes:

O resultado e um RadIA menos dependente de explicacao previa. O usuario pode conversar, pedir uma acao, criar um projeto, aprovar um plano, ver a IDE trabalhar, acompanhar build, testes e debugger, e conferir a versao instalada nas proprias janelas.

Se você acompanha o RadIA, já sabe que a proposta do projeto não é colocar apenas mais uma janela de chat dentro do Delphi. O objetivo é permitir que a inteligência artificial participe de fluxos reais de desenvolvimento: inspecionar o projeto aberto, localizar símbolos, alterar arquivos, compilar, executar testes, analisar diffs e apresentar evidências verificáveis.

Esse tipo de experiência tem um desafio que normalmente aparece somente quando o agente começa a executar tarefas longas: o volume de contexto cresce muito rápido.

Uma compilação pode produzir centenas de hints. Uma suíte de testes pode repetir milhares de linhas de sucesso. Um diff pode ter centenas de kilobytes. Uma busca na base de conhecimento pode retornar trechos extensos. Se todo esse conteúdo continuar sendo reenviado integralmente ao modelo a cada nova decisão, a IA passa a gastar contexto, tempo e possivelmente dinheiro relendo informações que já foram processadas.

O RadIA 2.3.0 enfrenta esse problema com um RTK interno, escrito em Delphi e integrado diretamente ao Agent Runtime.

RTK, neste contexto, é uma camada de compactação de resultados de ferramentas. Em vez de entregar ao modelo todo o payload bruto em cada passo, o RadIA cria uma projeção menor, determinística e orientada às evidências que realmente importam. O resultado original não é apagado: ele permanece armazenado e pode ser recuperado por resumo ou por faixa sem executar a ferramenta novamente.

O efeito esperado é simples de explicar: menos ruído no contexto, mais espaço para raciocínio, menos repetição e maior capacidade de sustentar tarefas longas.

A versão 2.3.0 do RadIA reduz o volume de resultados reenviado aos modelos sem descartar a evidência original. Em dez execuções Release, o benchmark controlado mediu 96,71% de redução no corpus completo e 75,65% quando removemos o stress test de 1 MiB. Este artigo explica o que esses números realmente demonstram, o que eles não demonstram e por que tratar contexto como recurso pode ser uma evolução importante na programação assistida por IA.

Mas antes de falar em economia, precisamos responder à pergunta mais importante: os benchmarks são reais e confiáveis?

O RadIA 2.2.2 transforma comandos de automação em jornadas guiadas que preservam o contexto, adiciona geração de servidores DEXT minimalistas ou com controllers e deixa a configuração de modelos, CLI e MCP muito mais clara.

O RadIA é open source. Código-fonte, documentação, histórico e instruções de compilação estão no repositório oficial no GitHub.

Se você acompanha o desenvolvimento do RadIA, sabe que o nosso objetivo nunca foi criar apenas mais uma janela de chat dentro do Delphi. A proposta é usar inteligência artificial para executar fluxos reais de desenvolvimento: entender o projeto aberto, propor um plano, criar ou alterar arquivos, compilar, executar testes e apresentar evidências do resultado.

A versão 2.2.2 avança justamente nessa direção. Ela introduz jornadas conversacionais para criação de APIs DEXT, melhora a descoberta dos recursos do próprio plugin e resolve pontos importantes de previsibilidade na seleção de modelos, no limite de tokens e na configuração de CLI e MCP.

Em outras palavras: o RadIA ficou mais fácil de descobrir, mais claro de configurar e mais seguro de usar em tarefas longas.

Repositório: https://github.com/regyssilveira/RadIA-Plugin

Em poucas versões, o RadIA evoluiu de um assistente integrado ao editor para uma plataforma agêntica com 124 ferramentas, capaz de participar de jornadas completas de criação, build, testes, depuração, diagnóstico de memória e validação de correções.

Quem desenvolve em Delphi sabe que escrever código é apenas uma parte do trabalho. O ciclo real inclui compreender projetos antigos, localizar units, interpretar mensagens do compilador, criar e executar testes, reproduzir erros que só aparecem em runtime, analisar a pilha de chamadas e, nos casos mais difíceis, perseguir vazamentos de memória.

Foi olhando para essa jornada completa que o RadIA evoluiu.

Na versão 1.0.0, ele já era muito mais do que uma janela de chat. O plugin se integrava ao editor do Delphi, entendia o contexto da unit ativa, trabalhava com vários provedores de IA, criava e revisava código, preparava alterações seguras e acessava recursos da IDE por ferramentas estruturadas.

Agora, na versão 2.2.1, o RadIA chega a outro estágio: ele não apenas sugere o que o desenvolvedor poderia fazer. Com autorização, limites claros e etapas revisáveis, ele consegue participar da execução do trabalho dentro da própria IDE.

Se você desenvolve em Delphi, com certeza já conhece ou ouviu falar do Boss, o gerenciador de dependências que revolucionou a forma como organizamos, instalamos e compartilhamos código na nossa comunidade. Hoje, tenho o enorme prazer de apresentar o Boss4D (Boss4Delphi), uma versão do Boss modernizada, robusta, altamente testada e alinhada com as melhores práticas de Engenharia de Software modernas e totalmente feito em Delphi e aberto, regyssilveira/Boss4Delphi.

Neste artigo vamos ver o que mudou e passar por todas as novidades que o projeto traz.

A maioria dos sistemas Delphi possui uma característica em comum: são aplicações que evoluem durante muitos anos. ERPs, sistemas fiscais, aplicações industriais, financeiras e governamentais frequentemente acumulam milhares de linhas de código, dezenas de módulos e diversas equipes ao longo do tempo.

Nesse cenário, manter a qualidade do código passa a ser um desafio cada vez maior.

Questões como duplicidade de código, métodos excessivamente complexos, padrões inconsistentes, problemas de manutenção e até possíveis bugs podem se acumular silenciosamente durante anos.

É exatamente para esse tipo de situação que o SonarQube foi criado.

O SonarQube é uma das ferramentas de análise estática de código mais utilizadas do mercado e permite monitorar continuamente a qualidade dos projetos através de métricas, regras de validação e indicadores de manutenção.

Neste artigo vamos configurar uma instalação completa utilizando Docker, habilitar o suporte a Delphi através do Marketplace e executar nossa primeira análise de código.

Se você tem acompanhado a evolução do Rad IA — nosso plugin open-source de assistência de IA integrado nativamente à IDE do Delphi (Alexandria, Athens e Florence) —, sabe que nosso compromisso vai muito além de "envelopar APIs de IA". Buscamos trazer produtividade real para o desenvolvedor Object Pascal sob as regras mais rígidas de Clean Code, SOLID e segurança em runtime.

Na recém-lançada versão v0.0.26, demos um salto gigantesco. Redesenhamos a experiência visual do chat para torná-la mais orgânica e premium, e realizamos uma profunda reforma estrutural de engenharia de software na base de código do plugin.

Neste artigo, convido você a dar uma olhada nos bastidores do que mudou no Rad IA, nas decisões de arquitetura que tomamos e em como blindamos o plugin contra travamentos e concorrência no Delphi.