This is the next part in the series of "JavaFX in Action" interviews. Are you working on a fantastic JavaFX application? Let me know, and let's discuss it in the new year!

• July '24: Pedro Duque Vieira, Daniel Zimmermann, Christopher Schnick, and Robert Ladstätter
• November '24: Maciej Gorywoda, Ramiro Domínguez Ayub, Christoph Schwentker, Ulas Ergin
• December '24: Özkan Pakdil, Clément de Tastes, Almas Baim, Steve Hannah, Jago de Vreede
• March '25: Mike Hearn, Sven Reimers, Chris Newland

Cormac Redmond: KafkIO, the Kafka UI for Engineers and Admins

Cormac Redmond is an “All-things Java / Spring / MicroServices” expert who has been computing and programming from a young age. He has 20 years of professional experience spanning several industries, building everything from complex distributed systems to bespoke intranets and mobile apps. He enjoys fully and deeply understanding any domain or technology and is happiest when working within cultures that value the importance of building clean, elegant, testable, self-documenting systems while adopting forward-thinking practices and techniques.

KafkIO is designed for easy, fast, and enjoyable use. It only takes a few clicks before you’re exploring your Kafka clusters. No web servers, configuration files, clunky installation, Docker, or funky licensing! You can seamlessly create/edit/delete/dump/clear topics, produce messages, advanced search and streaming with text, offset, and date range criteria, tweak offsets, delete consumers, and browse/create/update schemas. Easily manage access control lists (ACLs). View your data in a variety of ways. Manage Kafka Connect connectors and ksqlDB (with a flexible KSQL editor). Troubleshoot issues with a clear view of the broker, topic, ksqlDB, connector, and consumer configuration, with live statistics such as partition skew, out-of-sync replicas, consumer lag, etc.

The UI is created with JavaFX and uses different libraries, which are all styled in a very consistent and easy-to-understand way. The application is beautifully designed and an excellent showcase of what can be achieved if a Java backend and JavaFX user interface are combined in one single powerful application!

More info in this blog post.

Brian Schlining: Annotating the Deep-Sea Wildlife

Brian Schlining is a Software Engineer at the Monterey Bay Aquarium Research Institute (MBARI), specializing in designing software systems to support scientific research. This includes data systems design, database development, user interface development (desktop and web applications), GIS, image and video analysis, micro-services, and analysis of large data sets.

Within MBARI, a full system of micro-services has been developed to store a large number of deep-sea videos and images, a knowledge base about the animals living in the sea, machine learning tools, etc.

VARS Annotation is a JavaFX user interface for creating and editing video annotations. It targets modern video workflows and is part of the MBARI Media Management software stack. It’s not a standalone application but depends on several external services that need to be deployed.

More info in this blog post.

Gerrit Grunwald: Creator of Many Amazing JavaFX Libraries

Gerrit Grunwald loves coding for around 40 years already. He is interested in desktop, mobile and IoT projects based on all possible technologies. But above all, he loves all-things-Java. He is the founder and leader of the Java User Group Münster (Germany), JavaOne rockstar and Java Champion. As Developer Advocate at Azul, he speaks a lot at conferences and user groups all around the world.

In the video, we discuss some of the libraries Gerrit has created, but there are a lot more! Check his GitHub repositories and blog…

• GitHub repositories
  • TilesFX: A JavaFX library containing tiles for Dashboards.
  • Medusa: A JavaFX library for Gauges.
  • Charts: A library for scientific charts in JavaFX.
  • and much more…
• Personal blog Harmonic Code
• Blog posts on Foojay.io

More info in this blog post.

Dirk Lemmermann: Creator of JavaFX Libraries and Applications

Dirk Lemmermann has over 40 years of programming and 30 years of professional experience. He is a seasoned and passionate software engineer and leader with a master’s degree in computer science and multiple honors and awards for his work in UI development and design, tool development, and scheduling applications.

