<?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 George Adams on Medium]]></title>
        <description><![CDATA[Stories by George Adams on Medium]]></description>
        <link>https://medium.com/@gdams?source=rss-f481ae7d74b8------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*Yg7OEnhmtHxEl3YM.jpg</url>
            <title>Stories by George Adams on Medium</title>
            <link>https://medium.com/@gdams?source=rss-f481ae7d74b8------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 06:17:26 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@gdams/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[One Billion Downloads: Reflecting on the Journey of Eclipse Adoptium]]></title>
            <link>https://gdams.medium.com/one-billion-downloads-reflecting-on-the-journey-of-eclipse-adoptium-22b4b2666bd2?source=rss-f481ae7d74b8------2</link>
            <guid isPermaLink="false">https://medium.com/p/22b4b2666bd2</guid>
            <category><![CDATA[eclipse-foundation]]></category>
            <category><![CDATA[openjdk]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[adoptium]]></category>
            <dc:creator><![CDATA[George Adams]]></dc:creator>
            <pubDate>Wed, 22 Jul 2026 09:05:14 GMT</pubDate>
            <atom:updated>2026-07-22T09:05:14.145Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JkjfyPUWzkmTdALh2qrk8Q.png" /></figure><p><strong>One billion downloads.</strong></p><p>It’s a number that’s difficult to comprehend, and one that certainly wasn’t on anyone’s mind when this journey began.</p><p>When we started what would eventually become AdoptOpenJDK, and later Eclipse Adoptium, we weren’t trying to build the world’s most widely used OpenJDK distribution. We were trying to solve a problem.</p><p>At the time, obtaining high-quality, production-ready OpenJDK binaries wasn’t as straightforward as it should have been. The Java ecosystem needed freely available, vendor-neutral builds that organisations and developers could rely on. More importantly, it needed an open community where the development, infrastructure, and decision making were transparent and collaborative.</p><p>What started as a handful of volunteers quickly became something much bigger.</p><h3>The Early Days</h3><p>Those early years were equal parts exciting and challenging.</p><p>There was no large engineering organisation behind the project. No dedicated marketing team. No guarantee that anyone would use what we were building.</p><p>Instead, there were passionate engineers contributing in their spare time, building release infrastructure, automating testing, solving difficult technical problems, and working together across company boundaries because they believed the ecosystem would benefit.</p><p>Every milestone felt significant.</p><p>The first successful builds.</p><p>The first major organisations adopting the binaries.</p><p>The first large-scale production deployments.</p><p>Every step reinforced the belief that an open community could build something trusted by developers around the world.</p><h3>Growing Beyond a Community Project</h3><p>As adoption accelerated, it became clear that the project had grown beyond its original ambitions.</p><p>Moving to the Eclipse Foundation and becoming Eclipse Adoptium was a significant moment. It provided a long-term home with open governance and encouraged even broader collaboration across the Java ecosystem.</p><p>Today, Adoptium is supported by an incredible community of contributors and organisations. Its binaries power everything from personal projects and university coursework to cloud platforms and enterprise applications running at global scale.</p><p>That growth didn’t happen overnight.</p><p>It happened because thousands of people contributed code, reviewed pull requests, reported bugs, improved documentation, operated infrastructure, sponsored development, and helped build trust over many years.</p><h3>One Billion Downloads Represents More Than a Number</h3><p>The billion-download milestone is exciting, but it isn’t really about downloads.</p><p>It represents developers choosing open source.</p><p>It represents organisations placing their trust in a community-led project.</p><p>It represents years of engineering effort invested by hundreds of contributors across many companies and time zones.</p><p>Most importantly, it demonstrates what can be achieved when competitors collaborate to improve an ecosystem that benefits everyone.</p><p>Open source is often described as software, but its real strength has always been its people.</p><h3>A Personal Reflection</h3><p>I’ve been fortunate enough to be part of this journey from the early AdoptOpenJDK days, helping shape the project as it evolved into Eclipse Adoptium, and later serving as Chairman of the Eclipse Adoptium Working Group.</p><p>Looking back, I’m immensely proud of what the community has achieved together.</p><p>Not because of the number itself, but because of everything that number represents.</p><p>It reflects countless hours of engineering, collaboration, debate, problem solving, and shared purpose.</p><p>It reflects a community that continued to grow while remaining true to its principles of openness, transparency, and technical excellence.</p><h3>Looking to the Future</h3><p>Reaching one billion downloads is an incredible milestone, but it’s also a reminder that projects like Adoptium don’t run themselves.</p><p>Behind every release is a significant amount of infrastructure, testing, security work, and countless hours from contributors around the world. As adoption continues to grow, so do the costs of keeping the project reliable, secure, and available for everyone.</p><p>If your organisation depends on Eclipse Adoptium, or if Adoptium has helped power your own projects over the years, I’d encourage you to consider giving something back. Whether that’s contributing code, helping with documentation, participating in the community, or supporting the project financially through the Eclipse Foundation, every contribution helps ensure Adoptium remains a sustainable, vendor-neutral OpenJDK distribution for years to come.</p><p>Open source succeeds because people invest in it. One billion downloads is an incredible achievement. Let’s make sure we’re building a community that can support the next billion as well.</p><h3>Thank You</h3><p>A milestone like this belongs to everyone who has played a part.</p><p>Thank you to every contributor who submitted a pull request.</p><p>Thank you to every maintainer who reviewed code and helped others.</p><p>Thank you to every organisation that invested time, people, and resources into the project.</p><p>Thank you to the Eclipse Foundation for providing a home where the project could continue to thrive.</p><p>And thank you to the millions of developers and organisations who chose Adoptium and trusted it to run their applications.</p><p>One billion downloads is an incredible achievement.</p><p>I’m excited to see where the next chapter takes us.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=22b4b2666bd2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[When AI Meets Java: Hilarious Misadventures with ChatGPT and GitHub Copilot]]></title>
            <link>https://gdams.medium.com/when-ai-meets-java-hilarious-misadventures-with-chatgpt-and-github-copilot-cd260f821d3e?source=rss-f481ae7d74b8------2</link>
            <guid isPermaLink="false">https://medium.com/p/cd260f821d3e</guid>
            <category><![CDATA[openjdk]]></category>
            <category><![CDATA[chatgpt]]></category>
            <category><![CDATA[github-copilot]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[George Adams]]></dc:creator>
            <pubDate>Tue, 18 Apr 2023 14:48:59 GMT</pubDate>
            <atom:updated>2023-04-18T14:48:59.695Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HUox_DLwh5F4zpYJ8h2vDQ.png" /></figure><h3>Introduction</h3><p>Java developers, prepare for a wild ride! AI-powered tools like ChatGPT and GitHub Copilot are here to spice up your coding experience. While they can be incredibly helpful, they sometimes lead us down a rabbit hole of hilariously wrong code suggestions. In this blog post, we’ll explore the lighter side of AI in Java development and share some laugh-out-loud examples of when things didn’t go quite as planned.</p><h3>When AI Suggestions Go Awry</h3><h4>A Recursive Nightmare</h4><p>Imagine working on a simple Java method to calculate the factorial of a number, and GitHub Copilot suggests the following gem:</p><pre>public static int factorial(int n) {<br>    if (n == 0) {<br>        return factorial(1);<br>    } else {<br>        return n * factorial(n - 1);<br>    }<br>}</pre><p>As you might notice, there’s a minor issue (ahem) with the base case — instead of returning 1, it calls factorial(1), resulting in infinite recursion. Good luck getting out of that one!</p><h4>The “Helpful” ChatGPT</h4><p>When you ask ChatGPT for help on how to parse a CSV file in Java, it gets a bit <em>too</em> creative and suggests:</p><pre>public static void parseCSV(String csvContent) {<br>    String[] lines = csvContent.split(&quot;\n&quot;);<br>    for (String line : lines) {<br>        String[] fields = line.split(&quot;,(?=([^\&quot;]*\&quot;[^\&quot;]*\&quot;)*[^\&quot;]*$)&quot;);<br>        System.out.println(&quot;Banana: &quot; + fields[0] + &quot;, Apple: &quot; + fields[1]);<br>    }<br>}</pre><p>While the regex magic is impressive, I’m not sure why the AI is suddenly obsessed with fruits. But hey, maybe it’s trying to remind us to eat healthily?</p><h4>The Not-So-Secure Password Generator</h4><p>GitHub Copilot, attempting to flex its security expertise, proposes this <em>excellent</em> password generator:</p><pre>public static String generatePassword() {<br>    return &quot;password123&quot;;<br>}</pre><p>Well, that’s certainly a secure password, right? I’m sure no hacker would <em>ever</em> think of trying that one first.</p><h4>The Java Time Machine</h4><p>ChatGPT, in an ambitious attempt to help you manipulate dates in Java, offers this peculiar code snippet:</p><pre>public static LocalDate timeTravel(LocalDate date, int years) {<br>    return date.plusYears(-years);<br>}</pre><p>While the intention was to add the specified number of years to the given date, the AI seems to have taken “time travel” a bit too literally by subtracting the years instead. Great Scott!</p><h4>The Mysterious Enum</h4><p>GitHub Copilot, eager to help you with a custom enumeration, presents this enigmatic creation:</p><pre>public enum MysteriousEnum {<br>    RED(&quot;Red&quot;),<br>    GREEN(&quot;Green&quot;),<br>    BLUE(&quot;Blue&quot;),<br>    BLARGH(&quot;Blargh&quot;);<br><br>    private String value;<br><br>    MysteriousEnum(String value) {<br>        this.value = value;<br>    }<br><br>    public String getValue() {<br>        return value;<br>    }<br>}</pre><p>While the first three enum values seem reasonable, “BLARGH” makes a surprise appearance, leaving us to wonder what exactly the AI was thinking. Perhaps it’s a new colour from a galaxy far, far away?</p><h4>The Unhelpful Helper Method</h4><p>When you ask ChatGPT to help you create a helper method to check if a string contains a specific character, it offers this peculiar suggestion:</p><pre>public static boolean containsChar(String input, char target) {<br>    return input.indexOf(target) == input.lastIndexOf(target);<br>}</pre><p>While this method does check for the presence of the target character, it returns true only if the character appears exactly once in the input string. It seems the AI decided to add a twist, turning a simple task into a more confusing one. Surprise!</p><h3>Embrace the Fun</h3><p>When using ChatGPT and GitHub Copilot, always remember that these tools are not perfect. They might provide you with brilliant code solutions one moment and hilarious missteps the next. To make the most of your AI-powered coding journey, follow these tips:</p><ol><li>Enjoy the humour: When AI-generated code goes wrong, have a good laugh and appreciate the absurdity.</li><li>Stay vigilant: Always review the generated code and verify its correctness, relevance, and security.</li><li>Learn and adapt: Use AI tools as a resource, not a crutch. Learn from the examples they provide and adapt them to your specific needs.</li></ol><p>And remember, as Java developers, we’re here to have fun and learn from our experiences — even if they involve AI-induced hilarity. Happy coding!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cd260f821d3e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Harnessing the Power of String Templates: A Guide for Java Developers]]></title>
            <link>https://gdams.medium.com/harnessing-the-power-of-string-templates-a-guide-for-java-developers-8b88a56fb452?source=rss-f481ae7d74b8------2</link>
            <guid isPermaLink="false">https://medium.com/p/8b88a56fb452</guid>
            <category><![CDATA[string-templates]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[openjdk]]></category>
            <dc:creator><![CDATA[George Adams]]></dc:creator>
            <pubDate>Fri, 14 Apr 2023 09:52:34 GMT</pubDate>
            <atom:updated>2023-04-14T09:52:34.235Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c_rHWg8vBccN19iKYghPUQ.png" /></figure><p>String templates, set to be introduced as a preview feature in JDK 21, simplify string formatting and manipulation in Java. This feature allows developers to embed expressions directly within string literals, making it easier to build and format complex strings. In this blog post, we will explore string templates and provide practical examples to help Java developers get started with this powerful new feature.</p><h4>Understanding String Templates</h4><p>String templates, also known as “interpolated strings”, enable developers to embed expressions within string literals. This eliminates the need for cumbersome concatenation and formatting methods like String.format(). With string templates, you can write more concise and readable code that is easier to maintain.</p><h4>Using String Templates for Simple Expressions</h4><p>To get started with string templates, let’s look at a basic example. Suppose you want to create a greeting message that includes the user’s name:</p><pre>String userName = &quot;Alice&quot;;<br>String greeting = &quot;Hello, &quot; + userName + &quot;!&quot;;<br>System.out.println(greeting); // Output: Hello, Alice!</pre><p>With string templates, you can simplify this code as follows:</p><pre>String userName = &quot;Alice&quot;;<br>String greeting = `Hello, ${userName}!`;<br>System.out.println(greeting); // Output: Hello, Alice!</pre><p>In this example, we embed the userName variable directly within the string literal using the ${expression} syntax.</p><h4>Using String Templates with Complex Expressions</h4><p>String templates can also handle more complex expressions, such as method calls or arithmetic operations. Here’s an example that calculates the total price of a purchase, including tax:</p><pre>double price = 100.0;<br>double taxRate = 0.2;<br>double totalPrice = price * (1 + taxRate);<br>String message = `Total price (including tax): ${totalPrice} GBP`;<br>System.out.println(message); // Output: Total price (including tax): 120.0 GBP</pre><p>In this example, the string template calculates the total price by embedding the totalPrice variable directly within the string literal.</p><h4>Formatting Strings with String Templates</h4><p>You can control the formatting of embedded expressions in string templates using format specifiers. Here’s an example that formats a number as a percentage:</p><pre>double successRate = 0.85;<br>String message = `Success rate: ${successRate : %.2f%%}`;<br>System.out.println(message); // Output: Success rate: 85.00%</pre><p>In this example, we use the : % format specifier to format the successRate variable as a percentage with two decimal places.</p><h4>Escaping Expressions in String Templates</h4><p>If you need to include a literal ${ or } character in a string template, you can escape it by doubling the braces:</p><pre>String message = `This is a literal brace: ${{} and a literal dollar sign: $$`;<br>System.out.println(message); // Output: This is a literal brace: ${ and a literal dollar sign: $</pre><h4>Conclusion</h4><p>String templates provide a powerful and concise way for Java developers to build and format complex strings. By embedding expressions directly within string literals, you can write cleaner, more maintainable code that is easier to read and understand. As you explore this new feature, you’ll find that string templates can help you streamline your string manipulation tasks and enhance the overall quality of your Java applications.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8b88a56fb452" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Embracing Virtual Threads: Migration Tips for Java Developers]]></title>
            <link>https://gdams.medium.com/embracing-virtual-threads-migration-tips-for-java-developers-afc90738fe1?source=rss-f481ae7d74b8------2</link>
            <guid isPermaLink="false">https://medium.com/p/afc90738fe1</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[virtual-threads]]></category>
            <category><![CDATA[openjdk]]></category>
            <dc:creator><![CDATA[George Adams]]></dc:creator>
            <pubDate>Tue, 11 Apr 2023 13:39:38 GMT</pubDate>
            <atom:updated>2023-04-17T10:55:30.304Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SMk2R06Nizc2kZcCXJWK4w.png" /></figure><p>As a Java developer, you may have already heard about virtual threads, a powerful feature introduced in Project Loom. Virtual threads provide a lightweight alternative to traditional threads, making writing scalable and efficient concurrent code easier. In this blog post, we will discuss migration tips for Java developers who want to make the most of virtual threads.</p><h4>Understand the differences between virtual and native threads</h4><p>Before diving into the migration, it’s crucial to understand the fundamental differences between virtual threads (also known as “fibers”) and native threads. The operating system manages native threads, while virtual threads are managed by the Java Virtual Machine (JVM). This means that virtual threads have much lower overhead, allowing you to create millions of them without running into resource limitations.</p><h4>Start using virtual threads</h4><p>You can start experimenting with virtual threads by creating a virtual thread executor using the java.util.concurrent.ExecutorService. Here&#39;s a simple example:</p><pre>import java.util.concurrent.ExecutorService;<br>import java.util.concurrent.Executors;<br><br>public class VirtualThreadExample {<br><br>    public static void main(String[] args) {<br>        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();<br><br>        executor.submit(() -&gt; {<br>            System.out.println(&quot;Hello from a virtual thread!&quot;);<br>        });<br><br>        executor.shutdown();<br>    }<br>}</pre><p>In this example, we create a virtual thread executor and submit a task to be executed by a virtual thread.</p><h4>Migrate from Thread to ExecutorService for concurrency</h4><p>When migrating from native threads to virtual threads, it’s essential to replace direct usage of the Thread class with the ExecutorService. Consider the following native thread example:</p><pre>public class NativeThreadExample {<br><br>    public static void main(String[] args) {<br>        Thread thread = new Thread(() -&gt; {<br>            System.out.println(&quot;Hello from a native thread!&quot;);<br>        });<br><br>        thread.start();<br><br>        try {<br>            thread.join();<br>        } catch (InterruptedException e) {<br>            e.printStackTrace();<br>        }<br>    }<br>}</pre><p>The equivalent example using virtual threads would look like this:</p><pre>import java.util.concurrent.ExecutorService;<br>import java.util.concurrent.Executors;<br><br>public class VirtualThreadExample {<br><br>    public static void main(String[] args) {<br>        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();<br><br>        executor.submit(() -&gt; {<br>            System.out.println(&quot;Hello from a virtual thread!&quot;);<br>        });<br><br>        executor.shutdown();<br>    }<br>}</pre><h4>Handle blocking operations</h4><p>When working with virtual threads, it’s essential to be aware of blocking operations. You can use java.util.concurrent.CompletableFuture to manage blocking tasks and integrate them seamlessly with virtual threads. Here&#39;s an example:</p><pre>import java.util.concurrent.ExecutorService;<br>import java.util.concurrent.Executors;<br>import java.util.concurrent.Future;<br><br>public class FutureExample {<br><br>    public static void main(String[] args) {<br>        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();<br><br>        Future&lt;String&gt; future = executor.submit(() -&gt; {<br>            return blockingOperation();<br>        });<br><br>        try {<br>            String result = future.get();<br>            System.out.println(&quot;Result: &quot; + result);<br>        } catch (InterruptedException | ExecutionException e) {<br>            e.printStackTrace();<br>        }<br><br>        executor.shutdown();<br>    }<br><br>    private static String blockingOperation() {<br>        // Simulate a blocking operation<br>        try {<br>            Thread.sleep(2000);<br>        } catch (InterruptedException e) {<br>            e.printStackTrace();<br>        }<br>        return &quot;Blocking operation completed&quot;;<br>    }<br>}</pre><p>In this example, we submit a blocking operation to the virtual thread executor, which returns a Future object. We then use Future.get() to block and wait for the result of the blocking operation. Thanks to virtual threads, this blocking style can be used without incurring the same performance penalties typically associated with native threads.</p><h4>Conclusion</h4><p>Migrating from native threads to virtual threads in Java can significantly improve the performance and scalability of your concurrent applications. By reducing the overhead associated with native threads, virtual threads enable you to create millions of lightweight threads without running into resource limitations. This allows you to write more efficient, parallelized code that can handle a larger number of concurrent tasks.</p><p>When transitioning to virtual threads, it’s crucial to replace direct usage of the Thread class with the ExecutorService, which provides a more flexible and powerful way to manage concurrency. Additionally, handling blocking operations using CompletableFuture ensures that your virtual threads remain efficient and responsive.</p><p>By embracing virtual threads and adopting these migration tips, Java developers can unlock new levels of performance in their concurrent applications. This powerful feature from Project Loom can help you write cleaner, more maintainable code while achieving superior scalability and responsiveness. As the Java ecosystem continues to evolve, virtual threads are set to play a key role in the future of high-performance, concurrent programming.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=afc90738fe1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[2020 — The highs and lows]]></title>
            <link>https://gdams.medium.com/2020-the-highs-and-lows-6e30beccecf6?source=rss-f481ae7d74b8------2</link>
            <guid isPermaLink="false">https://medium.com/p/6e30beccecf6</guid>
            <category><![CDATA[microsoft]]></category>
            <category><![CDATA[openjdk]]></category>
            <category><![CDATA[2020]]></category>
            <category><![CDATA[adoptopenjdk]]></category>
            <dc:creator><![CDATA[George Adams]]></dc:creator>
            <pubDate>Wed, 02 Dec 2020 16:50:45 GMT</pubDate>
            <atom:updated>2020-12-02T16:58:28.142Z</atom:updated>
            <content:encoded><![CDATA[<h3>2020 — The highs and lows</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LdnvbvCl5a-mcS-LRw70UA.png" /></figure><p>Well, it’s been quite a year for everyone. We’ve all had to clear out the home office, stock up on toilet paper and eat lots of takeaway food to make up for the lack of dining out. As we look forward to 2021, I wanted to put aside the struggles of mask-wearing and not seeing loved ones, and share some positive things that have happened this year.</p><h3>Microsoft</h3><p>Since the jClarity acquisition last year, we have been working hard to create a Java at Microsoft team completely from scratch. Some of the key highlights:</p><p><strong>Announcing an </strong><a href="https://devblogs.microsoft.com/java/announcing-openjdk-windows-arm/"><strong>OpenJDK Windows ARM64</strong></a><strong> and macOS Silicon port</strong></p><p>The Java VM team has been very busy working on porting OpenJDK to more arm64 systems. With more than <strong>4.3 billion</strong> people, 60 percent of the world’s population, touching a device carrying an ARM chip each day, it is essential to provide an OpenJDK build for these devices. Not only has the team successfully ported OpenJDK to Windows ARM64, but they have also gone one step further and <a href="https://appleinsider.com/articles/20/09/22/microsoft-contributes-to-java-port-for-apple-silicon-macs">partnered up with Azul</a> to port OpenJDK to Apple Silicon chips.</p><p><a href="https://devblogs.microsoft.com/java/announcing-openjdk-windows-arm/">Announcing OpenJDK for Windows 10 on ARM | Java at Microsoft</a></p><h4>Launching Microsoft’s first ever Java Conference #jdconf</h4><p>I was hugely honoured to present a keynote at Microsoft’s premier Java conference. I never thought that the day would come (and plenty of others took a double-take) but it was a massive step in the right direction, proving to the OpenJDK community that Microsoft is “all in” on Java. All the talks are now available to be watched back on the <a href="https://www.youtube.com/playlist?list=PLlrxD0HtieHjuKsDZg1JBevOVAjeWe1p0">Microsoft Developer YouTube account</a>.</p><h3><strong>AdoptOpenJDK</strong></h3><p>AdoptOpenJDK has proven to be a runaway success, with over 210M downloads of our binary distributions now powering Java workloads across the globe. AdoptOpenJDK continues to exceed all of our expectations.</p><h4>Eclipse Adoptium</h4><p>In June, we announced our intent to move the project to the <a href="https://www.eclipse.org/">Eclipse Foundation</a>. After thoroughly investigating all of our options, the Eclipse Foundation was selected based on its deep understanding of the Java ecosystem and its ability to support OSS projects as they flourish into enterprise-accepted technologies. We will likely start the huge task of moving the repositories and other project technology to the Eclipse Foundation in the new year.</p><p><a href="https://blog.adoptopenjdk.net/2020/06/adoptopenjdk-to-join-the-eclipse-foundation/">AdoptOpenJDK to join the Eclipse Foundation</a></p><h4><strong>Virtual Roadshow</strong></h4><p>I’ve often heard people complain about the virtual conferences that have appeared since lockdown began. They say that without the interaction, the corridor conversations and of course the beer, that the business value is gone. While I do agree, I’ve realised that without the need for planes and hotels and business expenses, virtual conferences are much simpler to attend. I’ve often found myself working while having someone’s talk in the background (something I wouldn’t have done if I was at the conference).</p><p>And so with all of my 2020 conferences cancelled, I came up with a plan (alongside Hendrik Ebbers) to create an AdoptOpenJDK Virtual Roadshow. For years I have been turning down talks at Java User Groups around the world because I simply don’t have the time, or I can’t justify the expense, so we decided that this was the perfect time to reach out to them. In total, we talked to JUG’s in 11 different countries and were able to help Java users around the world understand AdoptOpenJDK. It was such a great opportunity to be able to reach so many people from behind my computer and I hope that in 2021 we may be able to finally get back to some big talks on stages… and of course the beer.</p><p><a href="https://blog.adoptopenjdk.net/2020/07/adoptopenjdk-virtual-roadshow/">AdoptOpenJDK Virtual Roadshow</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6e30beccecf6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dummies guide to notarizing your runtime]]></title>
            <link>https://gdams.medium.com/dummies-guide-to-notarizing-your-runtime-a1e9105b2c21?source=rss-f481ae7d74b8------2</link>
            <guid isPermaLink="false">https://medium.com/p/a1e9105b2c21</guid>
            <category><![CDATA[notarization]]></category>
            <category><![CDATA[macos-catalina]]></category>
            <category><![CDATA[macos]]></category>
            <dc:creator><![CDATA[George Adams]]></dc:creator>
            <pubDate>Tue, 29 Oct 2019 10:52:15 GMT</pubDate>
            <atom:updated>2019-10-29T10:52:15.194Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/494/1*zVtGR5vUohjMNyhaT-ETVw.png" /></figure><h3>Summary</h3><p>Apple has recently changed the requirements for applications to install on macOS 10.15 and above. The change requires developers to notarize the application before it gets shipped. Notarization involves submitting the application to Apple to be scanned and generates a JSON report with any issues. More information about notarization can be found <a href="https://developer.apple.com/documentation/security/notarizing_your_app_before_distribution">here</a>.</p><p>As a response to multiple complaints from developers, Apple has loosened the requirements until January 2020 but after that you need to comply with all of the original requirements.</p><h3>How does this affect my runtime?</h3><p>There are a few different scenarios around today so let’s walk through them…</p><h4><strong>You’ve never code signed your runtime before:</strong></h4><p>If you’ve always shipped your runtime without code signing it then you may not need to change anything, if a developer wishes to bundle your runtime into their application they can codesign at that stage and all will be well but…</p><h4>You ship macOS installers:</h4><p>If you ship pkg or dmg installers then you are going to have to notarize the installer going forwards. In principle this means that you need to submit the installer to Apple using xcrun which comes with XCode:</p><pre>xcrun altool --notarize-app --primary-bundle-id &quot;&lt;bundle id&gt;&quot; --username &quot;&lt;email&gt;&quot; --password &quot;&lt;password&gt;&quot; --file &lt;installer&gt;.pkg</pre><p>Once this command has completed you will be given a <strong>RequestUUID </strong>which is what you then use to check the status:</p><pre>xcrun altool --notarization-info &lt;RequestUUID&gt;<strong> </strong>--username &quot;&lt;email&gt;&quot; --password &quot;&lt;password&gt;&quot;</pre><p>If all goes well then you will see Status Message: Package Approved. But unfortunately this won’t be enough for most users. (see codesigning instructions below)</p><h4>You codesign your runtime already:</h4><p>If you already codesign your runtime then you will already be familiar with the following command:</p><pre>codesign --timestamp --sign &quot;Developer ID Application: &lt;cert&gt;&quot; &lt;binary to sign&gt;</pre><p>If you’ve tried to notarize your installer but you are seeing warnings about hardened runtime not being enabled you are going to have to modify your codesign command:</p><pre>codesign --entitlements entitlements.plist --options runtime --timestamp --sign &quot;Developer ID Application: &lt;cert&gt;&quot; &lt;binary to sign&gt;</pre><p>There are two key changes here:</p><ol><li>Entitlements:</li></ol><p>You must specify entitlements of your application, a typical set of entitlements may look like this:</p><pre>&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;<br>&lt;!DOCTYPE plist PUBLIC &quot;-//Apple//DTD PLIST 1.0//EN&quot; &quot;http://www.apple.com/DTDs/PropertyList-1.0.dtd&quot;&gt;<br>&lt;plist version=&quot;1.0&quot;&gt;<br>&lt;dict&gt;<br>    &lt;key&gt;com.apple.security.cs.allow-jit&lt;/key&gt;<br>    &lt;true/&gt;<br>    &lt;key&gt;com.apple.security.cs.allow-unsigned-executable-memory&lt;/key&gt;<br>    &lt;true/&gt;<br>    &lt;key&gt;com.apple.security.cs.disable-executable-page-protection&lt;/key&gt;<br>    &lt;true/&gt;<br>    &lt;key&gt;com.apple.security.cs.allow-dyld-environment-variables&lt;/key&gt;<br>    &lt;true/&gt;<br>    &lt;key&gt;com.apple.security.cs.disable-library-validation&lt;/key&gt;<br>    &lt;true/&gt;<br>&lt;/dict&gt;<br>&lt;/plist&gt;</pre><p>2. Runtime:</p><p>You must also now specify --options runtime in order to enable hardened runtime.</p><h4>Other Problems:</h4><ul><li>Apple notarization requires the binary to have been compiled on xcode 9 or later. This may not be an issue for you but if you see warnings about algorithms being unsupported when you notarize you will need upgrade your compiler.</li><li>Once you have notarized your installer, every user will be able to run it on their computers as long as they have an internet connection. In order to support users who do not have an internet connection you will need to staple the notarization report to the installer:</li></ul><pre>xcrun stapler staple &quot;&lt;installer.pkg&gt;&quot;</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a1e9105b2c21" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bundling AdoptOpenJDK into a notarized macOS application]]></title>
            <link>https://medium.com/adoptopenjdk/bundling-adoptopenjdk-into-a-notarized-macos-application-f4d69404afc?source=rss-f481ae7d74b8------2</link>
            <guid isPermaLink="false">https://medium.com/p/f4d69404afc</guid>
            <category><![CDATA[macos-mojave]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[adoptopenjdk]]></category>
            <category><![CDATA[codesign]]></category>
            <category><![CDATA[macos]]></category>
            <dc:creator><![CDATA[George Adams]]></dc:creator>
            <pubDate>Wed, 31 Jul 2019 13:13:16 GMT</pubDate>
            <atom:updated>2019-07-31T13:26:07.934Z</atom:updated>
            <content:encoded><![CDATA[<p>Some changes have been made to the way we codesign our macOS binaries</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/697/1*biNlEnwTnZdoW1AOmTNsbQ.png" /><figcaption>codesign verification of a hardened runtime</figcaption></figure><h3>Summary</h3><p>Apple has recently changed the requirements for applications to install on macOS 10.15 and above. The change requires developers to notarize the application before it gets shipped. Notarization involves submitting the application to Apple to be scanned and generates a JSON report with any issues. More information about notarization can be found <a href="https://developer.apple.com/documentation/security/notarizing_your_app_before_distribution">here</a>.</p><h3>What’s changed?</h3><p>We have enabled hardened runtime on our macOS binaries which will allow them to be bundled into applications and pass Apple’s Notarization tests. OpenJDK 11+ will work out of the box, OpenJDK8 needs a bit more work because it’s built on an older toolchain that the notarization test doesn’t support. We will be creating a second release of <a href="https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/tag/jdk-11.0.4%2B11">jdk-11.0.4+11</a> and <a href="https://github.com/AdoptOpenJDK/openjdk12-binaries/releases/tag/jdk-12.0.2%2B10">jdk-12.0.2+10</a> which will have hardened runtime enabled.</p><h3><strong>The issue</strong></h3><p>We had multiple bug reports from users saying that when they bundle AdoptOpenJDK binaries into their applications, the notarization fails with multiple errors such as the ones below:</p><pre>“message”: “The signature algorithm used is too weak.”,<br>“message”: “The executable does not have the hardened runtime enabled.”,</pre><p>In order to work around this, we have had to enable hardened runtime on our binaries when we codesign them.</p><p>This requires us to add --options runtime to the codesign command. It also requires us to enable the following entitlements:</p><pre>&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;&lt;!DOCTYPE plist PUBLIC &quot;-//Apple//DTD PLIST 1.0//EN&quot; &quot;http://www.apple.com/DTDs/PropertyList-1.0.dtd&quot;&gt;&lt;plist version=&quot;1.0&quot;&gt;<br>&lt;dict&gt;    <br>  &lt;key&gt;com.apple.security.cs.allow-jit&lt;/key&gt;<br>  &lt;true/&gt;<br>  &lt;key&gt;com.apple.security.cs.allow-unsigned-executable-memory&lt;/key&gt;<br>  &lt;true/&gt;            <br>  &lt;key&gt;com.apple.security.cs.disable-executable-page-protection&lt;/key&gt;<br>  &lt;true/&gt;<br>  &lt;key&gt;com.apple.security.cs.allow-dyld-environment-variables&lt;/key&gt;<br>  &lt;true/&gt; <br>&lt;/dict&gt;<br>&lt;/plist&gt;</pre><h4>Why can’t I bundle OpenJDK8?</h4><p>If you try and bundle our OpenJDK8 binaries you will receive the following notarization failure:</p><pre>&quot;message&quot;: &quot;The binary uses an SDK older than the 10.9 SDK.&quot;,</pre><p>This is because OpenJDK8 is designed to be built on a much older toolchain. We will work closely with the wider community to get a fix that allows OpenJDK8 to be built on a newer version of Xcode. As soon as this is ready we will be able to build an OpenJDK8 hardened runtime enabled binary.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f4d69404afc" width="1" height="1" alt=""><hr><p><a href="https://medium.com/adoptopenjdk/bundling-adoptopenjdk-into-a-notarized-macos-application-f4d69404afc">Bundling AdoptOpenJDK into a notarized macOS application</a> was originally published in <a href="https://medium.com/adoptopenjdk">AdoptOpenJDK</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Sponsorship at AdoptOpenJDK]]></title>
            <link>https://medium.com/adoptopenjdk/sponsorship-at-adoptopenjdk-fd5fe5a19586?source=rss-f481ae7d74b8------2</link>
            <guid isPermaLink="false">https://medium.com/p/fd5fe5a19586</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[sponsorship]]></category>
            <category><![CDATA[adoptopenjdk]]></category>
            <dc:creator><![CDATA[George Adams]]></dc:creator>
            <pubDate>Thu, 11 Apr 2019 13:59:37 GMT</pubDate>
            <atom:updated>2019-07-25T20:13:29.003Z</atom:updated>
            <content:encoded><![CDATA[<p>Do you want to sponsor the AdoptOpenJDK project?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SCVnQxappYOd6uJdmdDWmQ.png" /><figcaption>Current AdoptOpenJDK sponsors, April 2019 (<a href="https://adoptopenjdk.net/sponsors.html">https://adoptopenjdk.net/sponsors</a>)</figcaption></figure><h4>Thank you to our sponsors</h4><p>Before we get started I just want to say a massive thank you to all the incredible companies that already sponsor the AdoptOpenJDK project! Without your generous donations, the project simply wouldn’t be able to run and continue to grow at the rate that it already does.</p><h4>Why should you sponsor AdoptOpenJDK?</h4><p>We believe that OpenJDK™ / Java™ is part of the public good. AdoptOpenJDK’s mission is to produce professionally tested OpenJDK™ binaries for as many platforms, architectures, and versions as possible. These binaries are ​$free​ (of cost) and ​free​ to use (under open source licenses) and kept up to date as long as the upstream OpenJDK™ and Eclipse OpenJ9 projects update their source code.</p><h4>Who really runs AdoptOpenJDK?</h4><p>AdoptOpenJDK’s direction is steered by its individual members and there is a ​Technical Steering Committee​ in place to ensure broad and fair representation.</p><h4><strong>Who’s using AdoptOpenJDK?</strong></h4><p>We already have 20M+ downloads for our builds. Everyone from individual developers to Fortune 500’s are relying on AdoptOpenJDK binaries.</p><h3>Where you can help</h3><p>There are a variety of ways that organizations and their members can help AdoptOpenJDK fulfill its mission.</p><h4>Engineering Support<strong>:</strong></h4><p>1. <strong>Devops</strong>​​ — Especially related to Ansible, O/S administration knowledge. Our goal is to have all hosts regularly wiped and rebuilt using Ansible and other immutable infrastructure techniques.<br>2. <strong>Build</strong>​​ — We run a Jenkins pipeline builds which require Jenkins, Groovy, C/C++, Bash knowledge to maintain.<br>3. <strong>Web</strong>​​ — We’re looking to rewrite the website in a modern framework guided by strong Ux and a UI that delights.<br>4. <strong>Security</strong>​​ — AdoptOpenJDK needs to protect itself against bad actors up to and including state-sponsored actors.</p><h4><strong>Infrastructure Requirements:</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F4RQLZqWsimr0QtUJIn5vA.jpeg" /></figure><p>We are currently looking for multiple hosts for build and test across various platforms that have significant CPU and memory. This will be used to quickly and continuously build and test multiple versions of OpenJDK.</p><p>Linux-x64 hardware is always useful for hosting key services and allows us to provide good test coverage across all distributions. We are also looking for some of the more specialized platforms to be added to our build farm (machines that often cost much more to pay for in the cloud). Our general guideline for build machines is:</p><p><strong>4+ core </strong>​​CPU ​​<strong>8GB</strong>​​ RAM and ​​<strong>120+GB</strong>​​ Disk (preferably ​​<strong>SSD</strong>​​)</p><h4><strong>Financial Sponsorship:</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1BjqkhD_h_Ah31kTgELYmw.jpeg" /></figure><p>Direct financial sponsorship helps ensure that the infrastructure and 3rd party services we rely on have long-term stability. As the project grows in size, so do these costs and so we are always looking for more financial sponsors to join the project. If you are interested in financial sponsorship of the project and want to find out more about the costs associated etc, then please email us at <a href="/service/mailto:sponsorship@adoptopenjdk.net">sponsorship@adoptopenjdk.net</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fd5fe5a19586" width="1" height="1" alt=""><hr><p><a href="https://medium.com/adoptopenjdk/sponsorship-at-adoptopenjdk-fd5fe5a19586">Sponsorship at AdoptOpenJDK</a> was originally published in <a href="https://medium.com/adoptopenjdk">AdoptOpenJDK</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What’s up at AdoptOpenJDK]]></title>
            <link>https://medium.com/adoptopenjdk/whats-up-at-adoptopenjdk-d3afc8b0fb3a?source=rss-f481ae7d74b8------2</link>
            <guid isPermaLink="false">https://medium.com/p/d3afc8b0fb3a</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[openjdk]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[adoptopenjdk]]></category>
            <dc:creator><![CDATA[George Adams]]></dc:creator>
            <pubDate>Mon, 08 Apr 2019 19:54:25 GMT</pubDate>
            <atom:updated>2019-04-30T08:11:32.502Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>There have been many milestones reached at AdoptOpenJDK</blockquote><h4>20 Million Downloads</h4><p>First and foremost AdoptOpenJDK has officially hit 20 million downloads! Steve Wallin was the first to tweet about it here:</p><h3>Steve Wallin on Twitter</h3><p>Congratulations to @adoptopenjdk for hitting 20 million downloads!</p><p>With the recent launch of the AdoptOpenJDK <a href="https://dash.adoptopenjdk.net/">Download Dashboard</a>, it has become easier than ever to track the downloads for each release. It was only on the 14th March that the project hit the 15 million downloads milestone so to get another 5 million downloads in under a month is a true testament to the rapid growth of the project.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/710/1*dEpbomaIwwmR1Fx6VqxzGA.png" /><figcaption><a href="https://dash.adoptopenjdk.net/">https://dash.adoptopenjdk.net</a> — 8th April 2019</figcaption></figure><h4>OpenJDK 12</h4><p>Yes, that’s right! The first public OpenJDK™ 12 release came out on the 19th March…</p><p>AdoptOpenJDK got their first releases out just <strong>24 hours</strong> after the upstream project which is an incredible achievement so a massive thank you to all who were involved!</p><p>For HotSpot releases click <a href="https://adoptopenjdk.net/releases.html?variant=openjdk12&amp;jvmVariant=hotspot">here</a>.</p><p>For OpenJ9 releases click <a href="https://adoptopenjdk.net/releases.html?variant=openjdk12&amp;jvmVariant=openj9">here</a>.</p><h4>5000 followers</h4><p>Another big milestone was reached here! The official <a href="https://twitter.com/adoptopenjdk">twitter</a> account reached 5000 followers on the 28th of March. If you haven’t already make sure you give the account a follow to always get the latest updates from the project.</p><h3>AdoptOpenJDK on Twitter</h3><p>We are just 1 follower shy of 5000 followers! Who&#39;s the lucky person going to be? Thank you everyone for the continued support! #Thanks @verified</p><h4>Installers</h4><p>Lots of work has been taking place behind the scenes at the installer workgroup. For those who haven’t already noticed, both Windows (.msi) and macOS (.pkg) installers have been produced as part of the nightly pipelines for a couple of weeks now. For those wanting Linux installers (.deb and .rpm) you’ll be pleased to know that they too are well underway <a href="https://github.com/AdoptOpenJDK/openjdk-installer/pull/79">here</a>. The OpenJDK 12 release was the first release to go out with installers for both Windows and macOS but OpenJDK 8 and 11 are also soon to be released. The .pkg installers are now also getting rolled out by default in the <a href="https://github.com/AdoptOpenJDK/homebrew-openjdk">homebrew casks</a> rather than using the tarballs.</p><h4><a href="https://status.adoptopenjdk.net/">https://status.adoptopenjdk.net/</a></h4><p>For those looking for status updates on AdoptOpenJDK you can now head over to the brand new status page where any critical service announcements will be posted:</p><p><a href="https://status.adoptopenjdk.net/">AdoptOpenJDK | Status Page</a></p><h4>Commercial Support</h4><p>The <a href="https://adoptopenjdk.net/support.html">support</a> page at AdoptOpenJDK was updated. It now includes the commercial support offerings by both <a href="https://www.ibm.com/cloud/support-for-runtimes">IBM</a> and <a href="https://www.jclarity.com/adoptopenjdk-support/">jClarity</a>.</p><h4>Icedtea-Web</h4><p>The AdoptOpenJDK project was very excited to welcome the Icedtea-web repo to the project which was kindly donated by the folks at RedHat. The move happened in March and there has been lots of activity in the new repo which can be found <a href="https://github.com/AdoptOpenJDK/icedtea-web">here</a>.</p><h4>Testimonials Page</h4><p>AdoptOpenJDK is creating a testimonials page for the website. The idea here is that we can use it as a platform to show off all the companies that have already started AdoptOpenJDK binaries in production. If you’d like to have your own company logo included in this then fill in the Google Form in the tweet below:</p><h3>AdoptOpenJDK on Twitter</h3><p>If your company is using AdoptOpenJDK binaries then make sure to fill in our form https://t.co/xxK6XqJXN3 to get your logo included on our new &quot;Users&quot; page. #helpwanted #adoptopenjdk #OpenJDK</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d3afc8b0fb3a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/adoptopenjdk/whats-up-at-adoptopenjdk-d3afc8b0fb3a">What’s up at AdoptOpenJDK</a> was originally published in <a href="https://medium.com/adoptopenjdk">AdoptOpenJDK</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[MacOS Binary Changes]]></title>
            <link>https://medium.com/adoptopenjdk/macos-binary-changes-8293f154c5dc?source=rss-f481ae7d74b8------2</link>
            <guid isPermaLink="false">https://medium.com/p/8293f154c5dc</guid>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[George Adams]]></dc:creator>
            <pubDate>Fri, 05 Oct 2018 18:30:25 GMT</pubDate>
            <atom:updated>2019-04-08T19:22:32.158Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>As a result of a recent change in our build-scripts, the directory layout of our macOS tarballs has changed. Many developers had requested that we ship our binaries in the native macOS binary layout rather than our traditional JDK layout.</blockquote><h3>Why the change?</h3><p>There are several good reasons to change the directory layout to match most of the other Java implementations. The main reason that we have chosen to do so is to allow our Homebrew recipes to be merged into core making it much easier for developers to easily download our binaries!</p><h3>What does this mean for me?</h3><p>Essentially the directory tree has changed, previously when you extracted our macOS tarballs the bin and lib directories were located in the root directory. Native macOS Java binaries alongside most other Java implementations don’t come bundled this way. Instead a Contents directory containing Home and MacOS directories along with an Info.plist file is shipped.</p><h3>What do I need to change?</h3><p>The actual OpenJDK binary is identical so your Java applications will run in the exact same way but you may need to modify your PATH to accommodate these changes. If you are looking for the bin and lib directories, they are now located inside Contents/Home/bin and Contents/Home/lib.</p><pre>.<br>└── Contents<br>    ├── Home<br>    │   ├── bin<br>    │   ├── conf<br>    │   ├── demo<br>    │   ├── include<br>    │   ├── jmods<br>    │   ├── legal<br>    │   ├── lib<br>    │   ├── man<br>    │   └── release<br>    ├── Info.plist<br>    └── MacOS<br>        └── libjli.dylib -&gt; ../Home/lib/jli/libjli.dylib</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8293f154c5dc" width="1" height="1" alt=""><hr><p><a href="https://medium.com/adoptopenjdk/macos-binary-changes-8293f154c5dc">MacOS Binary Changes</a> was originally published in <a href="https://medium.com/adoptopenjdk">AdoptOpenJDK</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>