<!DOCTYPE html>
<!--[if lt IE 7]>      <html class="no-js lt-ie9 lt-ie8 lt-ie7"> <![endif]-->
<!--[if IE 7]>         <html class="no-js lt-ie9 lt-ie8"> <![endif]-->
<!--[if IE 8]>         <html class="no-js lt-ie9"> <![endif]-->
<!--[if gt IE 8]><!--> <html class="no-js"> <!--<![endif]--><head>
    <meta charset='utf-8'/><meta http-equiv='X-UA-Compatible' content='IE=edge'/><meta name='viewport' content='width=device-width, initial-scale=1'/><title>The Apache Groovy programming language - Blogs</title><link href='../img/favicon.ico' type='image/x-ico' rel='icon'/><link rel='stylesheet' type='text/css' href='../css/bootstrap.css'/><link rel='stylesheet' type='text/css' href='../css/font-awesome.min.css'/><link rel='stylesheet' type='text/css' href='../css/style.css'/>
</head><body>
    <div id='fork-me'>
        <a href='https://github.com/apache/groovy'>
            <img style='position: fixed; top: 20px; right: -58px; border: 0; z-index: 100; transform: rotate(45deg);' src='/img/horizontal-github-ribbon.png'/>
        </a>
    </div><div id='st-container' class='st-container st-effect-9'>
        <nav class='st-menu st-effect-9' id='menu-12'>
            <h2 class='icon icon-lab'>Socialize</h2><ul>
                <li>
                    <a href='https://groovy-lang.org/mailing-lists.html' class='icon'><span class='fa fa-envelope'></span> Discuss on the mailing-list</a>
                </li><li>
                    <a href='https://twitter.com/ApacheGroovy' class='icon'><span class='fa fa-twitter'></span> Groovy on Twitter</a>
                </li><li>
                    <a href='https://groovy-lang.org/events.html' class='icon'><span class='fa fa-calendar'></span> Events and conferences</a>
                </li><li>
                    <a href='https://github.com/apache/groovy' class='icon'><span class='fa fa-github'></span> Source code on GitHub</a>
                </li><li>
                    <a href='https://groovy-lang.org/reporting-issues.html' class='icon'><span class='fa fa-bug'></span> Report issues in Jira</a>
                </li><li>
                    <a href='http://stackoverflow.com/questions/tagged/groovy' class='icon'><span class='fa fa-stack-overflow'></span> Stack Overflow questions</a>
                </li><li>
                    <a href='http://groovycommunity.com/' class='icon'><span class='fa fa-slack'></span> Slack Community</a>
                </li>
            </ul>
        </nav><div class='st-pusher'>
            <div class='st-content'>
                <div class='st-content-inner'>
                    <!--[if lt IE 7]>
                    <p class="browsehappy">You are using an <strong>outdated</strong> browser. Please <a href="http://browsehappy.com/">upgrade your browser</a> to improve your experience.</p>
                <![endif]--><div><div class='navbar navbar-default navbar-static-top' role='navigation'>
                            <div class='container'>
                                <div class='navbar-header'>
                                    <button type='button' class='navbar-toggle' data-toggle='collapse' data-target='.navbar-collapse'>
                                        <span class='sr-only'></span><span class='icon-bar'></span><span class='icon-bar'></span><span class='icon-bar'></span>
                                    </button><a class='navbar-brand' href='../index.html'>
                                        <i class='fa fa-star'></i> Apache Groovy
                                    </a>
                                </div><div class='navbar-collapse collapse'>
                                    <ul class='nav navbar-nav navbar-right'>
                                        <li class=''><a href='https://groovy-lang.org/learn.html'>Learn</a></li><li class=''><a href='https://groovy-lang.org/documentation.html'>Documentation</a></li><li class=''><a href='/download.html'>Download</a></li><li class=''><a href='https://groovy-lang.org/support.html'>Support</a></li><li class=''><a href='/'>Contribute</a></li><li class=''><a href='https://groovy-lang.org/ecosystem.html'>Ecosystem</a></li><li class=''><a href='/blog'>Blog posts</a></li><li class=''><a href='https://groovy.apache.org/events.html'></a></li><li>
                                            <a data-effect='st-effect-9' class='st-trigger' href='#'>Socialize</a>
                                        </li><li class=''>
                                            <a href='../search.html'>
                                                <i class='fa fa-search'></i>
                                            </a>
                                        </li>
                                    </ul>
                                </div>
                            </div>
                        </div><div id='content' class='page-1'><div class='row'><div class='row-fluid'><div class='col-lg-3' id='blog-index'><ul class='nav-sidebar list'><li class='active'><a href='/blog/'>Blogs</a></li><li><a href='groovy-knapsack'>Solving the Knapsack Problem with Groovy</a></li><li><a href='groovy-delegation'>Using the Delegation Pattern with Groovy</a></li><li><a href='groovy-typecheckers'>Groovy Type Checkers</a></li><li><a href='seasons-greetings-emoji'>Season&#8217;s Greetings with Emojis</a></li><li><a href='groovy-gatherers'>Using Gatherers with Groovy</a></li><li><a href='set-operations-with-groovy'>Set Operators with Groovy</a></li><li><a href='community-over-code-na-2023'>Community Over Code (North America) 2023</a></li><li><a href='chatgpt-one-liners'>ChatGPT meets Groovy one-liners</a></li><li><a href='groovy-pekko-gpars'>Using Apache Pekko actors and GPars actors with Groovy</a></li><li><a href='groovy-dauphine'>Processing Results for the Critérium du Dauphiné</a></li><li><a href='create-groovy-blog'>Creating a Groovy Blog Post</a></li><li><a href='groovy-record-performance'>Groovy Record Performance</a></li><li><a href='groovy-sequenced-collections'>Groovy and Sequenced Collections (JEP-431)</a></li><li><a href='lego-bricks-with-groovy'>Lego Bricks with Groovy</a></li><li><a href='gpars-meets-virtual-threads'>GPars meets Virtual Threads</a></li><li><a href='helloworldemoji'>Hello World with Emojis</a></li><li><a href='groovy-records'>Groovy Records</a></li><li><a href='groovy-haiku-processing'>Groovy Haiku processing</a></li><li><a href='testing_permutations_combinations'>Groovy Testing with Combinations and Permutations</a></li><li><a href='apache-nlpcraft-with-groovy'>Converting natural language into actions with NLPCraft and Groovy</a></li><li><a href='quake3-inverse-square-root'>Quake III Arena and the fast inverse square root algorithm</a></li><li><a href='australian-timezones'>Australian Time Zones</a></li><li><a href='wordle-checker'>Checking Wordle with Groovy</a></li><li><a href='groovy-null-processing'>Groovy Processing Nulls In Lists</a></li><li><a href='groundhog-day'>Groundhog Day</a></li><li><a href='fun-with-rating-stars'>Fun with rating stars</a></li><li><a href='apache-groovy-2022-year-in'>Apache Groovy 2022 Year In Review</a></li><li><a href='jvm-hello-world-with-groovy'>JVM Hello World with Groovy</a></li><li><a href='adventures-with-groovyfx'>Adventures with GroovyFX</a></li><li><a href='fun-with-obfuscated-groovy'>Fun with obfuscated Groovy</a></li><li><a href='zipping-collections-with-groovy'>Zipping Collections with Groovy</a></li><li><a href='whiskey-clustering-with-groovy-and'>Whiskey Clustering with Groovy and Apache Ignite</a></li><li><a href='groovy-dates-and-times-cheat'>Groovy Dates And Times Cheat Sheet</a></li><li><a href='fruity-eclipse-collections'>Fruity Eclipse Collections</a></li><li><a href='deep-learning-and-eclipse-collections'>Deep Learning and Eclipse Collections</a></li><li><a href='deck-of-cards-with-groovy'>Deck of cards with Groovy, JDK collections and Eclipse Collections</a></li><li><a href='encryption-and-decryption-with-groovy'>Encryption and decryption with Groovy</a></li><li><a href='calculating-fibonacci-with-groovy-revisited'>Calculating Fibonacci with Groovy revisited</a></li><li><a href='solving-cryptarithmetic-puzzles-with-groovy'>Solving cryptarithmetic puzzles with Groovy and constraint programming using Choco, JaCoP, and OR-Tools</a></li><li><a href='groovy-list-processing-cheat-sheet'>Groovy List Processing Cheat Sheet</a></li><li><a href='matrix-calculations-with-groovy-apache'>Matrix calculations with Groovy, Apache Commons Math, ojAlgo, Nd4j and EJML</a></li><li><a href='life-on-mars-units-of'>Life on Mars: Units of Measurement systems, Groovy, and domain specific languages (DSLs)</a></li><li><a href='natural-language-processing-with-groovy'>Natural Language Processing with Groovy, OpenNLP, CoreNLP, Nlp4j, Datumbox, Smile, Spark NLP, DJL and TensorFlow</a></li><li><a href='detecting-objects-with-groovy-the'>Detecting objects with Groovy, the Deep Java Library (DJL), and Apache MXNet</a></li><li><a href='working-with-sql-databases-with'>Working with SQL databases with Groovy and GraalVM</a></li><li><a href='reading-and-writing-csv-files'>Reading and Writing CSV files with Groovy</a></li><li><a href='groovy-release-train-4-0'>Groovy release train: 4.0.4, 3.0.12, 2.5.18</a></li><li><a href='comparators-and-sorting-in-groovy'>Comparators and Sorting in Groovy</a></li><li><a href='testing-your-java-with-groovy'>Testing your Java with Groovy, Spock, JUnit5, Jacoco, Jqwik and Pitest</a></li><li><a href='parsing-json-with-groovy'>Parsing JSON with Groovy</a></li><li><a href='classifying-iris-flowers-with-deep'>Classifying Iris Flowers with Deep Learning, Groovy and GraalVM</a></li><li><a href='using-groovy-with-apache-wayang'>Using Groovy with Apache Wayang and Apache Spark</a></li><li><a href='groovy-4-0-3-released'>Groovy 4.0.3 Released</a></li><li><a href='groovy-3-highlights'>Groovy 3 Highlights</a></li><li><a href='groovy-3-0-0-beta2'>Groovy 3.0.0-beta-2 Windows Installer Released (Community Release)</a></li><li><a href='groovy-3-0-0-beta1'>Groovy 3.0.0-beta-2 Released</a></li><li><a href='groovy-2-5-7-and'>Groovy 2.5.7 and 3.0.0-beta-1 Windows Installers Released (Community Artifacts)</a></li><li><a href='groovy-3-0-0-beta'>Groovy 3.0.0-beta-1 Released</a></li><li><a href='groovy-2-5-7-released'>Groovy 2.5.7 Released</a></li><li><a href='groovy-2-4-17-released'>Groovy 2.4.17 Released</a></li><li><a href='groovy-2-5-6-released'>Groovy 2.5.6 Released</a></li><li><a href='groovy-3-0-0-alpha1'>Groovy 3.0.0-alpha-4 Windows Installer Released (Community Artifact)</a></li><li><a href='groovy-3-0-0-alpha'>Groovy 3.0.0-alpha-4 Released</a></li><li><a href='groovy-2-5-5-windows'>Groovy 2.5.5 Windows Installer Released (Community Artifact)</a></li><li><a href='groovy-2-5-5-released'>Groovy 2.5.5 released</a></li><li><a href='groovy-2-4-16-windows'>Groovy 2.4.16 Windows Installer Released (Community Artifact)</a></li><li><a href='groovy-2-4-16-released'>Groovy 2.4.16 Released</a></li><li><a href='groovy-2-5-4-windows'>Groovy 2.5.4 Windows Installer Released (Community Artifact)</a></li><li><a href='groovy-2-5-4-released'>Groovy 2.5.4 Released</a></li><li><a href='apache-groovy-committer-graeme-rocher'>Apache Groovy committer Graeme Rocher receives Oracle Groundbreaker award</a></li><li><a href='gmavenplus-1-6-2-released'>GMavenPlus 1.6.2 Released (Community Artifact)</a></li><li><a href='groovy-2-5-3-windows'>Groovy 2.5.3 Windows Installer Released (Community Artifact)</a></li><li><a href='groovy-2-5-3-released'>Groovy 2.5.3 Released</a></li><li><a href='groovy-2-5-2-windows'>Groovy 2.5.2 Windows Installer Released (Community Artifact)</a></li><li><a href='groovy-2-5-2-released'>Groovy 2.5.2 released</a></li><li><a href='groovy-2-5-1-released'>Groovy 2.5.1 released</a></li><li><a href='announce-announcing-codenarc-1-2'>Announcing CodeNarc 1.2</a></li><li><a href='groovy-2-5-clibuilder-renewal'>Apache Groovy 2.5 CliBuilder Renewal</a></li><li><a href='groovy-2-5-0-released'>Groovy 2.5.0 released</a></li></ul><ul class='pagination'/></div><div class='col-lg-8 col-lg-pull-0'><h1>Blogs for Groovy</h1><div id='chartdiv'></div><p>Here you can find the Blogs for the Groovy programming language:</p><div id='blog-list'><div><span>Search: </span><input type='text' class='search'/></div><ul class='list'><li><p class='name'><a href='groovy-knapsack'>Solving the Knapsack Problem with Groovy</a><br/>Published by Paul King on 2024-02-09 03:00PM<br/>This post looks at solving the knapsack problem with Groovy.</p></li><li><p class='name'><a href='groovy-delegation'>Using the Delegation Pattern with Groovy</a><br/>Published by Paul King on 2024-01-28 08:08PM<br/>This post looks at using the Delegation Design Pattern with Groovy.</p></li><li><p class='name'><a href='groovy-typecheckers'>Groovy Type Checkers</a><br/>Published by Paul King on 2024-01-20 08:30PM<br/>This post looks at Groovy&apos;s Type Checkers.</p></li><li><p class='name'><a href='seasons-greetings-emoji'>Season&#8217;s Greetings with Emojis</a><br/>Published by Paul King on 2023-12-23 12:24PM<br/>Last updated: 2024-01-19 10:15PM<br/>Season&apos;s greetings with some emoji fun.</p></li><li><p class='name'><a href='groovy-gatherers'>Using Gatherers with Groovy</a><br/>Published by Paul King on 2023-12-09 03:30PM<br/>Last updated: 2024-01-18 10:00PM<br/>This post looks at using Gatherers (JEP 461) with Groovy.</p></li><li><p class='name'><a href='set-operations-with-groovy'>Set Operators with Groovy</a><br/>Published by Paul King on 2023-11-14 03:22PM<br/>This blog looks at union, intersection, difference &amp;amp; symmetric difference operators in Groovy.</p></li><li><p class='name'><a href='community-over-code-na-2023'>Community Over Code (North America) 2023</a><br/>Published by Paul King on 2023-10-26 05:00PM<br/>This post looks at the ASF Community Over Code conference in Halifax, Nova Scotia, October 7-10 2023, with a particular focus on the Groovy Track.</p></li><li><p class='name'><a href='chatgpt-one-liners'>ChatGPT meets Groovy one-liners</a><br/>Published by Paul King on 2023-10-19 06:00PM<br/>I asked ChatGPT if it could represent some short/one-liner programming-related dad jokes as short/one-liner Groovy scripts.</p></li><li><p class='name'><a href='groovy-pekko-gpars'>Using Apache Pekko actors and GPars actors with Groovy</a><br/>Published by Paul King on 2023-07-17 11:24PM<br/>Last updated: 2023-07-26 03:02PM<br/>This post looks at using Apache Pekko Actors and GPars Actors with Groovy.</p></li><li><p class='name'><a href='groovy-dauphine'>Processing Results for the Critérium du Dauphiné</a><br/>Published by Paul King on 2023-06-13 05:00PM<br/>This post looks at processing the general classification results for the Critérium du Dauphiné using Groovy, GQuery and DuckDB.</p></li><li><p class='name'><a href='create-groovy-blog'>Creating a Groovy Blog Post</a><br/>Published by Paul King on 2023-05-25 11:35PM<br/>This post looks at the steps to create a blog post.</p></li><li><p class='name'><a href='groovy-record-performance'>Groovy Record Performance</a><br/>Published by Paul King on 2023-05-09 11:39PM<br/>Last updated: 2023-05-10 07:57PM<br/>This post looks at the performance of some of the generated methods in Groovy records.</p></li><li><p class='name'><a href='groovy-sequenced-collections'>Groovy and Sequenced Collections (JEP-431)</a><br/>Published by Paul King on 2023-04-29 09:00AM<br/>This post looks at Groovy support for sequenced collections.</p></li><li><p class='name'><a href='lego-bricks-with-groovy'>Lego Bricks with Groovy</a><br/>Published by Paul King on 2023-04-25 11:28PM<br/>Last updated: 2023-04-27 10:42PM<br/>This post compares Groovy built-in capabilities to Java and Eclipse Collections.</p></li><li><p class='name'><a href='gpars-meets-virtual-threads'>GPars meets Virtual Threads</a><br/>Published by Paul King on 2022-06-15 11:28AM<br/>Last updated: 2023-04-14 06:23PM<br/>This post looks at using GPars with virtual threads.</p></li><li><p class='name'><a href='helloworldemoji'>Hello World with Emojis</a><br/>Published by Paul King on 2023-04-04 12:24PM<br/>This post looks at a Groovy hello world with some emoji fun.</p></li><li><p class='name'><a href='groovy-records'>Groovy Records</a><br/>Published by Paul King on 2023-04-02 08:22PM<br/>This blog looks at Groovy records.</p></li><li><p class='name'><a href='groovy-haiku-processing'>Groovy Haiku processing</a><br/>Published by Paul King on 2023-11-07 07:22PM<br/>This blog looks at processing some creative writing looking at various properties of the letters within the text.</p></li><li><p class='name'><a href='testing_permutations_combinations'>Groovy Testing with Combinations and Permutations</a><br/>Published by Paul King on 2023-03-19 05:23PM<br/>This blog looks at testing with Groovy using Combinations and Permutations.</p></li><li><p class='name'><a href='apache-nlpcraft-with-groovy'>Converting natural language into actions with NLPCraft and Groovy</a><br/>Published by Paul King on 2023-03-10 07:22PM<br/>Last updated: 2023-03-13 01:32PM<br/>This blog looks at using Apache NLPCraft from Groovy.</p></li><li><p class='name'><a href='quake3-inverse-square-root'>Quake III Arena and the fast inverse square root algorithm</a><br/>Published by Paul King on 2023-02-28 12:05AM<br/>Inspired by a recent tweet, this blog looks at the fast inverse square root algorithm made famous in Quake III Arena.</p></li><li><p class='name'><a href='australian-timezones'>Australian Time Zones</a><br/>Published by Paul King on 2023-02-20 08:00PM<br/>Inspired by a recent update related to Antarctic timezones, this post looks at some interesting Australian time zone facts.</p></li><li><p class='name'><a href='wordle-checker'>Checking Wordle with Groovy</a><br/>Published by Paul King on 2023-02-08 12:00AM<br/>This post looks at writing a Wordle checker in Groovy.</p></li><li><p class='name'><a href='groovy-null-processing'>Groovy Processing Nulls In Lists</a><br/>Published by Paul King on 2023-02-06 12:00AM<br/>This post looks at processing lists containing nulls in Groovy.</p></li><li><p class='name'><a href='groundhog-day'>Groundhog Day</a><br/>Published by Paul King on 2023-02-02 12:00AM<br/>Inspired by a recent tweet, this blog looks at some datetime manipulations to calculate the period between Groundhog day and the start of Spring.</p></li><li><p class='name'><a href='fun-with-rating-stars'>Fun with rating stars</a><br/>Published by Paul King on 2023-01-25 12:00AM<br/>Inspired by a recent tweet, this blog looks at producing a string of stars corresponding to a rating.</p></li><li><p class='name'><a href='apache-groovy-2022-year-in'>Apache Groovy 2022 Year In Review</a><br/>Published by Paul King on 2022-12-29 02:28PM<br/>This post looks back at some highlights for Groovy in 2022.</p></li><li><p class='name'><a href='jvm-hello-world-with-groovy'>JVM Hello World with Groovy</a><br/>Published by Paul King on 2022-12-22 02:24PM<br/>This post looks at using bytecode libraries to generate class files. It&apos;s a deep dive into how compilers and other tools work behind the scenes.</p></li><li><p class='name'><a href='adventures-with-groovyfx'>Adventures with GroovyFX</a><br/>Published by Paul King on 2022-12-12 02:22PM<br/>This blog looks at a GroovyFX TODO application.</p></li><li><p class='name'><a href='fun-with-obfuscated-groovy'>Fun with obfuscated Groovy</a><br/>Published by Paul King on 2022-12-08 12:40AM<br/>This post looks at some Obfuscated code for outputting some well-known text.</p></li><li><p class='name'><a href='zipping-collections-with-groovy'>Zipping Collections with Groovy</a><br/>Published by Paul King on 2022-11-17 12:50PM<br/>This post looks at zipping collections.</p></li><li><p class='name'><a href='whiskey-clustering-with-groovy-and'>Whiskey Clustering with Groovy and Apache Ignite</a><br/>Published by Paul King on 2022-10-27 11:13AM<br/>This post looks at using Apache Ignite with Apache Groovy and the K-Means algorithm to cluster scotch whiskeys.</p></li><li><p class='name'><a href='groovy-dates-and-times-cheat'>Groovy Dates And Times Cheat Sheet</a><br/>Published by Paul King on 2022-10-24 07:27AM<br/>This post looks at data and time functionality in Groovy including classic and Java date time, JSR310, functionality.</p></li><li><p class='name'><a href='fruity-eclipse-collections'>Fruity Eclipse Collections</a><br/>Published by Paul King on 2022-10-13 11:05AM<br/>This post looks at using KMeans to compare fruit nominated color with the colors used in its emoji.</p></li><li><p class='name'><a href='deep-learning-and-eclipse-collections'>Deep Learning and Eclipse Collections</a><br/>Published by Paul King on 2022-10-11 10:41AM<br/>This post uses Emojis and Eclipse Collections to process pet records. We then use deep learning to predict whether each emoji looks like a dog or cat.</p></li><li><p class='name'><a href='deck-of-cards-with-groovy'>Deck of cards with Groovy, JDK collections and Eclipse Collections</a><br/>Published by Paul King on 2022-09-23 10:18AM<br/>Last updated: 2022-09-25 11:15AM<br/>This post highlights some code for modelling and manipulating cards with records, JDK collections, and Eclipse Collections.</p></li><li><p class='name'><a href='encryption-and-decryption-with-groovy'>Encryption and decryption with Groovy</a><br/>Published by Paul King on 2022-09-19 02:34PM<br/>This post looks at encrypting and decrypting data using Groovy with the AES and CAST5 algorithms.</p></li><li><p class='name'><a href='calculating-fibonacci-with-groovy-revisited'>Calculating Fibonacci with Groovy revisited</a><br/>Published by Paul King on 2022-09-08 10:59AM<br/>This post looks at various ways to calculate Fibonacci numbers such as recursion and iteration including optimisations like tail recursion and memoization.</p></li><li><p class='name'><a href='solving-cryptarithmetic-puzzles-with-groovy'>Solving cryptarithmetic puzzles with Groovy and constraint programming using Choco, JaCoP, and OR-Tools</a><br/>Published by Paul King on 2022-09-05 01:43PM<br/>This post looks at solving cryptarithmetic puzzles using Groovy.</p></li><li><p class='name'><a href='groovy-list-processing-cheat-sheet'>Groovy List Processing Cheat Sheet</a><br/>Published by Paul King on 2022-08-28 08:46AM<br/>This post looks at the common Groovy features for processing lists.</p></li><li><p class='name'><a href='matrix-calculations-with-groovy-apache'>Matrix calculations with Groovy, Apache Commons Math, ojAlgo, Nd4j and EJML</a><br/>Published by Paul King on 2022-08-18 01:41PM<br/>This post looks at using Groovy to write a number of applications involving matrices. It uses a number of open source matrix libraries.</p></li><li><p class='name'><a href='life-on-mars-units-of'>Life on Mars: Units of Measurement systems, Groovy, and domain specific languages (DSLs)</a><br/>Published by Paul King on 2022-08-13 06:31AM<br/>This post looks at using the JSR 385 unit of measurement system and writing domain specific languages with examples including the Mars rover robot.</p></li><li><p class='name'><a href='natural-language-processing-with-groovy'>Natural Language Processing with Groovy, OpenNLP, CoreNLP, Nlp4j, Datumbox, Smile, Spark NLP, DJL and TensorFlow</a><br/>Published by Paul King on 2022-08-07 07:34AM<br/>This post looks at numerous common natural language processing tasks using Groovy and a range of NLP libraries.</p></li><li><p class='name'><a href='detecting-objects-with-groovy-the'>Detecting objects with Groovy, the Deep Java Library (DJL), and Apache MXNet</a><br/>Published by Paul King on 2022-08-01 11:52AM<br/>This post looks at using Apache Groovy, DLJ and Apache MXNet to use neural networks to detect objects within an image.</p></li><li><p class='name'><a href='working-with-sql-databases-with'>Working with SQL databases with Groovy and GraalVM</a><br/>Published by Paul King on 2022-07-29 02:07PM<br/>This post looks at a simple H2 database application. It shows how to create a native version of the application using GraalVM.</p></li><li><p class='name'><a href='reading-and-writing-csv-files'>Reading and Writing CSV files with Groovy</a><br/>Published by Paul King on 2022-07-25 02:26PM<br/>This post looks at processing CSV files using OpenCSV, Commons CSV, and Jackson Databind libraries.</p></li><li><p class='name'><a href='groovy-release-train-4-0'>Groovy release train: 4.0.4, 3.0.12, 2.5.18</a><br/>Published by Paul King on 2022-07-24 12:55PM<br/>Groovy 4.0.4, 3.0.12 and 2.5.18 Release Announcement.</p></li><li><p class='name'><a href='comparators-and-sorting-in-groovy'>Comparators and Sorting in Groovy</a><br/>Published by Paul King on 2022-07-21 03:51PM<br/>This post looks at Groovy functionality for making your classes comparable and/or sortable.</p></li><li><p class='name'><a href='testing-your-java-with-groovy'>Testing your Java with Groovy, Spock, JUnit5, Jacoco, Jqwik and Pitest</a><br/>Published by Paul King on 2022-07-15 08:26AM<br/>This post looks at testing Java using Groovy, Spock, JUnit5, Jacoco, Jqwik and Pitest</p></li><li><p class='name'><a href='parsing-json-with-groovy'>Parsing JSON with Groovy</a><br/>Published by Paul King on 2022-07-10 02:00PM<br/>This post looks at parsing JSON using Groovy&apos;s in-built capabilities as well as some other libraries.</p></li><li><p class='name'><a href='classifying-iris-flowers-with-deep'>Classifying Iris Flowers with Deep Learning, Groovy and GraalVM</a><br/>Published by Paul King on 2022-06-25 10:52AM<br/>Last updated: 2022-06-27 11:16AM<br/>This post looks at classifying Iris flowers using traditional and neural net based approaches using Eclipse DeepLearning4j, Encog, Deep Netts and GraalVM.</p></li><li><p class='name'><a href='using-groovy-with-apache-wayang'>Using Groovy with Apache Wayang and Apache Spark</a><br/>Published by Paul King on 2022-06-19 01:01PM<br/>This post looks at using Apache Wayang and Apache Spark with Apache Groovy to cluster various Whiskies.</p></li><li><p class='name'><a href='groovy-4-0-3-released'>Groovy 4.0.3 Released</a><br/>Published by Paul King on 2022-06-15 08:16AM<br/>Groovy 4.0.3 Release Announcement.</p></li><li><p class='name'><a href='groovy-3-highlights'>Groovy 3 Highlights</a><br/>Published by Paul King on 2020-02-13 02:28AM<br/>A summary of the highlights for Groovy 3.</p></li><li><p class='name'><a href='groovy-3-0-0-beta2'>Groovy 3.0.0-beta-2 Windows Installer Released (Community Release)</a><br/>Published by Remko Popma on 2019-07-15 10:30AM<br/>Groovy 3.0.0-beta-2 Windows Installer Release Announcement.</p></li><li><p class='name'><a href='groovy-3-0-0-beta1'>Groovy 3.0.0-beta-2 Released</a><br/>Published by Remko Popma on 2019-07-15 10:25AM<br/>Groovy 3.0.0-beta-2 Release Announcement.</p></li><li><p class='name'><a href='groovy-2-5-7-and'>Groovy 2.5.7 and 3.0.0-beta-1 Windows Installers Released (Community Artifacts)</a><br/>Published by Remko Popma on 2019-05-12 10:49PM<br/>Groovy 2.5.7 and 3.0.0-beta-1 Windows Installer Release Announcement.</p></li><li><p class='name'><a href='groovy-3-0-0-beta'>Groovy 3.0.0-beta-1 Released</a><br/>Published by Remko Popma on 2019-05-12 10:41PM<br/>Groovy 3.0.0-beta-1 Release Announcement.</p></li><li><p class='name'><a href='groovy-2-5-7-released'>Groovy 2.5.7 Released</a><br/>Published by Remko Popma on 2019-05-12 10:39PM<br/>Groovy 2.5.7 Release Announcement.</p></li><li><p class='name'><a href='groovy-2-4-17-released'>Groovy 2.4.17 Released</a><br/>Published by Remko Popma on 2019-05-12 10:32PM<br/>Groovy 2.4.17 Release Announcement.</p></li><li><p class='name'><a href='groovy-2-5-6-released'>Groovy 2.5.6 Released</a><br/>Published by Remko Popma on 2019-02-04 10:19PM<br/>Groovy 2.5.6 Release Announcement.</p></li><li><p class='name'><a href='groovy-3-0-0-alpha1'>Groovy 3.0.0-alpha-4 Windows Installer Released (Community Artifact)</a><br/>Published by Remko Popma on 2019-01-01 09:28AM<br/>Groovy 2.4.16 Windows Installer Release Announcement.</p></li><li><p class='name'><a href='groovy-3-0-0-alpha'>Groovy 3.0.0-alpha-4 Released</a><br/>Published by Remko Popma on 2019-01-01 09:24AM<br/>Groovy 3.0.0-alpha-4 Release Announcement.</p></li><li><p class='name'><a href='groovy-2-5-5-windows'>Groovy 2.5.5 Windows Installer Released (Community Artifact)</a><br/>Published by Remko Popma on 2018-12-24 10:02PM<br/>Groovy 2.5.5 Windows Installer Release Announcement.</p></li><li><p class='name'><a href='groovy-2-5-5-released'>Groovy 2.5.5 released</a><br/>Published by Remko Popma on 2018-12-24 11:53AM<br/>Groovy 2.5.5 Release Announcement.</p></li><li><p class='name'><a href='groovy-2-4-16-windows'>Groovy 2.4.16 Windows Installer Released (Community Artifact)</a><br/>Published by Remko Popma on 2018-12-18 10:06PM<br/>Groovy 2.4.16 Windows Installer Release Announcement.</p></li><li><p class='name'><a href='groovy-2-4-16-released'>Groovy 2.4.16 Released</a><br/>Published by Remko Popma on 2018-12-18 10:04PM<br/>Groovy 2.4.16 Release Announcement.</p></li><li><p class='name'><a href='groovy-2-5-4-windows'>Groovy 2.5.4 Windows Installer Released (Community Artifact)</a><br/>Published by Remko Popma on 2018-11-12 11:43AM<br/>Groovy 2.5.4 Windows Installer Release Announcement.</p></li><li><p class='name'><a href='groovy-2-5-4-released'>Groovy 2.5.4 Released</a><br/>Published by Remko Popma on 2018-11-12 11:42AM<br/>Groovy 2.5.4 Release Announcement.</p></li><li><p class='name'><a href='apache-groovy-committer-graeme-rocher'>Apache Groovy committer Graeme Rocher receives Oracle Groundbreaker award</a><br/>Published by Paul King on 2018-10-24 11:33PM<br/>Congratulations to Graeme Rocher for receiving the Oracle Groundbreaker award.</p></li><li><p class='name'><a href='gmavenplus-1-6-2-released'>GMavenPlus 1.6.2 Released (Community Artifact)</a><br/>Published by Remko Popma on 2018-10-14 10:00PM<br/>GMavenPlus 1.6.2 Release Announcement.</p></li><li><p class='name'><a href='groovy-2-5-3-windows'>Groovy 2.5.3 Windows Installer Released (Community Artifact)</a><br/>Published by Remko Popma on 2018-10-14 09:47PM<br/>Groovy 2.5.3 Windows Installer Release Announcement.</p></li><li><p class='name'><a href='groovy-2-5-3-released'>Groovy 2.5.3 Released</a><br/>Published by Remko Popma on 2018-10-14 09:43PM<br/>Groovy 2.5.3 Release Announcement.</p></li><li><p class='name'><a href='groovy-2-5-2-windows'>Groovy 2.5.2 Windows Installer Released (Community Artifact)</a><br/>Published by Remko Popma on 2018-08-19 09:50AM<br/>Groovy 2.5.2 Windows Installer Release Announcement.</p></li><li><p class='name'><a href='groovy-2-5-2-released'>Groovy 2.5.2 released</a><br/>Published by Remko Popma on 2018-08-16 02:52AM<br/>Groovy 2.5.2 Release Announcement.</p></li><li><p class='name'><a href='groovy-2-5-1-released'>Groovy 2.5.1 released</a><br/>Published by Remko Popma on 2018-07-14 02:18AM<br/>Groovy 2.5.1 Release Announcement.</p></li><li><p class='name'><a href='announce-announcing-codenarc-1-2'>Announcing CodeNarc 1.2</a><br/>Published by Remko Popma on 2018-07-10 10:16AM<br/>CodeNarc 1.2 Release Announcement.</p></li><li><p class='name'><a href='groovy-2-5-clibuilder-renewal'>Apache Groovy 2.5 CliBuilder Renewal</a><br/>Published by Remko Popma on 2018-05-30 11:28AM<br/>This post looks at new CliBuilder features from Groovy 2.5 in particular the Picocli-based implementation.</p></li><li><p class='name'><a href='groovy-2-5-0-released'>Groovy 2.5.0 released</a><br/>Published by Remko Popma on 2018-05-30 11:28AM<br/>Groovy 2.5.0 Release Announcement.</p></li></ul><ul class='pagination'/></div></div></div></div></div><footer id='footer'>
                            <div class='row'>
                                <div class='colset-3-footer'>
                                    <div class='col-1'>
                                        <h1>Groovy</h1><ul>
                                            <li><a href='https://groovy-lang.org/learn.html'>Learn</a></li><li><a href='https://groovy-lang.org/documentation.html'>Documentation</a></li><li><a href='/download.html'>Download</a></li><li><a href='https://groovy-lang.org/support.html'>Support</a></li><li><a href='/'>Contribute</a></li><li><a href='https://groovy-lang.org/ecosystem.html'>Ecosystem</a></li><li><a href='/blog'>Blog posts</a></li><li><a href='https://groovy.apache.org/events.html'></a></li>
                                        </ul>
                                    </div><div class='col-2'>
                                        <h1>About</h1><ul>
                                            <li><a href='https://github.com/apache/groovy'>Source code</a></li><li><a href='https://groovy-lang.org/security.html'>Security</a></li><li><a href='https://groovy-lang.org/learn.html#books'>Books</a></li><li><a href='https://groovy-lang.org/thanks.html'>Thanks</a></li><li><a href='http://www.apache.org/foundation/sponsorship.html'>Sponsorship</a></li><li><a href='https://groovy-lang.org/faq.html'>FAQ</a></li><li><a href='https://groovy-lang.org/search.html'>Search</a></li>
                                        </ul>
                                    </div><div class='col-3'>
                                        <h1>Socialize</h1><ul>
                                            <li><a href='https://groovy-lang.org/mailing-lists.html'>Discuss on the mailing-list</a></li><li><a href='https://twitter.com/ApacheGroovy'>Groovy on Twitter</a></li><li><a href='https://groovy-lang.org/events.html'>Events and conferences</a></li><li><a href='https://github.com/apache/groovy'>Source code on GitHub</a></li><li><a href='https://groovy-lang.org/reporting-issues.html'>Report issues in Jira</a></li><li><a href='http://stackoverflow.com/questions/tagged/groovy'>Stack Overflow questions</a></li><li><a href='http://groovycommunity.com/'>Slack Community</a></li>
                                        </ul>
                                    </div><div class='col-right'>
                                        <p>
                                            The Groovy programming language is supported by the <a href='http://www.apache.org'>Apache Software Foundation</a> and the Groovy community.
                                        </p><div text-align='right'>
                                            <img src='../img/asf_logo.png' title='The Apache Software Foundation' alt='The Apache Software Foundation' style='width:60%'/>
                                        </div><p>Apache&reg; and the Apache feather logo are either registered trademarks or trademarks of The Apache Software Foundation.</p>
                                    </div>
                                </div><div class='clearfix'>&copy; 2003-2024 the Apache Groovy project &mdash; Groovy is Open Source: <a href='http://www.apache.org/licenses/LICENSE-2.0.html' alt='Apache 2 License'>license</a>, <a href='https://privacy.apache.org/policies/privacy-policy-public.html'>privacy policy</a>.</div>
                            </div>
                        </footer></div>
                </div>
            </div>
        </div>
    </div><script src='../js/vendor/jquery-1.10.2.min.js' defer></script><script src='../js/vendor/classie.js' defer></script><script src='../js/vendor/bootstrap.js' defer></script><script src='../js/vendor/sidebarEffects.js' defer></script><script src='../js/vendor/modernizr-2.6.2.min.js' defer></script><script src='../js/plugins.js' defer></script><script src='https://cdnjs.cloudflare.com/ajax/libs/list.js/1.5.0/list.min.js'></script><script>
                var blogList = new List('blog-list', {
                    valueNames: ['name'],
                    page: 10,
                    pagination: true
                });
                var blogIndex = new List('blog-index', {
                    page: 30,
                    pagination: true
                });
                </script><script src='https://cdn.amcharts.com/lib/5/index.js'></script><script src='https://cdn.amcharts.com/lib/5/wc.js'></script><script>
                var root = am5.Root.new("chartdiv");
                var wc = root.container.children.push(am5wc.WordCloud.new(root, {
                    colors: am5.ColorSet.new(root, {})
                }));
                wc.data.setAll([
                { category: "concurrency", value: 2 }, { category: "groovy", value: 75 }, { category: "actors", value: 2 }, { category: "pekko", value: 1 }, { category: "gpars", value: 2 }, { category: "calendar", value: 1 }, { category: "date", value: 3 }, { category: "jsr310", value: 1 }, { category: "time", value: 1 }, { category: "data science", value: 7 }, { category: "eclipse collections", value: 9 }, { category: "kmeans", value: 3 }, { category: "emoji", value: 7 }, { category: "virtual threads", value: 3 }, { category: "scala integration", value: 1 }, { category: "clustering", value: 2 }, { category: "windows installer", value: 8 }, { category: "release", value: 25 }, { category: "decryption", value: 1 }, { category: "encryption", value: 1 }, { category: "security", value: 1 }, { category: "bouncy castle", value: 1 }, { category: "asf", value: 1 }, { category: "apachecon", value: 2 }, { category: "communityovercode", value: 1 }, { category: "collections", value: 5 }, { category: "zip", value: 1 }, { category: "guava", value: 3 }, { category: "vavr", value: 1 }, { category: "streamex", value: 1 }, { category: "jOOλ", value: 1 }, { category: "ginq", value: 6 }, { category: "gquery", value: 5 }, { category: "cycling", value: 2 }, { category: "duckdb", value: 1 }, { category: "sql", value: 2 }, { category: "csv", value: 2 }, { category: "award", value: 1 }, { category: "constraint programming", value: 1 }, { category: "jacop", value: 1 }, { category: "or-tools", value: 1 }, { category: "choco", value: 2 }, { category: "jsr331", value: 1 }, { category: "codenarc", value: 1 }, { category: "grails", value: 1 }, { category: "chatgpt", value: 1 }, { category: "one-liners", value: 1 }, { category: "machine learning", value: 2 }, { category: "artificial intelligence", value: 1 }, { category: "neural networks", value: 2 }, { category: "tribuo", value: 1 }, { category: "deep netts", value: 1 }, { category: "encog", value: 1 }, { category: "eclipse deeplearning4j", value: 3 }, { category: "deep learning", value: 3 }, { category: "graalvm", value: 3 }, { category: "native", value: 3 }, { category: "fibonacci", value: 1 }, { category: "recursion", value: 1 }, { category: "streams", value: 3 }, { category: "jep431", value: 1 }, { category: "maven", value: 1 }, { category: "gmaven", value: 1 }, { category: "natural language processing", value: 2 }, { category: "nlp", value: 1 }, { category: "nlpcraft", value: 1 }, { category: "java", value: 3 }, { category: "spock", value: 2 }, { category: "testing", value: 2 }, { category: "jqwik", value: 2 }, { category: "pitest", value: 1 }, { category: "junit", value: 2 }, { category: "jacoco", value: 1 }, { category: "blog", value: 1 }, { category: "2022", value: 1 }, { category: "parrot", value: 1 }, { category: "apache mxnet", value: 1 }, { category: "DJL", value: 1 }, { category: "artifical intelligence", value: 1 }, { category: "gradle", value: 2 }, { category: "zipping", value: 1 }, { category: "wordle", value: 1 }, { category: "domain specific languages", value: 1 }, { category: "jsr385", value: 1 }, { category: "units of measurement", value: 1 }, { category: "centroids", value: 1 }, { category: "records", value: 7 }, { category: "apache spark", value: 1 }, { category: "apache wayang", value: 1 }, { category: "delegation", value: 1 }, { category: "design pattern", value: 1 }, { category: "combinations", value: 1 }, { category: "permutations", value: 1 }, { category: "allpairs", value: 1 }, { category: "data", value: 1 }, { category: "deserialization", value: 1 }, { category: "files", value: 1 }, { category: "reading", value: 1 }, { category: "serialization", value: 1 }, { category: "writing", value: 1 }, { category: "opencsv", value: 1 }, { category: "commons csv", value: 1 }, { category: "jackson databind", value: 2 }, { category: "dataflow", value: 1 }, { category: "agents", value: 1 }, { category: "datetime", value: 2 }, { category: "timezone", value: 1 }, { category: "spark nlp", value: 1 }, { category: "apache opennlp", value: 1 }, { category: "corenlp", value: 1 }, { category: "nlp4j", value: 1 }, { category: "tensorflow", value: 1 }, { category: "djl", value: 1 }, { category: "smile", value: 1 }, { category: "datumbox", value: 1 }, { category: "lego", value: 1 }, { category: "lists", value: 2 }, { category: "commons collections", value: 2 }, { category: "apache", value: 2 }, { category: "gatherers", value: 1 }, { category: "jdk22", value: 1 }, { category: "chop", value: 1 }, { category: "collate", value: 1 }, { category: "inject", value: 1 }, { category: "jep461", value: 1 }, { category: "fold", value: 1 }, { category: "scan", value: 1 }, { category: "ignite", value: 1 }, { category: "obfuscated", value: 1 }, { category: "commons math", value: 2 }, { category: "@Sortable", value: 1 }, { category: "timecategory", value: 1 }, { category: "type checking", value: 1 }, { category: "printf", value: 1 }, { category: "regex", value: 1 }, { category: "format", value: 1 }, { category: "groovyfx", value: 1 }, { category: "javafx", value: 1 }, { category: "groovyConsole", value: 1 }, { category: "hephaestus", value: 1 }, { category: "null", value: 1 }, { category: "Groovy truth", value: 1 }, { category: "comparators", value: 1 }, { category: "functional", value: 1 }, { category: "lambdas", value: 1 }, { category: "sorting", value: 1 }, { category: "jvm", value: 1 }, { category: "h2", value: 1 }, { category: "scala", value: 1 }, { category: "kotlin", value: 1 }, { category: "lombok", value: 1 }, { category: "knapsack", value: 1 }, { category: "optimisation", value: 1 }, { category: "genetic algorithms", value: 1 }, { category: "dynamic programming", value: 1 }, { category: "matrices", value: 1 }, { category: "ojalgo", value: 1 }, { category: "nd4j", value: 1 }, { category: "ejml", value: 1 }, { category: "vector api", value: 1 }, { category: "clibuilder", value: 1 }, { category: "picocli", value: 1 }, { category: "commons cli", value: 1 }, { category: "bytecode", value: 1 }, { category: "byte buddy", value: 1 }, { category: "proguardcore", value: 1 }, { category: "asm", value: 1 }, { category: "jvmadvent", value: 1 }, { category: "json", value: 1 }, { category: "scripting", value: 1 }, { category: "AST transforms", value: 1 }, { category: "set", value: 1 }
                ]);
                wc.labels.template.setAll({
                    paddingTop: 5,
                    paddingBottom: 5,
                    paddingLeft: 5,
                    paddingRight: 5,
                    fontFamily: "Courier New"
                });
                </script><script>
          (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
          (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
          m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
          })(window,document,'script','//www.google-analytics.com/analytics.js','ga');

          ga('create', 'UA-257558-10', 'auto');
          ga('send', 'pageview');
    </script>
</body></html>