As the CEO of Senapt and DLSC, he oversees the development of CRM systems for energy suppliers in England and Java and JavaFX consulting and software development for various domains and applications. His mission is to deliver high-quality, innovative, and user-friendly solutions that meet the needs and expectations of his clients and partners.

JavaFX Libraries

Dirk has created, or contributed to, a lot of libraries, and most of them are available as open source libraries!

• FlexGanttFX
• ControlsFX
• GemsFX
• WorkbenchFX
• CalendarFX
• GitHub repositories with more work by Dirk

JFX Central

JFX Central, the home to anything JavaFX related, is a website, desktop application, and mobile app, all based on the same code base. Both the tool itself, as the data it uses, are open source projects.

• JFX Central, website
• JFX Central, sources
• JFX Central, data sources

Senapt Applications

Senapt provides “Energy-as-a-Service Platform”, by providing an energy transactions platform for energy sellers and energy buyers in the UK. As the energy landscape has continued to change, retail electricity providers have been looking for strategies to meet the ever-growing, ever-changing demands for their customers. Senapt’s products have been designed to help energy suppliers to facilitate this changing relationship and allow them to seize the opportunities of the smart grid.

More info in this blog post.

The post Video series “JavaFX In Action”, Part 5 with Cormac Redmond (KafkIO), Brian Schlining (Annotating the Deep-Sea Wildlife), Gerrit Grunwald (JavaFX Libraries), Dirk Lemmermann (JavaFX Libraries and Applications, JFX Central) appeared first on foojay.

Recently Azul announced that AVD (Azul Vulnerability Detection), which is our solution to scan for security vulnerabilities in production, now comes with a new feature that only makes it possible to identify vulnerable components on a JAR file level but also on class file level.

The Production Scanning Challenge

So what does that mean? Usually, security scanners work in environments from development up to CI/CD, but not in production. The main reason for that is the fact that once you start scanning for vulnerabilities in production, the scanning process itself needs too many resources, which brings down the performance of the system. The performance decrease can be in the range of 10 to 30%, which explains why companies trust security scanners that scan in CI/CD and don't add additional scans in production.

Because at Azul we know how the JVM works, we created a solution that is mainly made for scanning in production with more or less no performance impact.

For that, we use a so-called Java Agent, which is also often used by other scanners, but we tuned it to use as few resources as possible, to keep performance up in production.

Given the dynamic nature of Java, it is a good idea to scan your application, also in production.

How AVD Architecture Works

The diagram below shows a possible scenario of using AVD:

You run your application on one or multiple JVM's (Java Virtual Machine), which can be any build of OpenJDK (e.g., Amazon Corretto, Adoptium Temurin, Azul Zulu, etc.). Now a Java Agent will be attached to each JVM you would like to monitor in production.

Each agent will send data that is coming from the JVM it is attached to, to the so called Forwarder, which is another Java program that will usually be installed somewhere in the infrastructure of your environment, in a way that it is reachable by the Java Agents.

The Forwarder has only one job, it forwards the information that was collected from the Java Agents to Azul Intelligence Cloud, where the data will be stored and analyzed.

Deployment Tagging and Reporting

Because these days many companies make use of continuous deployment, it makes sense to tag each new version of your application with a so-called "AppEnv" tag that can be defined by you.

Later on when creating reports, you can filter by these tags, which makes it possible to create reports for specific deployments or whatever you have in mind.

Once the setup is in place, you can create reports at any time either using the Intelligence Cloud web interface or the API that is provided.

The API makes it possible to integrate AVD into your own products, if you like, and the web interface can always be helpful to quickly take a look at the latest data.

Reducing False Positives Through Production Scanning

So, normally security scanners give you information about the vulnerable JAR files that have been detected which leads to huge lists of possible vulnerabilities that have to be checked by the security team. A lot of those vulnerabilities found are so called false/positives which means yes there might be a vulnerability but it wasn't used by the system. This analysis is very time consuming and holds your security team away from focusing on the really important vulnerabilities that might have an impact on your system.

By scanning in production, we can tell you not only if there are possible vulnerabilities, but also if you are using the vulnerable JAR files at all. This will drastically reduce the number of false positives because you can create lists that only contain the vulnerable libraries that have been called in production.

