<?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 Valmar Júnior on Medium]]></title>
        <description><![CDATA[Stories by Valmar Júnior on Medium]]></description>
        <link>https://medium.com/@valmarjunior?source=rss-1177d249fdce------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*f4_9wW0gHa3glM7YBVyMQw.jpeg</url>
            <title>Stories by Valmar Júnior on Medium</title>
            <link>https://medium.com/@valmarjunior?source=rss-1177d249fdce------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 19:14:50 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@valmarjunior/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[Java: The Language that Reinvented Itself 23 Times]]></title>
            <link>https://medium.com/@valmarjunior/java-the-language-that-reinvented-itself-23-times-95bbe58e48ed?source=rss-1177d249fdce------2</link>
            <guid isPermaLink="false">https://medium.com/p/95bbe58e48ed</guid>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Valmar Júnior]]></dc:creator>
            <pubDate>Tue, 17 Sep 2024 00:00:14 GMT</pubDate>
            <atom:updated>2024-09-17T00:00:14.238Z</atom:updated>
            <content:encoded><![CDATA[<p>Recently, while scrolling through LinkedIn, I stumbled upon a meme that stopped me in my tracks and got me thinking:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/567/1*WDnephtWQT2vyFJyLo-oiw.png" /></figure><p>My reaction was a mix of nostalgic smile, fascination, and slight discomfort. Java version 23? Wow! It’s impressive to think that, since its launch decades ago, the platform has evolved so rapidly and drastically.</p><p>When I entered college, around 2011, the Java landscape was completely different from what we see today. Java 7 had just been released, bringing new features like try-with-resources and switch with Strings. However, Java 6 still reigned supreme in the market and classrooms. It was with this version that I had my first real contact with the language, both in college projects and my first internship.</p><p>Back then, as nostalgics will remember, Java web development was dominated by a set of technologies that may seem outdated today, but were state-of-the-art:</p><ol><li>JSF (JavaServer Faces): Frameworks like PrimeFaces were at their peak, promising rapid development of rich interfaces.</li><li>JSP (JavaServer Pages): Still widely used, especially in legacy systems.</li><li>Servlets: The fundamental basis of every Java web project.</li><li>And, of course, the inevitable AJAX:</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/567/1*skbDTsHbuF-X_w04mExZjg.png" /></figure><p>AJAX was ubiquitous, transforming web applications from static pages into dynamic and interactive experiences. Learning to use XMLHttpRequest was practically a rite of passage for every web developer of the time.</p><p>Back then, we worked on complex web applications, where “responsive front-end” was an emerging concept and Java backend reigned supreme in enterprise development. .NET was beginning to emerge as a competitor, but it was still too early to threaten Java’s dominance.</p><p>And microservices? No way! The concept was barely crawling, facing considerable resistance. Pioneers like Martin Fowler and James Lewis were just beginning to explore and document this revolutionary approach that would completely change the way we think about software architecture.</p><p>Monolithic architecture was supreme. Imagine gigantic ERP systems, with millions of lines of code, all in a single Java project. Developers prided themselves on the size of their WARs and EARs, as if the weight of the file was a trophy. It was common to hear phrases like “My WAR is 150MB, the system must be very important!”</p><p>I’ll leave these nostalgic memories for another article! What really motivated me to write this text was a worrying realization: many developers end up becoming “blind” to new releases of the technologies they use daily. It’s understandable — the pace of technological evolution is frantic, and staying up-to-date can seem like a difficult task.</p><p>However, this “blindness” can be dangerous. We get stuck with obsolete practices, miss opportunities to improve our productivity, and worse, run the risk of becoming obsolete in the market.</p><p>With this in mind, I decided to embark on an ambitious project: a series of articles covering the evolution of Java, from version 6 to the most recent, 23. My goal is to help my fellow developers understand what has changed in each version, and this will help me too, of course 😊. We’ll highlight the main innovations, performance improvements, and new functionalities that have emerged over the years.</p><p>In this journey, we’ll explore how Java transformed from a relatively simple language into a robust and versatile platform. We’ll see the introduction of features that broke the comfort zone of many devs in Java 6, like the Diamond Operator and try-with-resources. We’ll go through the lambda revolution in Java 8, which completely changed the way we write code. We’ll explore the module system introduced in Java 9, which brought a new dimension to application modularity. And, of course, we’ll dive into recent advances in concurrency and performance in the most recent versions.</p><p>Additionally, we’ll correlate these changes with the main frameworks that supported Java during this time. We’ll see how Spring evolved along with the language, adopting new features and patterns. We’ll observe the rise of frameworks like Quarkus and Micronaut, which took advantage of performance improvements in the most recent Java versions. We’ll analyze how Hibernate adapted to changes in JPA and how testing frameworks, like JUnit and Mockito, evolved to make our tests more robust and expressive.</p><p>Get ready for a fascinating journey through Java’s recent history. From Java 6 to 23, we’ll unravel together how each version, along with its ecosystem, shaped software development as we know it today.</p><p>Stay tuned for the next article, where we’ll begin our journey with Java 6 and the changes that began to pave the way for modern Java!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=95bbe58e48ed" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Java: A Linguagem que se Reinventou 23 Vezes]]></title>
            <link>https://medium.com/@valmarjunior/java-a-linguagem-que-se-reinventou-23-vezes-0d34d098e1f3?source=rss-1177d249fdce------2</link>
            <guid isPermaLink="false">https://medium.com/p/0d34d098e1f3</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[history-web-development]]></category>
            <category><![CDATA[ajax]]></category>
            <dc:creator><![CDATA[Valmar Júnior]]></dc:creator>
            <pubDate>Mon, 16 Sep 2024 23:39:39 GMT</pubDate>
            <atom:updated>2024-09-16T23:39:39.930Z</atom:updated>
            <content:encoded><![CDATA[<p>Esses dias, navegando pelo LinkedIn, deparei-me com um meme que me fez parar e refletir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/567/1*WDnephtWQT2vyFJyLo-oiw.png" /></figure><p>Minha reação foi um misto de sorriso nostálgico, fascínio e um leve desconforto. Java na versão 23? Uau! É impressionante pensar que, desde seu lançamento há décadas, a plataforma evoluiu tão rápida e drasticamente.</p><p>Quando ingressei na faculdade, lá por volta de 2011, o cenário do Java era completamente diferente do que vemos hoje. O <a href="https://docs.oracle.com/javase/7/docs/technotes/guides/language/">Java 7</a> tinha acabado de ser lançado, trazendo novidades como o <a href="https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html">try-with-resources</a> e o switch com Strings. No entanto, o Java 6 ainda reinava supremo no mercado e nas salas de aula. Foi com essa versão que tive meu primeiro contato real com a linguagem, tanto nos projetos da faculdade quanto no meu primeiro estágio.</p><p>Naquela época, os saudosistas vão lembrar, o desenvolvimento web Java era dominado por um conjunto de tecnologias que hoje podem parecer antiquadas, mas que eram o estado da arte:</p><p>1. <a href="https://www.oracle.com/java/technologies/javaserverfaces.html">JSF (JavaServer Faces)</a>: Frameworks como <a href="https://www.primefaces.org/">PrimeFaces</a> estavam no auge, prometendo desenvolvimento rápido de interfaces ricas.</p><p>2. <a href="https://www.oracle.com/java/technologies/jspt.html">JSP (JavaServer Pages)</a>: Ainda amplamente utilizado, especialmente em sistemas legados.</p><p>3. <a href="https://docs.oracle.com/javaee/7/tutorial/servlets.htm">Servlets</a>: A base fundamental de todo projeto web Java.</p><p>4. E, é claro, o inevitável <a href="https://developer.mozilla.org/en-US/docs/Web/Guide/AJAX">AJAX</a>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/567/1*skbDTsHbuF-X_w04mExZjg.png" /></figure><p>AJAX era onipresente, transformando as aplicações web de páginas estáticas em experiências dinâmicas e interativas. Aprender a usar <a href="https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest"><strong><em>XMLHttpRequest</em></strong></a><em> </em>era praticamente um rito de passagem para todo desenvolvedor web da época.</p><p>Naquele tempo, trabalhávamos em aplicações web complexas, onde “front-end responsivo” era um conceito emergente e o backend Java reinava absoluto no desenvolvimento empresarial. O .NET começava a despontar como concorrente, mas ainda era cedo para ameaçar o domínio do Java.</p><p>E microserviços? Nem pensar! O conceito mal engatinhava, enfrentando resistência considerável. Pioneiros como <a href="https://martinfowler.com/articles/microservices.html">Martin Fowler</a> e <a href="https://twitter.com/boicy">James Lewis</a> estavam apenas começando a explorar e documentar essa abordagem revolucionária, que mudaria completamente a forma como pensamos arquitetura de software.</p><p>A arquitetura monolítica era suprema. Imagine sistemas ERP gigantescos, com milhões de linhas de código, todos em um único projeto Java. Desenvolvedores se orgulhavam do tamanho de seus WARs e EARs, como se o peso do arquivo fosse um troféu. Era comum ouvir frases como “Meu WAR tem 150MB, o sistema deve ser muito importante!”</p><p>Vou deixar essas lembranças saudosas para outro artigo! O que realmente me motivou a escrever este texto foi uma constatação preocupante: muitos desenvolvedores acabam ficando “cegos” às novas releases das tecnologias que usam diariamente. É compreensível — o ritmo da evolução tecnológica é frenético, e manter-se atualizado pode parecer uma tarefa difícil.</p><p>No entanto, essa “cegueira” pode ser perigosa. Ficamos presos a práticas obsoletas, perdemos oportunidades de melhorar nossa produtividade e, pior, corremos o risco de nos tornarmos obsoletos no mercado.</p><p>Foi pensando nisso que decidi embarcar em um projeto ambicioso: uma série de artigos cobrindo a evolução do Java, da versão 6 até a mais recente, a 23. Meu objetivo é ajudar meus colegas desenvolvedores a entenderem o que mudou em cada versão, e isso vai me ajudar também, claro 😊. Vamos destacar as principais novidades, melhorias de performance e novas funcionalidades que surgiram ao longo dos anos.</p><p>Nesta jornada, exploraremos como o Java se transformou de uma linguagem relativamente simples em uma plataforma robusta e versátil. Veremos a introdução de recursos que quebraram a zona de conforto de muitos devs no Java 6, como o <a href="https://docs.oracle.com/javase/8/docs/technotes/guides/language/type-inference-generic-instance-creation.html">Diamond Operator</a> e o try-with-resources. Passaremos pela revolução dos <a href="https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html">lambdas</a> no Java 8, que mudaram completamente a forma como escrevemos código. Exploraremos o sistema de módulos introduzido no <a href="https://www.oracle.com/corporate/features/understanding-java-9-modules.html">Java 9</a>, que trouxe uma nova dimensão à modularidade das aplicações. E, é claro, mergulharemos nos recentes avanços em concorrência e performance nas versões mais recentes.</p><p>Além disso, vamos correlacionar essas mudanças com os principais frameworks que apoiaram o Java nesse tempo. Veremos como o <a href="https://spring.io/">Spring</a> evoluiu junto com a linguagem, adotando novos recursos e padrões. Observaremos a ascensão de frameworks como o <a href="https://quarkus.io/">Quarkus</a> e <a href="https://micronaut.io/">Micronaut</a>, que aproveitaram as melhorias de performance das versões mais recentes do Java. Analisaremos como o <a href="https://hibernate.org/">Hibernate</a> se adaptou às mudanças na <a href="https://jakarta.ee/specifications/persistence/">JPA</a> e como frameworks de teste, como <a href="https://junit.org/junit5/">JUnit</a> e <a href="https://site.mockito.org/">Mockito</a>, evoluíram para tornar nossos testes mais robustos e expressivos.</p><p>Prepare-se para uma viagem fascinante pela história recente do Java. Do Java 6 ao 23, vamos desvendar juntos como cada versão, junto com seu ecossistema, moldou o desenvolvimento de software como conhecemos hoje.</p><p>Fique ligado para o próximo artigo, onde começaremos nossa jornada com o Java 6 e as mudanças que começaram a pavimentar o caminho para o Java moderno!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0d34d098e1f3" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>