<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Rafael Chinaglia on Medium]]></title>
        <description><![CDATA[Stories by Rafael Chinaglia on Medium]]></description>
        <link>https://medium.com/@rafael-chinaglia?source=rss-931f1fe0a8fd------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*JeCE4pIoVB3e6q3kuzFINg.jpeg</url>
            <title>Stories by Rafael Chinaglia on Medium</title>
            <link>https://medium.com/@rafael-chinaglia?source=rss-931f1fe0a8fd------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 22:07:11 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rafael-chinaglia/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Novidades do Java 26 (para pessoas desenvolvedoras)]]></title>
            <link>https://medium.com/totvsdevelopers/novidades-do-java-26-para-desenvolvedores-af356bb0e822?source=rss-931f1fe0a8fd------2</link>
            <guid isPermaLink="false">https://medium.com/p/af356bb0e822</guid>
            <category><![CDATA[desenvolvedores]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[developer]]></category>
            <dc:creator><![CDATA[Rafael Chinaglia]]></dc:creator>
            <pubDate>Thu, 26 Mar 2026 16:47:06 GMT</pubDate>
            <atom:updated>2026-04-02T14:38:51.452Z</atom:updated>
            <content:encoded><![CDATA[<p>Artigo de Loiane Groner</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rSY9GCp7EQWKrgU7VKXWlA.jpeg" /><figcaption>Reprodução/Freepik</figcaption></figure><p>O Java 26 chega com o casamento de padrões em pleno funcionamento, a concorrência caminhando para a finalização e APIs pragmáticas para otimização de inicialização e criptografia. Após o intenso trabalho de linguagem realizado no Java 25, o Java 26 concentra-se em aprimorar as versões prévias existentes e fornecer primitivas de biblioteca que estavam faltando.</p><p>Este post é um guia prático: seções curtas, código executável e cenários concretos onde você usará cada recurso em breve. Cada trecho de código é intencionalmente minimalista para que você possa copiar, adaptar e executar rapidamente.</p><blockquote><strong><em>Observação</em></strong><em> : O Java 26 </em><strong><em>não é uma versão LTS</em></strong><em> . Ele recebe atualizações por 6 meses (até setembro de 2026). Para suporte a longo prazo, use o Java 21 LTS ou o Java 25 LTS.</em></blockquote><ul><li>[FINAL] — estável, pronto para produção</li><li>[PRÉ-VISUALIZAÇÃO] — requer--enable-preview</li><li>[INCUBADOR] — experimental, pode sofrer alterações significativas</li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#java-26-highlights">Destaques do Java 26</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#language--pattern-matching">Correspondência de linguagem e padrões</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#jep-530-primitive-types-in-patterns-instanceof-and-switch-preview">JEP 530: Tipos primitivos em padrões, instanceof e switch [PRÉVIA]</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#concurrency-at-scale">Concorrência em escala</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#jep-525-structured-concurrency-preview">JEP 525: Concorrência estruturada [PRÉVIA]</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#startup-optimization">Otimização de startups</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#jep-526-lazy-constants-preview">JEP 526: Constantes preguiçosas [PRÉVIA]</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#cryptography--security">Criptografia e segurança</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#jep-524-pem-encodings-of-cryptographic-objects-preview">JEP 524: Codificações PEM de objetos criptográficos [PRÉ-VISUALIZAÇÃO]</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#jep-500-prepare-to-make-final-mean-final-final">JEP 500: Prepare-se para tornar final o significado final [FINAL]</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#performance--gc">Desempenho e GC</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#jep-516-ahead-of-time-object-caching-with-any-gc-final">JEP 516: Cache de objetos antecipado com qualquer GC [FINAL]</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#jep-522-g1-gc-improve-throughput-by-reducing-synchronization-final">JEP 522: G1 GC: melhorar o rendimento reduzindo a sincronização [FINAL]</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#jep-517-http3-for-the-http-client-api-final">JEP 517: HTTP/3 para a API do Cliente HTTP [FINAL]</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#vector-compute-early-incubation">Computação vetorial (incubação inicial)</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#jep-529-vector-api-incubator">JEP 529: API vetorial [INCUBADORA]</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#platform-cleanup">Limpeza da plataforma</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#jep-504-remove-the-applet-api-final">JEP 504: Remover a API Applet [FINAL]</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#what-you-can-start-using-today">O que você pode começar a usar hoje</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#production-ready-no-flags-required-final">Pronto para produção (sem necessidade de sinalizadores) [FINAL]</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#safe-to-adopt-in-devtest-preview">Seguro para adoção em desenvolvimento/teste [PRÉVIA]</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#experimental-incubators--wait-for-finalization">Experimental (incubadoras) — aguardar finalização</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#migration-checklist">Lista de verificação para migração</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#notes">Notas</a></li><li><a href="https://loiane.com/2026/03/whats-new-in-java-26-for-developers/#references">Referências</a></li></ul><h3>Destaques do Java 26</h3><ul><li>[PRÉVIA] Tipos primitivos em padrões em qualquer lugar (JEP 530 — quarta prévia, lançamento em breve)</li><li>[PRÉVIA] Maturidade da concorrência estruturada (JEP 525 — sexta prévia, próxima da versão final)</li><li>[PRÉVIA] Constantes preguiçosas para aumento de desempenho na inicialização (JEP 526 — segunda prévia)</li><li>[PRÉVIA] APIs de criptografia PEM (JEP 524 — segunda prévia)</li><li>[FINAL] Cache AOT com qualquer GC — incluindo ZGC (JEP 516)</li><li>[FINAL] HTTP/3 para o Cliente HTTP (JEP 517)</li><li>[FINAL] Ganhos de desempenho do GC G1 (JEP 522)</li><li>[FINAL] Campos finais ganhando força (JEP 500 — avisos hoje, negativas depois)</li><li>[INCUBATOR] API de computação vetorial (JEP 529 — décima primeira incubadora)</li></ul><h3>Correspondência de linguagem e padrões</h3><h3>JEP 530: Tipos primitivos em padrões, instanceof e switch [PRÉVIA]</h3><p><a href="https://openjdk.org/jeps/530">JEP 530</a></p><p>O que é: A correspondência de padrões agora funciona uniformemente em todos os tipos primitivos. Você pode usar `std::string` instanceof int x, vincular valores restritos com segurança em `std::string` switche verificar conversões sem perda silenciosa.</p><p>Quando você usará: análise de JSON com coerção de tipo, verificações seguras de intervalo numérico, expressão de regras de negócios com guardas.</p><p>Antes (conversão manual, verificações de tipo repetitivas):</p><pre>// BEFORE (Java 25)<br>public class PriceAnalyzer {<br>    static String category(Object price) {<br>        if (price instanceof Integer) {<br>            int p = (Integer) price;<br>            return p &lt; 100 ? &quot;BUDGET&quot; : p &lt; 500 ? &quot;MID&quot; : &quot;PREMIUM&quot;;<br>        }<br>        if (price instanceof Double) {<br>            double d = (Double) price;<br>            // Silent truncation risk if cast to int<br>            if (d &gt; 1000.0) return &quot;PREMIUM&quot;;<br>            return &quot;MID&quot;;<br>        }<br>        if (price instanceof Long) {<br>            long l = (Long) price;<br>            return l &gt; 10_000 ? &quot;PREMIUM&quot; : &quot;BUSINESS&quot;;<br>        }<br>        return &quot;UNKNOWN&quot;;<br>    }<br>}</pre><p>Após (padrões primitivos com estreitamento seguro):</p><pre>// src/main/java/com/loiane/pricing/Category.java<br>package com.loiane.pricing;</pre><pre>public class PriceAnalyzer {<br>    static String category(Object price) {<br>        return switch (price) {<br>            case int p when p &lt; 100 -&gt; &quot;BUDGET&quot;;<br>            case int p when p &lt; 500 -&gt; &quot;MID&quot;;<br>            case int p -&gt; &quot;PREMIUM&quot;;<br>            <br>            case long l when l &gt; 10_000 -&gt; &quot;PREMIUM&quot;;<br>            case long l -&gt; &quot;BUSINESS&quot;;<br>            <br>            // Only bind d to int x if conversion is exact (no silent loss)<br>            case double d when d instanceof int x -&gt; <br>                &quot;EXACT_INT: &quot; + category(x);<br>            case double d when d &gt; 1000.0 -&gt; &quot;PREMIUM&quot;;<br>            case double d -&gt; &quot;MID&quot;;<br>            <br>            default -&gt; &quot;UNKNOWN&quot;;<br>        };<br>    }</pre><pre>    public static void main(String[] args) {<br>        System.out.println(category(50));       // BUDGET<br>        System.out.println(category(300));      // MID<br>        System.out.println(category(800));      // PREMIUM<br>        System.out.println(category(15_000L));  // PREMIUM<br>        System.out.println(category(500.0));    // EXACT_INT<br>        System.out.println(category(500.5));    // MID<br>    }<br>}</pre><p>O que está acontecendo aqui?</p><ul><li>case int pvincula-se exatamente a valores inteiros; Longe Doubletêm seus próprios casos.</li><li>d instanceof int xVerifica se o valor double dpode ser convertido exatamente para int (sem perda de precisão); somente então o vincula.</li><li>Os guards ( when) permitem expressar lógica de intervalo em linha.</li></ul><p>Executar (pré-visualização):</p><pre>javac --enable-preview --release 26 -d out src/main/java/com/loiane/pricing/Category.java<br>java --enable-preview -cp out com.loiane.pricing.PriceAnalyzer</pre><h3>Concorrência em escala</h3><h3>JEP 525: Concorrência estruturada [PRÉVIA]</h3><p><a href="https://openjdk.org/jeps/525">JEP 525</a></p><p>O que é: Concorrência baseada em tarefas com cancelamento automático e propagação de erros. Criam-se subtarefas relacionadas, unindo-as em uma unidade; se uma falhar, as demais são canceladas automaticamente.</p><p>Quando usar: manipuladores de requisições web, operações de E/S paralelas, fluxos de trabalho com limites claros de sucesso/falha.</p><p>Antes (cancelamento manual, vazamentos de threads em caso de falha, tratamento complexo de erros):</p><pre>// BEFORE (Java 25, using ExecutorService)<br>public class OrderService {<br>    static class OrderData {<br>        String customer;<br>        List&lt;String&gt; items;<br>        String address;<br>    }<br>    <br>    static OrderData fetchOrder(ExecutorService executor) throws Exception {<br>        Future&lt;String&gt; customerFuture = executor.submit(() -&gt; {<br>            Thread.sleep(100); // simulate I/O<br>            return &quot;Alice&quot;;<br>        });<br>        <br>        Future&lt;List&lt;String&gt;&gt; itemsFuture = executor.submit(() -&gt; {<br>            Thread.sleep(150);<br>            return List.of(&quot;Laptop&quot;, &quot;Mouse&quot;);<br>        });<br>        <br>        Future&lt;String&gt; addressFuture = executor.submit(() -&gt; {<br>            Thread.sleep(200);<br>            return &quot;123 Main St&quot;;<br>        });<br>        <br>        // Problem: if customerFuture.get() throws, itemsFuture and addressFuture<br>        // keep running (thread leak). Manual cancellation needed everywhere.<br>        String customer = customerFuture.get();<br>        List&lt;String&gt; items = itemsFuture.get();<br>        String address = addressFuture.get();<br>        <br>        return new OrderData(customer, items, address);<br>    }<br>}</pre><p>Após (tratamento e cancelamento estruturados e automáticos de erros):</p><pre>// src/main/java/com/loiane/orders/OrderService.java<br>package com.loiane.orders;</pre><pre>import java.util.concurrent.StructuredTaskScope;<br>import java.util.concurrent.StructuredTaskScope.Joiner;<br>import java.util.List;</pre><pre>public class OrderService {<br>    static class OrderData {<br>        String customer;<br>        List&lt;String&gt; items;<br>        String address;<br>        <br>        OrderData(String customer, List&lt;String&gt; items, String address) {<br>            this.customer = customer;<br>            this.items = items;<br>            this.address = address;<br>        }<br>    }<br>    <br>    static OrderData fetchOrder() throws Exception {<br>        try (var scope = StructuredTaskScope.open(Joiner.allSuccessfulOrThrow())) {<br>            var customerTask = scope.fork(() -&gt; {<br>                Thread.sleep(100);<br>                return &quot;Alice&quot;;<br>            });<br>            <br>            var itemsTask = scope.fork(() -&gt; {<br>                Thread.sleep(150);<br>                return List.of(&quot;Laptop&quot;, &quot;Mouse&quot;);<br>            });<br>            <br>            var addressTask = scope.fork(() -&gt; {<br>                Thread.sleep(200);<br>                return &quot;123 Main St&quot;;<br>            });<br>            <br>            scope.join(); // Wait for all; if any fails, cancel others automatically<br>            <br>            return new OrderData(<br>                customerTask.get(),<br>                itemsTask.get(),<br>                addressTask.get()<br>            );<br>        }<br>        // Scope closed: all subtasks guaranteed to have finished<br>    }<br>    <br>    public static void main(String[] args) throws Exception {<br>        var order = fetchOrder();<br>        System.out.println(&quot;Customer: &quot; + order.customer);<br>        System.out.println(&quot;Items: &quot; + order.items);<br>        System.out.println(&quot;Address: &quot; + order.address);<br>    }<br>}</pre><p>O que está acontecendo aqui?</p><ul><li>StructuredTaskScope.open(Joiner.allSuccessfulOrThrow())Cria um escopo onde todas as subtarefas devem ser concluídas com sucesso.</li><li>fork()Inicia cada tarefa assíncrona (thread virtual, por padrão no Java 21+).</li><li>join()Aguarda a conclusão de todas as subtarefas; se alguma falhar, as outras são canceladas imediatamente.</li><li>tryO parâmetro -with-resources garante que o escopo seja encerrado e a limpeza seja realizada.</li></ul><p>Executar (pré-visualização):</p><pre>javac --enable-preview --release 26 -d out src/main/java/com/loiane/orders/OrderService.java<br>java --enable-preview -cp out com.loiane.orders.OrderService</pre><h3>Otimização de startups</h3><h3>JEP 526: Constantes preguiçosas [PRÉVIA]</h3><p><a href="https://openjdk.org/jeps/526">JEP 526</a></p><p>O que é: Imutabilidade diferida. Cria uma LazyConstant&lt;T&gt;variável que é inicializada no primeiro acesso, com semântica de &quot;no máximo uma vez&quot;, mesmo sob chamadas concorrentes. A JVM a trata como uma constante verdadeira após a inicialização, permitindo otimizações.</p><p>Quando usar: Inicialização da aplicação — adie inicializações dispendiosas (loggers, repositórios, configurações) até que sejam necessárias.</p><p>Antes (inicialização imediata ou bloqueio com verificação dupla, ambos problemáticos):</p><pre>// BEFORE<br>public class Application {<br>    // Eager: logger created even if app never logs<br>    private static final Logger LOGGER = Logger.getLogger(&quot;com.app&quot;);<br>    <br>    // Or: double-checked locking (verbose, not constant-folded)<br>    private static volatile Logger logger;<br>    static Logger getLogger() {<br>        if (logger == null) {<br>            synchronized (Application.class) {<br>                if (logger == null) {<br>                    logger = Logger.getLogger(&quot;com.app&quot;);<br>                }<br>            }<br>        }<br>        return logger;<br>    }<br>}</pre><p>Após (constante preguiçosa com desempenho de ansioso):</p><pre>// src/main/java/com/loiane/app/Application.java<br>package com.loiane.app;</pre><pre>import java.lang.LazyConstant;<br>import java.util.logging.Logger;</pre><pre>public class Application {<br>    // Initialize lazily on first call; JVM constant-folds after init<br>    private static final LazyConstant&lt;Logger&gt; LOGGER =<br>        LazyConstant.of(() -&gt; Logger.getLogger(&quot;com.loiane.app&quot;));<br>    <br>    static void logInfo(String msg) {<br>        LOGGER.get().info(msg);<br>    }<br>    <br>    public static void main(String[] args) {<br>        logInfo(&quot;App started&quot;); // First call: logger created<br>        logInfo(&quot;Processing&quot;);  // Subsequent: instant (constant-folded)<br>    }<br>}</pre><p>Para listas, use List.ofLazy():</p><pre>// src/main/java/com/loiane/app/Pool.java<br>package com.loiane.app;</pre><pre>import java.util.List;</pre><pre>public class Pool {<br>    static class Worker {<br>        String name;<br>        Worker(String name) { this.name = name; }<br>    }<br>    <br>    // Pool of 10 workers, each created on first access<br>    static final List&lt;Worker&gt; WORKERS = List.ofLazy(10, <br>        index -&gt; new Worker(&quot;worker-&quot; + index));<br>    <br>    public static void main(String[] args) {<br>        System.out.println(WORKERS.get(0).name); // Lazy init<br>        System.out.println(WORKERS.get(0).name); // Instant (cached)<br>    }<br>}</pre><p>O que está acontecendo aqui?</p><ul><li>LazyConstant.of(supplier)Cria um invólucro; liga para o fornecedor na primeira vez .get(), e nunca mais.</li><li>List.ofLazy(size, indexedSupplier)Cria uma lista de tamanho fixo com elementos preguiçosos.</li><li>A JVM otimiza os acessos após a inicialização estar completa.</li></ul><p>Executar (pré-visualização):</p><pre>javac --enable-preview --release 26 -d out src/main/java/com/loiane/app/*.java<br>java --enable-preview -cp out com.loiane.app.Application</pre><h3>Criptografia e segurança</h3><h3>JEP 524: Codificações PEM de objetos criptográficos [PRÉ-VISUALIZAÇÃO]</h3><p><a href="https://openjdk.org/jeps/524">JEP 524</a></p><p>O que é: APIs padrão para codificação/decodificação PEM de chaves, certificados e CRLs. Codifica para PEM para armazenamento/transporte; decodifica de PEM de volta para objetos criptográficos Java. Opcionalmente, criptografa chaves privadas.</p><p>Quando você usará: Gerenciamento de chaves, carregamento de certificados, compartilhamento seguro de chaves entre sistemas.</p><p>Antes (Base64 manual, modelo padrão, sem padrão):</p><pre>// BEFORE (Java 25)<br>import java.security.KeyPairGenerator;<br>import java.security.KeyPair;<br>import java.util.Base64;<br>import java.nio.file.*;</pre><pre>public class KeyMgmt {<br>    static void exportKey(KeyPair kp) throws Exception {<br>        byte[] privateKeyBytes = kp.getPrivate().getEncoded();<br>        String base64 = Base64.getEncoder().encodeToString(privateKeyBytes);<br>        <br>        StringBuilder pem = new StringBuilder();<br>        pem.append(&quot;-----BEGIN PRIVATE KEY-----\n&quot;);<br>        // Manually format to 64-char lines<br>        for (int i = 0; i &lt; base64.length(); i += 64) {<br>            int end = Math.min(i + 64, base64.length());<br>            pem.append(base64, i, end).append(&quot;\n&quot;);<br>        }<br>        pem.append(&quot;-----END PRIVATE KEY-----\n&quot;);<br>        <br>        Files.writeString(Path.of(&quot;key.pem&quot;), pem);<br>    }<br>}</pre><p>Após (codificador/decodificador PEM limpo com criptografia opcional):</p><pre>// src/main/java/com/loiane/crypto/KeyMgmt.java<br>package com.loiane.crypto;</pre><pre>import java.security.*;<br>import java.security.spec.*;<br>import java.nio.file.*;<br>import java.security.PEMEncoder;<br>import java.security.PEMDecoder;</pre><pre>public class KeyMgmt {<br>    // Generate a keypair<br>    static KeyPair generateKeyPair() throws Exception {<br>        var gen = KeyPairGenerator.getInstance(&quot;RSA&quot;);<br>        gen.initialize(2048);<br>        return gen.generateKeyPair();<br>    }<br>    <br>    // Export keypair to PEM (no encryption)<br>    static void exportKeyPair(KeyPair kp, Path path) throws Exception {<br>        String pem = PEMEncoder.of().encodeToString(kp);<br>        Files.writeString(path, pem);<br>        System.out.println(&quot;Exported: &quot; + path.getFileName());<br>    }<br>    <br>    // Export private key with password encryption<br>    static void exportEncrypted(KeyPair kp, char[] password, Path path) <br>            throws Exception {<br>        var encoder = PEMEncoder.of().withEncryption(password);<br>        String pem = encoder.encodeToString(kp.getPrivate());<br>        Files.writeString(path, pem);<br>        System.out.println(&quot;Exported encrypted: &quot; + path.getFileName());<br>    }<br>    <br>    // Import from PEM<br>    static KeyPair importKeyPair(Path path, char[] password) throws Exception {<br>        String pem = Files.readString(path);<br>        var decoder = PEMDecoder.of().withDecryption(password);<br>        // Decoder infers type from PEM header<br>        return (KeyPair) decoder.decode(pem);<br>    }<br>    <br>    public static void main(String[] args) throws Exception {<br>        var kp = generateKeyPair();<br>        <br>        exportKeyPair(kp, Path.of(&quot;public-private.pem&quot;));<br>        exportEncrypted(kp, &quot;secret123&quot;.toCharArray(), Path.of(&quot;private-encrypted.pem&quot;));<br>        <br>        // Re-import<br>        var restored = importKeyPair(<br>            Path.of(&quot;private-encrypted.pem&quot;),<br>            &quot;secret123&quot;.toCharArray()<br>        );<br>        System.out.println(&quot;Restored private key: &quot; + restored.getPrivate().getAlgorithm());<br>    }<br>}</pre><p>O que está acontecendo aqui?</p><ul><li>PEMEncoder.of()Cria um codificador; .encodeToString()retorna o texto PEM diretamente.</li><li>withEncryption(password)Permite a criptografia baseada em senha para chaves privadas.</li><li>PEMDecoder.of().withDecryption(password)Detecta automaticamente o tipo de chave a partir do cabeçalho PEM; descriptografa se necessário.</li></ul><p>Executar (pré-visualização):</p><pre>javac --enable-preview --release 26 -d out src/main/java/com/loiane/crypto/KeyMgmt.java<br>java --enable-preview -cp out com.loiane.crypto.KeyMgmt</pre><h3>JEP 500: Prepare-se para tornar final o significado final [FINAL]</h3><p><a href="https://openjdk.org/jeps/500">JEP 500</a></p><p>O que é: A reflexão profunda (por exemplo, Field.set()em campos finais) agora emite um aviso. Em uma futura versão do Java, ela lançará uma exceção por padrão. Isso abre caminho para a verdadeira imutabilidade e otimizações da JVM.</p><p>Quando usar: Analise os avisos em seus logs e bibliotecas. Use --enable-final-field-mutation=ALL-UNNAMEDem produção se necessário, mas planeje refatorar o código.</p><p>Código (detectar mutação do campo final):</p><pre>// src/main/java/com/loiane/finals/FinalTest.java<br>package com.loiane.finals;</pre><pre>import java.lang.reflect.Field;</pre><pre>public class FinalTest {<br>    static class Config {<br>        final String env = &quot;prod&quot;;<br>    }<br>    <br>    public static void main(String[] args) throws Exception {<br>        Config cfg = new Config();<br>        System.out.println(&quot;Before: &quot; + cfg.env);<br>        <br>        // Reflection: mutate the final field<br>        Field f = Config.class.getDeclaredField(&quot;env&quot;);<br>        f.setAccessible(true);<br>        f.set(cfg, &quot;dev&quot;); // Warning issued in Java 26<br>        <br>        System.out.println(&quot;After: &quot; + cfg.env);  // Prints &quot;dev&quot;<br>    }<br>}</pre><p>Corra e preste atenção ao aviso:</p><pre>javac -d out src/main/java/com/loiane/finals/FinalTest.java<br>java -cp out com.loiane.finals.FinalTest<br># Output:<br># WARNING: Final field env in class com.loiane.finals.FinalTest$Config<br># has been mutated by class com.loiane.finals.FinalTest.main ...</pre><p>Se precisar suprimir o aviso (temporariamente):</p><pre>java --illegal-final-field-mutation=allow -cp out com.loiane.finals.FinalTest</pre><p>Mas planeje migrar as bibliotecas de serialização para sun.reflect.ReflectionFactoryoutra solução.</p><h3>Desempenho e GC</h3><p>[FINAL]</p><h3>JEP 516: Cache de objetos antecipado com qualquer GC [FINAL]</h3><p><a href="https://openjdk.org/jeps/516">JEP 516</a></p><p>O que é: O cache AOT agora funciona com ZGC, não apenas com G1/Serial/Parallel. Utiliza um formato agnóstico ao GC (índices lógicos), de modo que o mesmo cache funciona em diferentes GCs.</p><p>Quando usar: Inicializações a frio de contêineres. Treine com qualquer coletor de lixo; use em produção com Z, G1 ou qualquer outro.</p><p>Fluxo de trabalho:</p><pre># Training: collect class-loading and object data<br>java -XX:AOTCacheOutput=app.aot -jar yourapp.jar</pre><pre># Production: reuse the same cache with ZGC<br>java -XX:+UseZGC -XX:AOTCache=app.aot -jar yourapp.jar</pre><pre># or with G1 (the default)<br>java -XX:AOTCache=app.aot -jar yourapp.jar</pre><p>Exemplo do Spring Boot (da documentação do JDK): <strong>melhoria de 41% no tempo de inicialização</strong> do PetClinic (21.000 classes pré-carregadas).</p><h3>JEP 522: G1 GC: melhorar o rendimento reduzindo a sincronização [FINAL]</h3><p><a href="https://openjdk.org/jeps/522">JEP 522</a></p><p>O que é: Barreiras de escrita do G1 simplificadas; tabela de cartões dupla elimina a disputa entre os threads do aplicativo e do otimizador de GC. Resultado: <strong>ganho de desempenho de 5 a 15%</strong> em cargas de trabalho com grande volume de objetos; tempos de pausa ligeiramente menores.</p><p>Quando você vai usar: Nada a fazer! As melhorias são automáticas. Acompanhe -XX:+PrintGCDetailsse tiver interesse.</p><p>Trecho de teste (das notas de lançamento):</p><pre># Before: heavy mutation → GC thread contention<br>java -XX:+UseG1GC -XX:+PrintGCDetails -jar cpu-intensive-app.jar</pre><pre># After Java 26: same flags, lower GC overhead<br>java -XX:+UseG1GC -XX:+PrintGCDetails -jar cpu-intensive-app.jar<br># Observe: fewer GC pauses, higher throughput</pre><h3>JEP 517: HTTP/3 para a API do Cliente HTTP [FINAL]</h3><p><a href="https://openjdk.org/jeps/517">JEP 517</a></p><p>O que é: HttpClientagora suporta HTTP/3 (sobre QUIC). Benefícios: handshakes mais rápidos, sem bloqueio de cabeçalho de fila, resiliente em redes com alta perda de pacotes. Ativação opcional; o padrão é HTTP/2 para compatibilidade.</p><p>Quando usar: Ao servir conteúdo de endpoints compatíveis com HTTP/3 (CDNs modernos, balanceadores de carga na nuvem). Compatível com versões anteriores; código existente inalterado.</p><p>Código (opt-in HTTP/3 explícito):</p><pre>// src/main/java/com/loiane/http/Http3Client.java<br>package com.loiane.http;</pre><pre>import java.net.http.*;<br>import java.net.URI;</pre><pre>public class Http3Client {<br>    public static void main(String[] args) throws Exception {<br>        // Default HTTP/2 client<br>        var client = HttpClient.newBuilder()<br>                .version(HttpClient.Version.HTTP_2)<br>                .build();<br>        <br>        var req = HttpRequest.newBuilder(<br>                URI.create(&quot;https://example.com/api/data&quot;))<br>                .GET()<br>                .build();<br>        <br>        var resp = client.send(req, HttpResponse.BodyHandlers.ofString());<br>        System.out.println(&quot;Status: &quot; + resp.statusCode());<br>        System.out.println(&quot;Body: &quot; + resp.body());<br>        <br>        // HTTP/3 client: opt-in<br>        var h3Client = HttpClient.newBuilder()<br>                .version(HttpClient.Version.HTTP_3)<br>                .build();<br>        <br>        var h3Resp = h3Client.send(req, HttpResponse.BodyHandlers.ofString());<br>        System.out.println(&quot;HTTP/3 Status: &quot; + h3Resp.statusCode());<br>        // If server doesn&#39;t support HTTP/3, transparently falls back to HTTP/2<br>    }<br>}</pre><h3>Computação vetorial (incubação inicial)</h3><h3>JEP 529: API vetorial [INCUBADORA]</h3><p><a href="https://openjdk.org/jeps/529">JEP 529</a></p><p>O que é: Expressões de operações vetoriais (SIMD) que compilam de forma confiável para AVX, NEON ou SVE. Servem como base VectorSpeciespara definir formato e tamanho; o HotSpot C2 compila para instruções vetoriais de hardware.</p><p>Quando usar: Aprendizado de máquina, criptografia, computação numérica, hashing de arrays. Ainda não está pronto para uso geral (em fase de incubação, aguardando o Projeto Valhalla); usado internamente no JDK.</p><p>Esboço de código (adição vetorial):</p><pre>// src/main/java/com/loiane/compute/VectorSum.java<br>package com.loiane.compute;</pre><pre>import jdk.incubator.vector.*;</pre><pre>public class VectorSum {<br>    static final VectorSpecies&lt;Float&gt; SPECIES = FloatVector.SPECIES_PREFERRED;<br>    <br>    static float[] addVectors(float[] a, float[] b) {<br>        float[] c = new float[a.length];<br>        int i = 0;<br>        <br>        // Vectorized loop<br>        int upperBound = SPECIES.loopBound(a.length);<br>        for (; i &lt; upperBound; i += SPECIES.length()) {<br>            FloatVector va = FloatVector.fromArray(SPECIES, a, i);<br>            FloatVector vb = FloatVector.fromArray(SPECIES, b, i);<br>            FloatVector vc = va.add(vb);<br>            vc.intoArray(c, i);<br>        }<br>        <br>        // Scalar tail<br>        for (; i &lt; a.length; i++) {<br>            c[i] = a[i] + b[i];<br>        }<br>        <br>        return c;<br>    }<br>    <br>    public static void main(String[] args) {<br>        float[] a = {1.0f, 2.0f, 3.0f, 4.0f};<br>        float[] b = {5.0f, 6.0f, 7.0f, 8.0f};<br>        float[] c = addVectors(a, b);<br>        for (float v : c) System.out.println(v);<br>    }<br>}</pre><p>Compile (add-modules for incubator):</p><pre>javac --add-modules jdk.incubator.vector -d out \<br>  src/main/java/com/loiane/compute/VectorSum.java<br>java --add-modules jdk.incubator.vector -cp out com.loiane.compute.VectorSum</pre><p>Em CPUs que suportam AVX-512 (por exemplo, Xeon), o HotSpot gera instruções vetorizadas; em CPUs mais antigas, o processo é revertido automaticamente.</p><h3>Limpeza da plataforma</h3><h3>JEP 504: Remover a API Applet [FINAL]</h3><p><a href="https://openjdk.org/jeps/504">JEP 504</a></p><p>O que é: java.applet, javax.swing.JApplet, e classes relacionadas <strong>foram completamente removidas</strong> . Applets não funcionam em navegadores há mais de 10 anos.</p><blockquote><em>Lembra dos aplicativos bancários do início dos anos 2000? Todos eles eram baseados em Applets!</em></blockquote><p>Quando você será afetado: Somente se você mantiver código legado usando applets. Caminho de migração:</p><ul><li><strong>Contêineres de interface do usuário</strong> : Use componentes AWT ou Swing diretamente.</li><li><strong>Reprodução de áudio</strong> : Usar javax.sound.SoundClip(adicionado no Java 25).</li></ul><p>Se você encontrar erros de compilação, significa que está modernizando. Isso é progresso.</p><h3>O que você pode começar a usar hoje</h3><p>Aqui está um roteiro pragmático para a adoção dos recursos do Java 26 em seus projetos:</p><h3>Pronto para produção (sem necessidade de sinalizadores) [FINAL]</h3><p>Comece a usar esses recursos imediatamente em qualquer projeto Java 26:</p><ul><li><strong>Suporte a HTTP/3 (JEP 517)</strong> : Adicione uma única linha para optar por participar; o código existente não será afetado. Risco zero.</li><li>var client = HttpClient.newBuilder() .version(HttpClient.Version.HTTP_3) .build();</li><li><strong>Cache AOT com qualquer GC (JEP 516)</strong> : Melhora o desempenho em inicialização a frio em 30 a 40%. Adicione uma etapa de treinamento em sua CI; envie app.aotpara as imagens de produção. Uma vitória absoluta.</li><li>java -XX:AOTCacheOutput=app.aot -jar app.jar --train java -XX:AOTCache=app.aot -jar app.jar # Production</li><li><strong>Melhorias no G1 GC (JEP 522)</strong> : Automático. Nada a fazer; aproveite um ganho de desempenho de 5 a 15% em cargas de trabalho com grande quantidade de objetos.</li><li><strong>Avisos de campos finais (JEP 500)</strong> : Analise os avisos nos logs; coordene com as atualizações de dependências. Nenhuma ação imediata é necessária, a menos que se utilize reflexão profunda nos campos finais.</li></ul><h3>Seguro para adoção em desenvolvimento/teste [PRÉVIA]</h3><p>Essas funcionalidades são estáveis ​​e serão implementadas em breve. Use-as em desenvolvimento e testes; planeje a implementação em produção quando estiverem finalizadas.</p><ul><li><strong>Padrões de tipo primitivo (JEP 530)</strong> : Quarta prévia; caminho claro para a finalização. Adote em novos códigos e refatore bases de código com alta dependência de recursos avançados.</li><li>if (value instanceof int x) { ... } switch (price) { case long l when l &gt; 10_000 -&gt; &quot;PREMIUM&quot;; ... }</li><li>Adicionar ao pipeline de construção: javac --enable-preview --release 26.</li><li><strong>Concorrência estruturada (JEP 525)</strong> : Sexta prévia; comprovada em aplicações reais. Use para todo novo código concorrente.</li><li>try (var scope = StructuredTaskScope.open(Joiner.allSuccessfulOrThrow())) { var t1 = scope.fork(() -&gt; ...); var t2 = scope.fork(() -&gt; ...); scope.join(); return new Result(t1.get(), t2.get()); }</li><li><strong>Constantes preguiçosas (JEP 526)</strong> : Segunda prévia; API estável. Use para otimizar a inicialização do aplicativo.</li><li>static final LazyConstant&lt;Logger&gt; LOGGER = LazyConstant.of(() -&gt; Logger.getLogger(&quot;app&quot;));</li><li><strong>Codificações PEM (JEP 524)</strong> : Segunda prévia; simples. Use para manipulação de chaves/certificados criptográficos:</li><li>var kp = KeyPairGenerator.getInstance(&quot;RSA&quot;).generateKeyPair(); String pem = PEMEncoder.of().encodeToString(kp);</li></ul><h3>Experimental (incubadoras) — aguardar finalização</h3><ul><li><strong>API Vector (JEP 529)</strong> : Décima primeira incubadora; depende do Projeto Valhalla. Ainda não recomendada para uso em produção. Acompanhe a conclusão no Java 27/28.</li></ul><h3>Lista de verificação para migração</h3><p>Se você é um dos primeiros a adotar o Java 26:</p><ol><li><strong>Ative as pré-visualizações na sua compilação</strong> :</li></ol><ul><li>&lt;!-- Maven --&gt; &lt;release&gt;26&lt;/release&gt; &lt;args&gt; &lt;arg&gt;--enable-preview&lt;/arg&gt; &lt;/args&gt;</li></ul><ol><li><strong>Atualização de CI/CD</strong> :</li></ol><ul><li>Baixe o JDK 26 GA.</li><li>Configure a geração de cache AOT nas etapas de treinamento (opcional, mas recomendado).</li><li>Teste --enable-previewpara detectar depreciações precocemente.</li></ul><ol><li><strong>Refatorar incrementalmente</strong> :</li></ol><ul><li>Novo código: usar padrões primitivos, concorrência estruturada e constantes preguiçosas.</li><li>Código legado: adote conforme o tempo permitir; esses recursos não são disruptivos.</li></ul><ol><li><strong>Plano para migração para LTS</strong> :</li></ol><ul><li>Java 26 = 6 meses de atualizações (até setembro de 2026).</li><li>ou permaneça usando o Java 21 LTS ou o Java 25 LTS até lá.</li></ul><h3>Notas</h3><ul><li><strong>Os recursos de pré-visualização e incubação</strong> exigem --enable-previewe/ou --add-modules.</li><li><strong>Os padrões primitivos</strong> (JEP 530) estão na reta final: a quarta prévia sugere a finalização no Java 27 ou 28.</li><li><strong>A concorrência estruturada</strong> (JEP 525) também está em um nível de maturidade semelhante; planeje usá-la em novos códigos concorrentes hoje mesmo.</li><li><strong>As constantes preguiçosas</strong> e <strong>as codificações PEM</strong> estão em fase de refinamento; pequenos ajustes na API são possíveis antes da versão final.</li><li><strong>A API Vector</strong> deixará de estar em fase de incubação assim que o Projeto Valhalla entregar classes de valor; ainda não é recomendada para produção fora do próprio JDK.</li><li><strong>A implementação final das restrições de campo</strong> envolve várias versões: avisos na versão 26 e proibições em uma versão futura. Planeje suas migrações agora.</li></ul><h3>Referências</h3><ul><li><a href="https://jdk.java.net/26/">Downloads do JDK 26 GA</a></li><li><a href="https://openjdk.org/jeps/0">Índice JEP do OpenJDK</a></li><li><a href="https://openjdk.org/projects/leyden/">Projeto Leyden: Inicialização e Aquecimento</a></li><li><a href="https://openjdk.org/projects/valhalla/">Projeto Valhalla: Classes de Valor</a></li></ul><p>Boa programação!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=af356bb0e822" width="1" height="1" alt=""><hr><p><a href="https://medium.com/totvsdevelopers/novidades-do-java-26-para-desenvolvedores-af356bb0e822">Novidades do Java 26 (para pessoas desenvolvedoras)</a> was originally published in <a href="https://medium.com/totvsdevelopers">TOTVS Developers</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[TOTVS Developers Podcast]]></title>
            <link>https://medium.com/totvsdevelopers/totvs-developers-podcast-229a71603c9a?source=rss-931f1fe0a8fd------2</link>
            <guid isPermaLink="false">https://medium.com/p/229a71603c9a</guid>
            <category><![CDATA[liderança]]></category>
            <category><![CDATA[protagonismo-feminino]]></category>
            <category><![CDATA[developer]]></category>
            <category><![CDATA[tecnologia]]></category>
            <dc:creator><![CDATA[Rafael Chinaglia]]></dc:creator>
            <pubDate>Wed, 18 Mar 2026 14:31:47 GMT</pubDate>
            <atom:updated>2026-03-18T14:31:47.822Z</atom:updated>
            <content:encoded><![CDATA[<h3>#79 — Protagonismo feminino em tecnologia, inovação e liderança</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ozMQLlcGrORAl2KqvLBENA.png" /></figure><p>No mês das mulheres, o TOTVS Developers Podcast traz um episódio especial sobre protagonismo feminino em tecnologia, inovação e liderança. A host Ana Claudia conduz uma conversa com quatro profissionais que atuam diretamente na construção de produtos, plataformas de dados, metodologias ágeis e estratégias de inovação.</p><p>O episódio explora trajetórias de carreira, decisões difíceis, bastidores da liderança técnica e os desafios de ocupar espaços estratégicos em um setor historicamente masculino. Segundo dados recentes, menos de 20% dos postos de tecnologia são ocupados por mulheres. Ao mesmo tempo, o Brasil enfrenta um déficit de centenas de milhares de profissionais de TI.</p><p>Nesse contexto, ampliar a diversidade nas equipes não é apenas uma questão de representatividade, é também um fator estratégico para inovação, criatividade e construção de soluções mais completas. Durante o episódio, as convidadas compartilham experiências sobre viradas de carreira, liderança em ambientes técnicos, cultura ágil, desenvolvimento de produtos, plataformas de dados para inteligência artificial e o futuro da inovação tecnológica.</p><h3>Participantes do episódio</h3><p><a href="https://www.linkedin.com/in/annaclaudia/">Ana Claudia</a> — Especialista em ofertas, parcerias e inovação de software. Psicóloga e pós-graduanda em Neurociências, Orientação Profissional e Análise Comportamental.</p><p><a href="https://www.linkedin.com/in/leticia-de-liz/">Letícia Liz</a> — Gestora de Ofertas e BizDev de serviços de sustentação, com experiência em inovação, estratégia e experiência de cliente, usuário e produto.</p><p><a href="https://www.linkedin.com/in/djani-dalfovo-8942b7b7/">Djani Dalfovo</a> — Agile Master há quase uma década, professora de metodologias ágeis e mestranda em Administração.</p><p><a href="https://www.linkedin.com/in/fabianenardon/">Fabiane Nardon</a> — Diretora de Inteligência de Dados, arquiteta hands-on de plataformas de dados para IA seguras e custo-eficientes. PhD em Semântica e Ontologias e ex-CTO da Tail.</p><p>O que você vai ouvir neste episódio:</p><ul><li>Trajetórias profissionais e viradas de carreira na área de tecnologia</li><li>Liderança feminina em ambientes técnicos e executivos</li><li>Os desafios de construir autoridade em um setor historicamente masculino</li><li>Cultura ágil e transformação organizacional</li><li>O impacto da inteligência artificial no desenvolvimento de produtos e dados</li><li>Conselhos para mulheres que querem crescer na carreira de tecnologia</li></ul><p>Se você trabalha com tecnologia, inovação, produto ou dados, este episódio traz reflexões importantes sobre carreira, liderança e o futuro da indústria tech.</p><p>Assista e ouça agora:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F-lwsq25ae9I%3Flist%3DPLeuob2rvkwP-iL6bNDRcvXFTrh9lJVf3P&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D-lwsq25ae9I&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F-lwsq25ae9I%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/5cf09f892f4c8b4b3cb68547044de77f/href">https://medium.com/media/5cf09f892f4c8b4b3cb68547044de77f/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=229a71603c9a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/totvsdevelopers/totvs-developers-podcast-229a71603c9a">TOTVS Developers Podcast</a> was originally published in <a href="https://medium.com/totvsdevelopers">TOTVS Developers</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[TOTVS Developers Podcast]]></title>
            <link>https://rafael-chinaglia.medium.com/totvs-developers-podcast-d291e465fd0b?source=rss-931f1fe0a8fd------2</link>
            <guid isPermaLink="false">https://medium.com/p/d291e465fd0b</guid>
            <category><![CDATA[protagonismo-feminino]]></category>
            <category><![CDATA[liderança]]></category>
            <category><![CDATA[inovação]]></category>
            <category><![CDATA[podcast]]></category>
            <category><![CDATA[tecnologia]]></category>
            <dc:creator><![CDATA[Rafael Chinaglia]]></dc:creator>
            <pubDate>Mon, 16 Mar 2026 16:05:52 GMT</pubDate>
            <atom:updated>2026-03-16T16:05:52.916Z</atom:updated>
            <content:encoded><![CDATA[<p>#79 — Protagonismo feminino em tecnologia, inovação e liderança</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ozMQLlcGrORAl2KqvLBENA.png" /></figure><p>No mês dedicado às mulheres, o <strong>TOTVS Developers Podcast</strong> apresenta um episódio especial voltado para discutir protagonismo feminino em tecnologia, inovação e liderança. Mais do que um debate conceitual, a conversa reúne profissionais que atuam diretamente na linha de frente da transformação digital.</p><p>Conduzido por <strong>Ana Claudia</strong>, o episódio reúne <strong>Letícia Liz, Djani Dalfovo e Fabiane Nardon</strong> para uma conversa sobre trajetórias profissionais, viradas de carreira, desafios estruturais e o futuro da tecnologia.</p><p>O ponto de partida da discussão é um cenário conhecido do setor. Apesar do crescimento acelerado da área de tecnologia, as mulheres ainda ocupam menos de 20% dos postos técnicos. Ao mesmo tempo, o Brasil enfrenta um déficit significativo de profissionais qualificados em TI.</p><p>Essa combinação torna a diversidade um fator cada vez mais estratégico para o desenvolvimento da indústria. Equipes diversas ampliam perspectivas, reduzem vieses e contribuem para a criação de soluções mais completas e eficazes.</p><p>Durante o episódio, as convidadas compartilham experiências pessoais e profissionais sobre momentos decisivos de carreira, a construção de liderança em ambientes técnicos e a evolução de temas centrais para o setor, como metodologias ágeis, plataformas de dados e inteligência artificial.</p><p>Entre os temas discutidos estão:</p><ul><li>as viradas de carreira que levaram cada convidada a posições de liderança</li><li>os desafios de atuar em ambientes técnicos e estratégicos</li><li>a construção de autoridade em um setor historicamente masculino</li><li>o papel da inteligência artificial no futuro do desenvolvimento de produtos e dados</li><li>conselhos práticos para mulheres que desejam construir carreira na área de tecnologia</li></ul><p>Ao longo da conversa, também emerge uma reflexão importante: ampliar a presença feminina na tecnologia não é apenas uma pauta social, mas um movimento que impacta diretamente a capacidade de inovação das organizações.</p><p>O episódio termina com uma pergunta simples, mas poderosa: <strong>qual decisão teve o maior impacto positivo na carreira de cada convidada?</strong> As respostas revelam escolhas, riscos e aprendizados que ajudam a iluminar caminhos para a próxima geração de profissionais da área.</p><p>Assista e ouça aqui: <br><a href="https://youtu.be/-lwsq25ae9I">https://youtu.be/-lwsq25ae9I</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d291e465fd0b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Web Não Foi Feita Para Agentes, e isso está começando a mudar]]></title>
            <link>https://medium.com/totvsdevelopers/a-web-n%C3%A3o-foi-feita-para-agentes-e-isso-est%C3%A1-come%C3%A7ando-a-mudar-7ae5db4c525a?source=rss-931f1fe0a8fd------2</link>
            <guid isPermaLink="false">https://medium.com/p/7ae5db4c525a</guid>
            <category><![CDATA[inteligência-artificial]]></category>
            <category><![CDATA[api]]></category>
            <category><![CDATA[desenvolvimentodesoftware]]></category>
            <category><![CDATA[agentes-de-ia]]></category>
            <category><![CDATA[desenvolvimento-web]]></category>
            <dc:creator><![CDATA[Rafael Chinaglia]]></dc:creator>
            <pubDate>Fri, 06 Mar 2026 14:51:13 GMT</pubDate>
            <atom:updated>2026-03-06T14:51:13.692Z</atom:updated>
            <content:encoded><![CDATA[<p>LIVE CODE com Yuri Nabaia</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mQ63v96uR-LGPQ5L8bOEAA.png" /></figure><p>A web que usamos todos os dias foi projetada para pessoas. Navegadores, interfaces e APIs foram pensados para usuários humanos clicando, lendo e interagindo com páginas.</p><p>Mas o avanço recente da inteligência artificial trouxe um novo tipo de usuário para a internet: os agentes.</p><p>Esses sistemas precisam acessar serviços, executar tarefas e se comunicar com aplicações de maneira estruturada. O problema é que a infraestrutura da web atual não foi construída pensando nesse tipo de interação.</p><p>Nos últimos anos começaram a surgir propostas para resolver essa limitação. Diversos novos protocolos passaram a ser discutidos no ecossistema tecnológico, com iniciativas apoiadas por empresas como Google e Microsoft.</p><p>Por isso, muitos desenvolvedores passaram a chamar 2024 de “o ano dos protocolos”, marcado pela criação de novas especificações voltadas para a integração entre agentes, ferramentas e serviços digitais.</p><p>Agora começa uma nova fase: colocar essas ideias em prática.</p><p>Neste evento de live coding exploramos algumas dessas tecnologias emergentes e demonstramos como elas podem impactar o desenvolvimento web.</p><p>Entre os temas abordados estão:</p><ul><li>o conceito de WebMCP</li><li>o uso de interfaces como AG-UI</li><li>o papel da interoperabilidade entre sistemas</li><li>como esses novos padrões podem transformar a forma como aplicações são construídas</li></ul><p>Além da discussão conceitual, o evento inclui demonstrações práticas com código, mostrando como essas tecnologias podem ser utilizadas hoje em experimentos e protótipos.</p><p><strong>Quando?</strong> 26/03, às 20h<br><strong>Onde?</strong> Youtube do TOTVS Developers</p><p>Compartilhe com sua galera e <a href="https://www.meetup.com/pt-BR/totvsdevelopers/events/313666111/">inscreva-se aqui</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7ae5db4c525a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/totvsdevelopers/a-web-n%C3%A3o-foi-feita-para-agentes-e-isso-est%C3%A1-come%C3%A7ando-a-mudar-7ae5db4c525a">A Web Não Foi Feita Para Agentes, e isso está começando a mudar</a> was originally published in <a href="https://medium.com/totvsdevelopers">TOTVS Developers</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[TOTVS Developers Podcast]]></title>
            <link>https://medium.com/totvsdevelopers/totvs-developers-podcast-f4a4af2c7d4e?source=rss-931f1fe0a8fd------2</link>
            <guid isPermaLink="false">https://medium.com/p/f4a4af2c7d4e</guid>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[dados]]></category>
            <category><![CDATA[data]]></category>
            <category><![CDATA[agilidade]]></category>
            <category><![CDATA[pipeline-de-dados]]></category>
            <dc:creator><![CDATA[Rafael Chinaglia]]></dc:creator>
            <pubDate>Tue, 10 Feb 2026 14:11:00 GMT</pubDate>
            <atom:updated>2026-02-10T14:11:00.912Z</atom:updated>
            <content:encoded><![CDATA[<h3>#78 — Agilidade orientada a resultado (Parte 2) | Pipeline de Insights</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nBPe0Ttjg5Usr5HT4NAWVw.png" /></figure><p><strong>Muitas empresas produzem dados em escala industrial. Mas poucas conseguem transformar isso em decisão.</strong></p><p>No episódio <strong>O Pipeline de Insights (Do Dado à Decisão)</strong>, a conversa parte de uma provocação simples — e incômoda: por que, mesmo cercados de dados, seguimos tomando decisões baseadas em feeling, urgência ou pressão política?</p><p>O problema não está na falta de dados. Está no excesso de <strong>reporting sem contexto</strong>, na baixa confiança na qualidade da informação e na desconexão entre métricas operacionais, produto e estratégia.</p><p>Ao longo do episódio, discutimos como construir um pipeline de insights que realmente funcione — aquele que começa no dado bruto, passa pela pergunta certa e termina em uma decisão consciente.</p><p>Falamos sobre o papel das áreas de agilidade nesse processo, indo além de métricas como throughput e lead time, e ajudando times de produto e negócio a enxergar padrões, riscos e oportunidades. Também abordamos por que tantos times ainda tratam dados como uma obrigação do passado, em vez de uma ferramenta para desenhar o futuro.</p><p>Outro ponto central da conversa é a <strong>qualidade dos dados</strong>. Antes de decidir, é preciso confiar. E decisões ruins baseadas em dados ruins são, muitas vezes, piores do que decidir sem dado nenhum.</p><p>Este episódio é um convite para sair do dashboard bonito e entrar no território mais difícil — e mais valioso — dos insights que geram boas perguntas e melhores decisões.</p><p>Assista aqui:<br><a href="https://www.youtube.com/watch?v=POPrjAT1OSI">https://www.youtube.com/watch?v=POPrjAT1OSI</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f4a4af2c7d4e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/totvsdevelopers/totvs-developers-podcast-f4a4af2c7d4e">TOTVS Developers Podcast</a> was originally published in <a href="https://medium.com/totvsdevelopers">TOTVS Developers</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Angular v21 e o Fim da Cobertura de Testes Exclusivamente em TypeScript: Por Que Precisamos…]]></title>
            <link>https://medium.com/totvsdevelopers/angular-v21-e-o-fim-da-cobertura-de-testes-exclusivamente-em-typescript-por-que-precisamos-ec8999dbc7f4?source=rss-931f1fe0a8fd------2</link>
            <guid isPermaLink="false">https://medium.com/p/ec8999dbc7f4</guid>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[desenvolvimento-software]]></category>
            <category><![CDATA[teste]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[angular]]></category>
            <dc:creator><![CDATA[Rafael Chinaglia]]></dc:creator>
            <pubDate>Wed, 21 Jan 2026 17:03:15 GMT</pubDate>
            <atom:updated>2026-01-21T17:03:15.969Z</atom:updated>
            <content:encoded><![CDATA[<h3>Angular v21 e o Fim da Cobertura de Testes Exclusivamente em TypeScript: Por Que Precisamos Repensar os Testes de Componentes</h3><p>Artigo de Loiane Groner para o iMasters</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*kcw2PHHf5LEZweioGa7H4g.png" /></figure><p>Neste artigo, vamos explorar uma mudança significativa no Angular v21 que afeta a forma como testamos nossos componentes. O Angular v21 introduz o Vitest como a biblioteca de testes padrão, substituindo a antiga configuração Jasmine/Karma. Embora isso possa parecer apenas uma atualização de ferramentas, tem implicações profundas para nossas estratégias de teste.</p><p>A verdadeira mudança reside na adequação às diretrizes de estilo modernas do Angular, no encapsulamento apropriado e na cobertura de testes precisa.</p><p>Se você atualizou recentemente para o Angular v21 (ou migrou para o Vitest) e de repente notou lacunas de cobertura que não existiam antes, não se preocupe. Vamos explorar por que isso está acontecendo e como adaptar seus testes para atender às expectativas do Angular.</p><blockquote><em>Este é um artigo de opinião sobre os próximos passos nos testes com Angular v21+.</em></blockquote><ul><li><a href="https://loiane.com/2025/12/angular-v21-template-coverage-testing/#the-legacy-mental-model-typescript-only-coverage">O Modelo Mental Legado: Cobertura Exclusiva de TypeScript</a></li><li><a href="https://loiane.com/2025/12/angular-v21-template-coverage-testing/#angular-v21--vitest-templates-are-now-part-of-coverage">Angular v21 + Vitest: Os modelos agora fazem parte da cobertura de testes.</a></li><li><a href="https://loiane.com/2025/12/angular-v21-template-coverage-testing/#the-impact-of-protected-members">O impacto dos membros protegidos</a></li><li><a href="https://loiane.com/2025/12/angular-v21-template-coverage-testing/#a-real-example-productlistcomponent">Um exemplo real: componente ProductListComponent</a></li><li><a href="https://loiane.com/2025/12/angular-v21-template-coverage-testing/#the-legacy-test-pattern-pre-v21">Padrão de teste legado (pré-v21)</a></li><li><a href="https://loiane.com/2025/12/angular-v21-template-coverage-testing/#the-challenge-protected-apis-are-not-test-friendly">O desafio: APIs protegidas não são fáceis de testar.</a></li><li><a href="https://loiane.com/2025/12/angular-v21-template-coverage-testing/#the-solution-test-through-the-template">A solução: Teste através do modelo</a></li><li><a href="https://loiane.com/2025/12/angular-v21-template-coverage-testing/#what-changes-in-practice">Que mudanças ocorrem na prática?</a></li><li><a href="https://loiane.com/2025/12/angular-v21-template-coverage-testing/#conclusion">Conclusão</a></li></ul><h3>O Modelo Mental Legado: Cobertura Exclusiva de TypeScript</h3><p>Durante muito tempo, os aplicativos Angular foram testados usando:</p><ul><li>Jasmim + Karma</li><li>Configurações baseadas em Jest</li></ul><p>Independentemente do executor, <strong>a cobertura era efetivamente exclusiva do TypeScript</strong> :</p><ul><li>.tsos arquivos foram instrumentados</li><li>.htmlOs modelos geralmente eram ignorados.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*LOeWyMtS1OgVufAv.jpeg" /></figure><p>Isso levou a um padrão de teste comum, no qual os desenvolvedores costumavam:</p><ul><li>Chame os métodos dos componentes diretamente (já que eles eram públicos).</li><li>Ler ou modificar propriedades de componentes em testes (já que eram públicas)</li><li>Afirmar sobre o estado interno</li></ul><p>Enquanto o método fosse executado, a cobertura aumentava, <strong>mesmo que o modelo nunca exercesse essa lógica</strong> .</p><p>O resultado? Altas métricas de cobertura que pareciam ótimas no papel, mas não refletiam com precisão a confiabilidade da interface do usuário.</p><h3>Angular v21 + Vitest: Os modelos agora fazem parte da cobertura de testes.</h3><p>O Angular v21 altera a configuração de teste padrão para <strong>Vitest</strong> . A mudança mais significativa está na forma como a cobertura é relatada:</p><blockquote><strong><em>Os modelos HTML agora estão incluídos nos relatórios de cobertura.</em></strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*badW3wM0fcZY4iP7.jpeg" /></figure><p>O que isso significa na prática? A cobertura agora inclui:</p><ul><li>Associações de eventos como (click)e(change)</li><li>Renderização condicional ( @ife outros controles)</li><li>Diretrizes estruturais</li><li>Caminhos de execução orientados por modelos</li></ul><p>Como resultado:</p><ul><li>Chamar um método de componente diretamente não “encobre” mais a lógica do template.</li><li>Agora, as lacunas de cobertura aparecem exatamente onde a interface do usuário não está sendo utilizada.</li></ul><p>Isso não é uma regressão. É o Angular fornecendo uma visão mais precisa e honesta da saúde da sua aplicação.</p><h3>O impacto dos membros protegidos</h3><p>Desde a versão 20 do Angular, o <a href="https://angular.dev/style-guide#use-protected-on-class-members-that-are-only-used-by-a-components-template">guia de estilo do Angular</a> recomenda:</p><blockquote><em>Dê preferência ao acesso protegido para quaisquer membros que devam ser lidos a partir do modelo do componente.</em></blockquote><p>Isso adiciona mais um desafio à abordagem de teste legada. Se um membro for `null` protected, ele não estará acessível no seu arquivo de teste. Você não pode simplesmente acessar o componente e verificar uma propriedade ou chamar um método diretamente.</p><p>O que isso significa? Mesmo que você quisesse ignorar o modelo e testar a lógica diretamente, o TypeScript não permitiria.</p><p>Portanto, temos duas forças nos impulsionando na mesma direção:</p><ol><li><strong>O Vitest</strong> requer a execução de um modelo para cobertura.</li><li><strong>O Guia de Estilo do Angular</strong> restringe o acesso à lógica interna dos componentes.</li></ol><p>A mensagem é clara: <strong>pare de testar detalhes de implementação. Comece a testar o comportamento.</strong></p><h3>Um exemplo real: componente ProductListComponent</h3><p>Para ilustrar isso, vejamos um exemplo real. O ProductListComponentexemplo do meu <a href="https://github.com/loiane/modern-angular">modern-angular</a>repositório demonstra esse padrão:</p><pre>app/products/product-list</pre><p>Este componente foi projetado seguindo os padrões modernos do Angular:</p><ul><li><strong>Lógica orientada a modelos</strong> : O modelo gerencia as interações do usuário.</li><li><strong>Membros protegidos</strong> : Propriedades e métodos usados ​​apenas no modelo são marcados comoprotected</li><li><strong>API pública mínima</strong> : O componente expõe apenas o que é estritamente necessário.</li></ul><p>Este design segue as recomendações que o guia de estilo do Angular vem incentivando desde a versão 20.</p><h3>Padrão de teste legado (pré-v21)</h3><p>Antes do Angular v21, um teste típico geralmente se parecia com isto:</p><pre>it(&#39;filters products by category&#39;, () =&gt; {<br>  component.selectedCategory = &#39;Books&#39;;<br>  component.applyFilter();</pre><pre>  expect(component.filteredProducts.length).toBe(2);<br>});</pre><p>Por que isso <em>pareceu</em> correto?</p><ul><li>O método foi executado com sucesso.</li><li>As afirmações foram aprovadas.</li><li>As métricas de cobertura do TypeScript aumentaram.</li></ul><p>No entanto, eis o que realmente aconteceu:</p><ul><li>O modelo nunca esteve envolvido no teste.</li><li>Nenhuma interação do usuário (clique, entrada de dados, etc.) foi simulada.</li><li>O teste validou detalhes da implementação, não o comportamento real.</li></ul><p>Com o Vitest, a cobertura de HTML permanece intacta e os relatórios de cobertura revelam a verdade: <strong>o componente não foi totalmente testado</strong> .</p><h3>O desafio: APIs protegidas não são fáceis de testar.</h3><p>Em componentes Angular modernos:</p><ul><li>Propriedades e métodos exclusivos do modelo são marcados com protected.</li><li>O TypeScript impede corretamente o acesso direto a esses membros a partir dos testes.</li></ul><p>Isso cria atrito para estilos de teste legados. Soluções alternativas comuns incluem:</p><ul><li>Convertendo o componente para any.</li><li>Métodos de criação criados publicexclusivamente para fins de teste.</li></ul><p>Mas, com a cobertura que leva em consideração os modelos, essas soluções alternativas falham por dois motivos:</p><ol><li>Eles violam os princípios de encapsulamento.</li><li>Eles não melhoram a cobertura do modelo.</li></ol><p>O Angular está basicamente nos dizendo: <strong>se o seu teste não passar pelo modelo, ele não conta.</strong></p><h3>A solução: Teste através do modelo</h3><p>A solução não é lutar contra o framework, mas sim <strong>mudar a forma como testamos os componentes</strong> .</p><p>Em vez de invocar a lógica diretamente, devemos:</p><ul><li>Interagir com o DOM</li><li>Eventos de gatilho</li><li>Verifique a saída renderizada</li></ul><p>Vamos refatorar o teste anterior para seguir esta abordagem:</p><pre>it(&#39;filters products when a category is selected&#39;, async () =&gt; {<br>  const select = fixture.nativeElement.querySelector(&#39;select&#39;);</pre><pre>  select.value = &#39;Books&#39;;<br>  select.dispatchEvent(new Event(&#39;change&#39;));<br>  fixture.detectChanges();</pre><pre>  const items = fixture.nativeElement.querySelectorAll(&#39;.product-item&#39;);<br>  expect(items.length).toBe(2);<br>});</pre><p><strong>O que está acontecendo aqui?</strong></p><ul><li>A interação de teste começa com o modelo (como os usuários realmente usam seu aplicativo).</li><li>A lógica protegida permanece protegida (encapsulamento adequado).</li><li>A cobertura agora inclui <strong>TypeScript e HTML.</strong></li></ul><p>Este teste reflete como os usuários realmente interagem com o componente, garantindo uma aplicação mais robusta e confiável.</p><blockquote><em>💡 </em><strong><em>Bônus</em></strong><em> : Você obtém cobertura de testes tanto para o modelo HTML quanto para o código TypeScript dentro do componente!</em></blockquote><h3>Que mudanças ocorrem na prática?</h3><p>Com o Angular v21+, seus testes devem:</p><ul><li><strong>Prefira a interação com o DOM</strong> em vez de chamadas de método.</li><li><strong>Afirme o comportamento visível</strong> , não o estado interno.</li><li><strong>Considere o modelo como o ponto de entrada.</strong></li></ul><p>O que você ganhará com essa mudança:</p><ul><li>Os testes tornam-se mais fáceis de refatorar.</li><li>O encapsulamento melhora naturalmente</li><li>Os números de cobertura finalmente refletem o uso real.</li></ul><p>Isso está perfeitamente alinhado com a direção de design do Angular e com as melhores práticas modernas de teste.</p><h3>Conclusão</h3><p>Ao atualizar para o Angular v21 + Vitest, espere o seguinte:</p><ul><li>Observe a queda na cobertura em componentes com uso intensivo de interface do usuário.</li><li>Identifique testes que exercitem apenas a lógica TS.</li><li>Reescreva os testes para acionar o comportamento por meio do modelo assim que você tornar as propriedades e os métodos protegidos.</li></ul><p>Cobertura de versões pré-Angular v21 com Jest:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Q8NREbopY3kTHH4g.jpeg" /></figure><p>Angular v21 com Vitest:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yM6D-N-06_hf4FHI.jpeg" /></figure><p>Inicialmente, essa mudança parece desconfortável. Mas, na realidade, o Angular v21 está fazendo algo importante:</p><ul><li>Alinhar as diretrizes de estilo com as ferramentas.</li><li>Incentivar testes baseados no comportamento</li><li>Eliminando a falsa confiança da cobertura exclusiva de TS</li></ul><p>O Angular não está tornando os testes mais difíceis. Está tornando os testes <strong>mais honestos</strong> .</p><p>Boa programação!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ec8999dbc7f4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/totvsdevelopers/angular-v21-e-o-fim-da-cobertura-de-testes-exclusivamente-em-typescript-por-que-precisamos-ec8999dbc7f4">Angular v21 e o Fim da Cobertura de Testes Exclusivamente em TypeScript: Por Que Precisamos…</a> was originally published in <a href="https://medium.com/totvsdevelopers">TOTVS Developers</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[O impacto da IA generativa no suporte técnico: o que muda para TI]]></title>
            <link>https://medium.com/totvsdevelopers/o-impacto-da-ia-generativa-no-suporte-t%C3%A9cnico-o-que-muda-para-ti-1f64d8a33e52?source=rss-931f1fe0a8fd------2</link>
            <guid isPermaLink="false">https://medium.com/p/1f64d8a33e52</guid>
            <category><![CDATA[generative-ai-tools]]></category>
            <category><![CDATA[ia-generativa]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Rafael Chinaglia]]></dc:creator>
            <pubDate>Wed, 14 Jan 2026 11:07:19 GMT</pubDate>
            <atom:updated>2026-01-14T11:07:19.910Z</atom:updated>
            <content:encoded><![CDATA[<p>Artigo de Edsel Simas para o iMasters</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*qiebJyYTyGixvGG9G9MxFQ.jpeg" /></figure><p>O avanço da IA generativa nos ambientes corporativos está pressionando áreas historicamente operacionais a revisarem seus modelos de atuação. O service desk é um dos casos mais visíveis. A adoção de LLMs (Large Language Models) em fluxos de atendimento técnico alterou não apenas a jornada do usuário, mas a própria lógica de triagem, resolução e escalonamento de incidentes. O ponto central não é se a IA substitui o analista, mas sim como ela redesenha a arquitetura operacional e impõe novas exigências à equipe de suporte.</p><p>Diferentemente das ondas anteriores de automação, centradas em scripts estáticos e bots de interação linear, o que se vê agora é a incorporação de motores de linguagem capazes de interpretar, inferir e sugerir ações a partir de descrições ambíguas ou mal formuladas. Isso altera radicalmente o desenho de operação dos service desks, reposicionando o analista humano como um elo crítico entre o conhecimento técnico acumulado e os sistemas de inferência probabilística que passaram a mediar parte significativa do atendimento.</p><p>No plano tático, a introdução de IA generativa reconfigura o ciclo de vida de um chamado. A entrada, antes limitada a formulários predefinidos ou atendentes humanos, agora pode ser feita via linguagem natural, interpretada em tempo real por um modelo de linguagem treinado em tickets históricos, bases de conhecimento e logs operacionais.</p><p>A partir desse ponto, o sistema classifica o chamado, sugere prioridade com base em contexto, tais como frequência, impacto, criticidade, histórico de incidentes correlatos, e até propõe soluções com base em respostas anteriores — que podem ser automaticamente redigidas, testadas e enviadas ao usuário final, dependendo do grau de autonomia definido pela política interna. O analista não desaparece desse fluxo, mas passa a operar em outra instância: como validador, auditor e — mais importante — como modelador do próprio conhecimento que alimenta a IA.</p><h3>Um novo campo de atuação para o atendimento humano</h3><p>Esse deslocamento funcional exige uma requalificação estrutural do papel do analista. A lógica anterior, centrada na execução direta e no conhecimento operacional tácito, dá lugar a uma demanda por competências interpretativas e estruturantes. O analista precisa entender como a IA toma decisões, quais vieses podem comprometer a acurácia das sugestões, como os dados de entrada, sintéticos, ruidosos ou incompletos, afetam o resultado, e de que modo se controla a degradação de performance dos modelos com o tempo.</p><p>Esse novo perfil não é um luxo de empresas de ponta, mas uma resposta direta às pressões por redução de SLA e aumento da taxa de resolução de primeira linha. Em muitas operações, os tickets de baixa complexidade estão sendo inteiramente absorvidos por sistemas de IA. Isso tende a elevar artificialmente a complexidade média dos chamados restantes, o que, se não for devidamente interpretado pelas lideranças, pode dar a falsa impressão de queda de performance humana, quando na verdade é reflexo da filtragem automatizada.</p><p>É nesse ponto que o analista precisa ser mais do que um resolvedor de tickets: ele passa a ser um intérprete da própria estrutura do suporte, atuando na reconfiguração contínua dos fluxos, na calibragem dos modelos e na gestão ativa da base de conhecimento.</p><h3>Curva de adoção no Brasil</h3><p>No país, existem diferentes estágios de adoção dessas tecnologias. Enquanto grandes operações corporativas já testam copilotos de IA para auxiliar seus analistas em tempo real, sugerindo scripts, comandos ou diagnósticos com base em padrões extraídos de tickets anteriores, a maioria das empresas opera em um modelo híbrido, onde fluxos automatizados convivem com zonas manuais de contenção.</p><p>A questão central, porém, é menos tecnológica do que organizacional: a IA já está presente, mas o arcabouço de governança, curadoria de dados e capacitação técnica ainda engatinha. Isso gera uma tensão estrutural: a promessa de ganho de eficiência não se sustenta se a equipe humana não souber operar, validar e evoluir o sistema.</p><p>Outro ponto relevante é a forma como a IA responde às demandas. Modelos generativos operam por inferência estatística, ou seja, sugerem a resposta mais provável, não necessariamente a mais correta. Em ambientes de suporte técnico, onde a margem de erro pode comprometer a segurança da informação, a estabilidade do ambiente ou o atendimento a requisitos regulatórios, isso impõe a necessidade de filtros humanos qualificados.</p><p>A supervisão analítica passa a ser mandatória: o analista precisa saber identificar alucinações do modelo, respostas fora de escopo ou inferências equivocadas geradas por bases mal treinadas.</p><p>Essa supervisão, aliás, é parte de uma camada estratégica de operação que tende a se expandir. Na medida q em que a IA assume tarefas de baixa densidade cognitiva, o analista de suporte é puxado para camadas de decisão mais complexas, como a integração entre ferramentas de observabilidade e sistemas de resposta automática, a configuração de alertas preditivos com base em aprendizado contínuo, ou a definição de parâmetros de auto escalonamento.</p><p>O suporte técnico passa a ser, então, um nó crítico na cadeia de resiliência operacional das empresas. E o analista que se adapta a esse novo papel deixa de ser executor de tarefas e passa a ser curador de inteligência.</p><p>Em síntese, a IA generativa não representa uma ameaça ao trabalho humano no suporte técnico — mas impõe uma mudança de ordem. O modelo operacional se reconfigura, e com ele a exigência de novas habilidades, novas linguagens e novos modelos mentais. O analista que entender essa transição e assumir um papel ativo na arquitetura e curadoria dos sistemas inteligentes terá não apenas lugar garantido no novo ecossistema — mas protagonismo. Ignorar esse movimento é uma escolha que cobra um preço: o da irrelevância técnica em um setor onde a automação já deixou de ser promessa e se tornou infraestrutura.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1f64d8a33e52" width="1" height="1" alt=""><hr><p><a href="https://medium.com/totvsdevelopers/o-impacto-da-ia-generativa-no-suporte-t%C3%A9cnico-o-que-muda-para-ti-1f64d8a33e52">O impacto da IA generativa no suporte técnico: o que muda para TI</a> was originally published in <a href="https://medium.com/totvsdevelopers">TOTVS Developers</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[TOTVS Developers Podcast #76]]></title>
            <link>https://medium.com/totvsdevelopers/totvs-developers-podcast-76-03130b0a07eb?source=rss-931f1fe0a8fd------2</link>
            <guid isPermaLink="false">https://medium.com/p/03130b0a07eb</guid>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[agile-coaching]]></category>
            <category><![CDATA[agile-development]]></category>
            <category><![CDATA[agile-methodology]]></category>
            <category><![CDATA[agilidade]]></category>
            <dc:creator><![CDATA[Rafael Chinaglia]]></dc:creator>
            <pubDate>Tue, 02 Dec 2025 01:02:39 GMT</pubDate>
            <atom:updated>2025-12-02T01:02:39.989Z</atom:updated>
            <content:encoded><![CDATA[<h3>Agile Outcome — Agilidade orientada a resultado (Parte 1)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3xHCKXMSMLem8nKqLK2NjA.png" /></figure><h3>Agile Outcome — Agilidade orientada a resultado</h3><p>No episódio de hoje, conversa com dois convidados incríveis sobre um tema que tá tirando o sono de muita gente que trabalha com Produto, Engenharia, Design e Dados: como, na prática, operar “como um só produto” dentro de uma estrutura gigante e cheia de times diferentes.</p><p>Os convidados foram: <a href="https://www.linkedin.com/in/alaim/">Alaim Alvarenga</a> e <a href="https://www.linkedin.com/in/brunolaia/">Bruno Laia</a></p><p>O papo passou por questões que todo mundo enfrenta no dia a dia:</p><p>— Por que a cultura pesa mais que o processo? <br>— Como criar integração real entre áreas que historicamente trabalham separadas? <br>— Onde a agilidade faz diferença quando o foco é eficiência, decisão estratégica e resultado?<br> — Como manter cadência e coerência sem matar a autonomia dos times? <br>— Que tipos de atritos ainda aparecem — e como resolver isso sem drama? <br>— O que aprendemos integrando equipes com níveis diferentes de maturidade?<br> — E qual é aquele sinal claro de que o time finalmente virou a chave e começou a operar de forma integrada?</p><p>O papo rendeu — e, pra ser sincero, não deu tempo de falar tudo. Então já deixo o aviso: vem mais episódio por aí, expandindo esse tema que dá pano pra manga em qualquer organização que quer ser de verdade orientada a resultado. Se você curte discussões práticas sobre agilidade, cultura e produto, já acompanha esse episódio e fica ligado nos próximos. Bora juntos</p><p>Assista e ouça aqui:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FbPeqcXswdAw%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DbPeqcXswdAw&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FbPeqcXswdAw%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/e6f46b39fd1ca0ab4dd8e0cc7911bdc1/href">https://medium.com/media/e6f46b39fd1ca0ab4dd8e0cc7911bdc1/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=03130b0a07eb" width="1" height="1" alt=""><hr><p><a href="https://medium.com/totvsdevelopers/totvs-developers-podcast-76-03130b0a07eb">TOTVS Developers Podcast #76</a> was originally published in <a href="https://medium.com/totvsdevelopers">TOTVS Developers</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[TOTVS Developers Podcast #75]]></title>
            <link>https://medium.com/totvsdevelopers/totvs-developers-podcast-75-414cceae1703?source=rss-931f1fe0a8fd------2</link>
            <guid isPermaLink="false">https://medium.com/p/414cceae1703</guid>
            <category><![CDATA[projetos-de-software]]></category>
            <category><![CDATA[gestão-de-projetos]]></category>
            <category><![CDATA[software]]></category>
            <dc:creator><![CDATA[Rafael Chinaglia]]></dc:creator>
            <pubDate>Tue, 11 Nov 2025 02:06:56 GMT</pubDate>
            <atom:updated>2025-11-11T02:06:56.763Z</atom:updated>
            <content:encoded><![CDATA[<h3>Gestão de Projetos de Software</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hsZ4fQ8JVLr_WHRdnAirWw.jpeg" /></figure><p>Neste episódio, recebemos Levi Tancredo, Coordenador de Desenvolvimento de Software e Team Leader, para um bate-papo sobre os principais desafios e práticas da gestão de projetos de software.</p><p>A conversa passa por temas como:</p><ul><li>Diferenças entre um gestor e um desenvolvedor técnico que assume a função;</li><li>Como equilibrar prazos, custos e qualidade em projetos complexos;</li><li>O papel da comunicação em times distribuídos e remotos;</li><li>Quando aplicar metodologias ágeis e quando optar por modelos mais tradicionais;</li><li>Estratégias para lidar com mudanças de escopo e conflitos entre stakeholders e equipe;</li><li>Métricas essenciais para medir o sucesso de um projeto;</li><li>Ferramentas e habilidades para quem deseja migrar para a gestão;</li><li>E como a inteligência artificial pode transformar a área nos próximos anos.</li></ul><p>Se você é desenvolvedor, gestor ou está de olho em dar os próximos passos na carreira, esse episódio traz insights valiosos e práticos sobre como encarar a gestão de desenvolvimento de software no dia a dia.</p><p>Assista e ouça aqui:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FZ1IP2PnqUwk%3Flist%3DPLeuob2rvkwP-iL6bNDRcvXFTrh9lJVf3P&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DZ1IP2PnqUwk&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FZ1IP2PnqUwk%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/bdbf4ae61dbe26699d7f0b5d65476dbd/href">https://medium.com/media/bdbf4ae61dbe26699d7f0b5d65476dbd/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=414cceae1703" width="1" height="1" alt=""><hr><p><a href="https://medium.com/totvsdevelopers/totvs-developers-podcast-75-414cceae1703">TOTVS Developers Podcast #75</a> was originally published in <a href="https://medium.com/totvsdevelopers">TOTVS Developers</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[TOTVS Developers Podcast #74]]></title>
            <link>https://medium.com/totvsdevelopers/totvs-developers-podcast-74-a86ad646cb4a?source=rss-931f1fe0a8fd------2</link>
            <guid isPermaLink="false">https://medium.com/p/a86ad646cb4a</guid>
            <category><![CDATA[podcasting]]></category>
            <category><![CDATA[podcast]]></category>
            <category><![CDATA[totvs-developers]]></category>
            <dc:creator><![CDATA[Rafael Chinaglia]]></dc:creator>
            <pubDate>Wed, 08 Oct 2025 14:39:42 GMT</pubDate>
            <atom:updated>2025-10-08T14:39:42.327Z</atom:updated>
            <content:encoded><![CDATA[<p>Dev além do código</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7Cfl9Llsl10GJ_VSiyXKuw.png" /></figure><p>Existe vida além do ambiente de trabalho?</p><p>Developers estão 24 horas por dia pensando em como ganhar dinheiro?</p><p>Como é a descompressão de uma pessoa desenvolvedora?</p><p>No episódio #74 do TOTVS Developers Podcast, a conversa vai além da programação. 🚀</p><p>O tema é “Dev além do código”, explorando como o papel do desenvolvedor não se limita apenas a escrever linhas de código.</p><p>Falamos sobre soft skills, colaboração, comunicação, visão de negócio e impacto dentro das equipes e organizações.</p><p>Nesse bate-papo, mostramos que ser um bom dev vai muito além da parte técnica: envolve também saber lidar com pessoas, trabalhar em equipe, aprender constantemente e se adaptar a novos desafios. 💡</p><p>🔗 Ouça agora o TOTVS Developers Podcast #74 — Dev além do código e descubra como desenvolver não só software, mas também uma mentalidade preparada para o futuro.</p><p>Assista e ouça aqui:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FWZKCPsZBx28%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DWZKCPsZBx28&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FWZKCPsZBx28%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/d53b034e43e79b7f90c651f6e65098e6/href">https://medium.com/media/d53b034e43e79b7f90c651f6e65098e6/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a86ad646cb4a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/totvsdevelopers/totvs-developers-podcast-74-a86ad646cb4a">TOTVS Developers Podcast #74</a> was originally published in <a href="https://medium.com/totvsdevelopers">TOTVS Developers</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>