Class-Level Precision for Maximum Efficiency

But we figured out that we can do even better... and also provide information about the classes that have been used in those vulnerable JAR files.

These days you will find libraries with hundreds of classes and just because the library contains a vulnerability, it doesn't mean that your application called the classes in that library that contains the vulnerability.

So by giving you more detailed information at the class level, you are now able to shrink the list of vulnerabilities to check even further and focus only on the really severe vulnerabities which can be a time and money saver.

For more details, see How Azul Identifies Java Security Vulnerabilities with 1,000 Times Greater Accuracy.

The post Save Time and Money by Reducing False Positives appeared first on foojay.

On April 25, 2020, Geertjan Wielenga published the first Foojay post. Yes, we are celebrating 5 years since the Friends Of OpenJDK website launch! Today, more than 1,600 posts are on the site, written by over 250 authors. And there is much more to discover within the Foojay world...

In this podcast, we look at how Foojay started with founder Geertjan Wielenga. We'll also hear from Gerrit Grunwald about how Foojay's Disco API has become part of your daily work without you realizing it. We also have several of our regular authors and podcast guests who share how Foojay has influenced them (and vice versa).

Thank you all for being part of the Foojay community, whether as a listener of this podcast, a visitor to the website, a user of the Disco API, or through any other touchpoint!

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

• Spotify
• Apple Podcasts
• And most others...

Content

00:00 Introduction

00:58 Grace Jansen
https://foojay.io/today/author/grace-jansen

02:44 Geertjan Wielenga about the start and evolution of Foojay
https://foojay.io/today/author/geertjan-wielenga/
Foojay on Mastodon: https://foojay.io/today/foojay-mastodon-service-here-it-is/
Java Quick Start Course on Foojay: https://foojay.io/java-quick-start/
JDoodle on Foojay: https://foojay.io/today/integrate-executable-java-code-in-your-blog-posts-part-2-how-to-use-dependencies/
Foojay Slack: https://foojay.io/today/join-slack-com-t-foojay-signup/
Contribute to Foojay: https://foojay.io/today/how-to-submit-your-next-article-on-foojay-io/

12:24 Richard Fichtner
https://foojay.io/today/author/r-fichtner
Free JCon tickets: https://foojay.io/today/free-foojay-io-tickets-for-jcon-europe-2025-cologne/

13:19 Mary Grygleski
https://foojay.io/today/author/mgrygles

15:01 Shai Almog
https://foojay.io/today/author/shai-almog

16:59 Gerrit Grunwald about the Disco API
https://foojay.io/today/author/gerrit-grunwald/
Disco API Blog: https://foojay.io/today/disco-api-helping-you-to-find-any-openjdk-distribution/
Disco API Swagger UI: https://api.foojay.io/swagger-ui

24:38 Simon Ritter
https://foojay.io/today/author/simonritter

25:10 Marit van Dijk
https://foojay.io/today/author/marit-van-dijk

25:47 Hanno Embregts
https://foojay.io/today/author/hanno-embregts

26:42 Bazlur Rahman
https://foojay.io/today/author/bazlur-rahman

29:10 Artur Skowroński
JVM weekly: https://www.linkedin.com/newsletters/jvm-weekly-7097859802881540096

30:22 Conclusion and looking forward to 30 years of Java with James Gosling

The post Foojay Podcast #70: Celebrating 5 Years of Foojay appeared first on foojay.

Last month, I published a Foojay article about the risks in systems that are stuck on old or outdated Java versions and got a lot of feedback from developers. Most of them want to move on but get stuck on management decisions, outdated production environments, or one of the many other reasons that keep systems stuck on old Java versions and dependencies.

Do you want to bring your system from Java 8 to 23? Did you know that Java 17 already has 13 security releases? And that you can use tools like OpenRewrite to help you update your code?

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

• Spotify
• Apple Podcasts
• And most others...

Guests

• Gerrit Grunwald: https://www.linkedin.com/in/gerritgrunwald/
• Jonathan Schneider: https://www.linkedin.com/in/jonkschneider/
• Martijn Dashorst: https://www.linkedin.com/in/dashorst/
• Carl Wanting: https://www.linkedin.com/in/carl-wanting-638943/
• Charl Fasching: https://www.linkedin.com/in/charl-fasching-77843288/
• Johan Janssen: https://www.linkedin.com/in/johanjanssen2001/

Content

00:00 Introduction of the topic and guests 

01:35 Gerrit Grunwald about CVE fixes in Java updates 
04:58 LTS (Long Term Support) versus STS (Short Term Support) 

9:45 Jonathan Schneider about the goal of OpenRewrite 
12:15 Upgrade all at once, or step by step? 
14:03 Who creates the recipes? 
15:08 What Moderne is offering on top of OpenRewrite  
17:29 How to use OpenRewrite in your IDE 
18:32 Companies maintaining recipies for their products 
20:05 Jonathan's view on the importance of upgrades  
26:56 Other use cases for OpenRewrite 

29:03 Martijn Dashorst: Updating legacy projects   

33:12 Carl Wanting and Charl Fasching: Migrating projects 

39:43 Johan Janssen: Java evolutions and upgrading  

42:51 Outro 

The post Foojay Podcast #63: How do we keep our Java applications up to date and secure? appeared first on foojay.

This is part 4 of the JCON interviews!

In this episode, we have 5 new guests for you.

• We start with garbage collectors and Intelligence Cloud, a tool created by Azul to find out which of your code is actually used in production and which dependencies are known to have vulnerabilities. My colleague Gerrit Grunwald was at JCON to give a talk about these subjects. 
• With Balkrishna Rawool we dove into Virtual Threads, a very interesting topic as concurrency and threads can be challenging... 
• Piotr Przybyl came to JCON to give a talk about Test Containers and how to test your application in an environment that is similar to your production environment. Another important topic related to testing is Flaky Tests. How do you handle tests that only fail from time to time and make your whole test report unreliable?
• François Martin had a talk about this subject, and he came to the conference together with Annelore Egger, who was one of the many volunteers. 

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

• Spotify
• Apple Podcasts
• And most others...

Content

00:37 Gerrit Grunwald:  Talks about Garbage collectors, What is Intelligence Cloud and how can you find out which of your code is actually used in production and which dependencies are known to have vulnerabilities 

https://www.linkedin.com/in/gerritgrunwald

09:55 Balkrishna Rawool: Talks about structured concurrency, virtual threads, what will come in the next Java releases 

https://www.linkedin.com/in/balkrishnarawool

18:00 Piotr Przybyl: Talks about Test Containers, ToxiProxy, how to test your applications in an environment that is similar to your production environment. 

https://www.linkedin.com/in/piotrprzybyl

29:23 François Martin: Volunteer JCON + Talks about Flaky Tests, how to handle waits in unit tests, how to do user interface tests, how to reproduce flaky tests. 

https://www.linkedin.com/in/fran%C3%A7oismartin

38:09 Annelore Egger: Volunteer JCON + Visitor + the Java comm

https://www.linkedin.com/in/annelore-egger-244879188

The post Foojay Podcast #52: JCON Report, Part 4 – Garbage Collectors, Intelligence Cloud, Test Containers and Flaky Tests, ToxiProxy, Structured Concurrency, Virtual Threads appeared first on foojay.

If you want to learn more about CRaC, feel free to read about it here.

CRaC is an OpenJDK project that can "snapshot" a running JVM (Java Virtual Machine) and store its state, including your application, to disk. Then, at another point in time, you can restore the JVM from the saved checkpoint back to memory. With this, one can start an application, warm it up, and create a checkpoint. Restoring from the saved checkpoint back to memory mainly relies on disk I/O, which means it is really fast (in the range of milliseconds).

To test the support for CRaC in SpringBoot 3.2, I will use the SpringBoot Petclinic demo.

Sponsored Content

Redis Released: A Worldwide In-Person Event Series

We’re talking new releases & fast AI, all over the world!

Watch the Replays Here

For this little test, I run Ubuntu 22.04 in Parallels on my M1 Macbook Pro using 4 cores and 4GB of RAM.

Prerequisites

To make use of CRaC in SpringBoot 3.2, you need to have three things:

• A JVM with support for CRaC
• A dependency for org.crac
• A folder where the checkpoints can be stored

The JDK
The used JDK (Java Development Kit) is Azul Zulu 21.0.1 + CRaC that you can get here. The JDK is available for x64 and aarch64 cpu architecture and for JDK 17 and JDK 21.

Permissions
It might be needed to set the permissions to be able to use CRIU, meaning to say on the Linux machine you run the demo, you need to execute the following commands once:

sudo chown root:root $JAVA_HOME/lib/criu
sudo chmod u+s $JAVA_HOME/lib/criu

org.crac.
Clone the petclinic repository to your local machine and add the dependency on the org.crac library.

Because CRaC at the moment is only available on Linux, you won't find a JDK that comes with support for CRaC for MacOS and Windows. This means you could not code against the CRaC API if you are on Mac or Windows machines. To solve this problem, the org.crac library offers the same API that is available in CRaC-enabled JDK's but instead of using the `jdk.crac` namespace, you will find it in the `org.crac` namespace.

With this, you can code against the CRaC API even on MacOS and Windows without having problems and as soon as you run it on a Linux system with a CRaC enabled JDK, it will use the CRaC feature.

You can find org.crac on Maven central, so you can add the dependency as follows:

Gradle:

implementation 'org.crac:crac:1.4.0'

Maven:

<dependency>
  <groupId>org.crac</groupId>
  <artifactId>crac</artifactId>
  <version>1.4.0</version>
</dependency>

Create a folder for the checkpoint
Before we test that we need to make sure that we have a folder where the checkpoint can be stored e.g. /tmp_checkpoint in the project folder.

Startup without using CRaC

Once you've cloned the petclinic repository, you need to build the project (e.g., gradlew clean build) and then you can run it.

The only thing we are interested in is the startup time of the application. I did tests on both JDK versions (17 and 21) and first of all, just by switching from 17 to 21 improved the startup time of the petclinic application already by 500ms!

So, if possible, you should switch the JDK as soon as possible to benefit from the better performance.

Start the application by executing:

java -jar spring-petclinic-3.2.0.jar

Here are the results when starting up the application without using CRaC:

OK, it's around 500ms faster but still takes some time to start up, so let's take a look at another approach that was implemented in SpringBoot 3.2.

Automatic Checkpoint

The engineers in the Spring team had a nice idea to improve the startup time of the Spring/SpringBoot framework by creating a checkpoint automatically right before the application is started.

Here is the description from the documentation:

"When the -Dspring.context.checkpoint=onRefresh JVM system property is set, a checkpoint is created automatically at startup during the LifecycleProcessor.onRefresh phase. After this phase has completed, all non-lazy initialized singletons have been instantiated, and InitializingBean#afterPropertiesSet callbacks have been invoked; but the lifecycle has not started, and the ContextRefreshedEvent has not yet been published."

To make use of the automatic checkpointing, we start the application as follows:

java -Dspring.context.checkpoint=onRefresh -XX:CRaCCheckpointTo=./tmp_checkpoint -jar spring-petclinic-3.2.0.jar

After executing the application, it will create the checkpoint, store the checkpoint files in the folder ./tmp_checkpoint, and will then exit the application.

Now you can restore the application from the checkpoint (which means starting it again) by executing:

java -XX:CRaCRestoreFrom=./tmp_checkpoint

Here are the results related to the startup time when restoring from the automatic checkpoint

This is pretty cool, we get a startup time that is one order of magnitude faster than the original startup time without the need of changing our code. It also means the checkpoint only contains the framework code and not your application code, because that was not started yet.

Manual Checkpoint

The automatic checkpoint is already a big improvement related to startup time but we can even go faster than that by using a manual checkpoint.

When using manual checkpoints, you can decide whenever you like to create a checkpoint.

Why is that important?

Well you might want to create a checkpoint after 10 minutes or when your application is completely warmed up (most/all of the code was compiled and optimized) etc.

The procedure to create a manual checkpoint is similar to the automatic checkpoint, the only difference is that you trigger the checkpoint from outside the application instead of having the framework creating the checkpoint automatically.

Before we start, make sure that the folder for the checkpoint is empty.

First you start your application as follows:

java -XX:CRaCCheckpointTo=./tmp_checkpoint -jar spring-petclinic-3.2.0.jar

Now you wait until the application was completely started up before you open a second shell window.
In this second shell window, you execute the following command:

jcmd spring-petclinic-3.2.0.jar JDK.checkpoint

Now you should see that in the first shell window, where you started the petclinic application, a checkpoint is created and the application was shut down.

You could check whether the application was checkpointed by verifiying that the folder ./tmp_checkpointcontains the checkpoint files.

Now you can close the second shell window.

To restore the application from this checkpoint you execute the same command as for the automatic checkpoint:

java -XX:CRaCRestoreFrom=./tmp_checkpoint

This manually triggered checkpoint does not only contain the framework code but also the application code which means we should see an even faster startup because the application was already loaded and started by the framework. So here are the results:

As you can see, we have been able to reduce the startup time of the petclinic application by another order of magnitude down to 75ms!

Info

Because Spring 6.1 and SpringBoot 3.2 fully support CRaC, we didn't need to make modifications to the code. Full support here means that as long as you use Spring resources, the framework will take care about closing resources before a checkpoint and restoring them after a restore.

In case you use other resources, you need to implement the CRaC Resource interface in the related classes and close those other resources (e.g. open files or socket connections) in the `beforeCheckpoint()` method and re-open the other resources in the `afterRestore()' methods.

Verdict

As we saw, the use of CRaC can dramatically reduce the startup time of a SpringBoot 3.2 application. In case you just would like to try it without touching your code you could reduce the startup time by one order of magnitude by simply using the automatic checkpoint feature in Spring 6.1 / SpringBoot 3.2.

For the fastest possible startup time, you can manually create a checkpoint which can bring down the startup time by two orders of magnitude.

The nice thing about CRaC is that fact that it is still running on a normal JVM and that the code can even further be optimized after a checkpoint/restore.

To get these results I needed to add a few lines of code to the petclinic project and if you would like to reproduce the numbers, feel free to clone my copy of the petclinic project over at my GitHub repository.

Happy cracing...

The post SpringBoot 3.2 + CRaC appeared first on foojay.

Sponsored Content

Revenue Intelligence for Dev-Focused Companies

Reo.Dev analyzes developer activity across 20+ sources to identify high-intent accounts and key contacts ready to buy.

See How Reo.Dev Works!

The post Video: “If I decide to stay with Oracle Java what issues will I face?” appeared first on foojay.

Because this alone was not enough to get it into the Mac App Store, I needed to add more functionality and so I've decided to also show the latest version of the last 4 LTS (Long Term Support) releases with the ability to download them either as JDK or JRE and if you like bundle JavaFX with it. At the moment that would mean JDK 8, 11, 17 and 21 with their latest versions available.

You need to be on MacOS Sonoma to be able to run the app because of the widgets that are only on Sonoma upwards.

The downloads are based on the free builds of OpenJDK by Azul (Zulu) and will only be downloaded as tar.gz packages to your Downloads folder.

Here are some screenshots...

The application:

The available widgets:

You can find the app on the MacOS app store following this link...

If you have ideas on how to improve this app... just let me know and ping me on twitter.

The post New: JDKMonitor appeared first on foojay.

Just in case you are in the area and interested to join one of our sessions or if you only would like to meet us in person, please check out the following links to get further information about the location etc.

Tour Stops:

Monday, 09/18/2023
Central Ohio JUG
Columbus, Ohio
(http://www.cojug.org/)

Tuesday, 09/19/2023
Garden State JUG
Madison, New Jersey
(https://gsjug.org/)

Wednesday, 09/20/2023
Detroit JUG
Detroit, Michigan
(https://www.meetup.com/detroit-java-user-group/)

Thursday, 09/21/2023
Omaha JUG
Omaha, Nebraska
(https://www.meetup.com/omahajava/)

Friday, 09/22/2023
Montreal JUG
Montreal, QC, Canada
(https://www.meetup.com/montreal-jug/events/)

We are really looking forward to meet you there... keep coding...

The post Gerrit and Ivar’s North America JUG Tour! appeared first on foojay.

Java and JavaFX are probably not the first options you consider if you want to create a game application.

But the FXGL library allows you to do precisely that! Create games that run on all platforms with the same codebase as we are used to with Java.

And even without an extra library, the JavaFX Components and Canvas provide many animation and gaming possibilities.

Let's learn from experts why Java should be on your game-development-language-list!

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

• Spotify
• Apple Podcasts
• And most others...

Guests

• Chengen Zhao
  • https://twitter.com/WhiteWoodCity
  • https://www.linkedin.com/in/chengenzhao/
  • Steam game created with JavaFX: Xtrike
• Almas Baim
  • https://github.com/AlmasB
  • https://twitter.com/AlmasBaim
  • https://www.youtube.com/almasb0/videos
  • https://github.com/almasb/fxgl
• Gerrit Grunwald
  • https://twitter.com/hansolo_/
  • https://mastodon.social/@hansolo_
  • https://github.com/HanSolo/jarkanoid
  • https://github.com/HanSolo/SpaceFX

Content

• 00’00 Intro and introduction of the guests
  • https://foojay.io/today/foojay-podcast-9/
• 04’00 About FXGL
  • https://foojay.io/today/book-review-learn-javafx-game-and-app-development-with-fxgl-17/ 
  • https://foojay.io/today/creating-a-snake-game-with-javafx-fxgl-in-three-pair-programming-sessions/  
• 08’48 How Chengen used FXGL to improve his Xtrike game
• 10’15 Combining 2D and 3D
• 11’20 The fascination of Gerrit for retro games
• 13’36 JavaFX components versus Canvas
  • https://twitter.com/AlmasBaim/status/1658565437053980691
  • https://twitter.com/AlmasBaim/status/1649882265986424832
  • https://twitter.com/AlmasBaim/status/1642277058033139712
  • https://twitter.com/AlmasBaim/status/1640102122350944257
• 19’09 Creating games while waiting in airports…
• 22’19 Convert to mobile and Steam apps
• 23’22 Question of Chengen if FXGL can extend view components 
• 24’58 How students are involved in the FXGL project
  • https://foojay.io/today/java-in-education-combining-java-with-raspberry-pi-and-the-pi4j-library/
• 29’53 Why FXGL has a mix of Java and Kotlin
• 32’22 Building for mobile and the hassle with the app stores…
  • https://foojay.io/today/cross-platform-development-in-java-with-gluon-and-graalvm-part-2/
  • https://foojay.io/today/porting-an-existing-javafx-app-to-ios/ 
  • https://foojay.io/today/creating-mobile-apps-with-javafx-part-3/ 
• 38’58 3D in JavaFX
  • https://foojay.io/today/visualizing-brain-computer-interface-data-using-javafx/
  • https://foojay.io/today/javafx-3d-a-look-back-in-history-and-some-experiments/ 
  • https://github.com/FXyz/FXyz
• 44’14 Status of Swing
• 47’13 About the Java community in China
• 49’23 Could a drag-and-drop animation tool be created for FXGL?
  • https://github.com/AlmasB/FXGL/blob/dev/fxgl-tools/src/main/java/com/almasb/fxgl/tools/editor/EditorApp.java 
• 51’13 Use JavaFX FXML markup files? And can SceneBuilder provide a code-only approach?
• 55’34 Conclusion

The post Foojay Podcast #25: Game Development with Java, JavaFX, and FXGL appeared first on foojay.