IntelliJ IDEA on foojay.io - Friends of OpenJDK

Getting Started with Exposed: Kotlin ORM Made Simple

Mon, 06 Jul 2026 03:39:00 +0000

Introduction

For quite some time, I have been a huge fan of and fascinated by JetBrains products, tools, and libraries because of their masterful craftsmanship in product creation and their pristine focus on building high-quality developer tools.

Even more excitingly, JetBrains Java Annotated Monthly newsletters have featured most of the technical articles I wrote for Foojay on topics such as Java, Spring, Spring Boot 4, and OpenRewrite.

Recently, one Kotlin Domain-Specific Language (DSL) library caught my attention. I immediately tried converting my existing Spring Boot 4 application from Java to Kotlin using Exposed, an ORM framework for Kotlin. Kotlin SQL Libary

You’re invited to IntelliJ IDEA Conf 2026!

Mon, 29 Jun 2026 18:35:08 +0000

We are excited to invite you to IntelliJ IDEA Conf 2026, a free virtual event on September 8-9, 2026.

IntelliJ IDEA Conf is a celebration of the developer community, bringing together professionals who strive for excellence in software development. Join us for this free, live online conference and learn from industry leaders and experts on September 8-9, 2026.

You’ll be able to learn about a broad range of topics relevant to modern Java and Kotlin development, including language evolution, enterprise Java, Spring-based applications, build tooling, containerized workflows, JVM performance, and data access technologies. For more details, see the agenda below.

Ask a Lille Dev

Tue, 16 Jun 2026 00:35:19 +0000

During the DevLille 2026 conference in Lille, I interviewed several Java developers and tech professionals with one simple goal: collecting authentic and spontaneous insights from the Java ecosystem. ☕🎤

The result became “Ask a Lille Dev”, a mini podcast made of short interviews recorded directly during the conference. Instead of long talks or polished marketing speeches, the idea was simple: ask practical questions to people working in tech every day.

Explore Spring AI SDK – Amazon Bedrock AgentCore – Part 3

Sun, 10 May 2026 09:09:00 +0000

In Part 1 and Part 2 , we explored the Spring AI SDK and Amazon Bedrock AgentCore features, including the agentcore runtime starter and integration of agentcore memory. In this article, we will explore the integration of AgentCore built-in tools, including the Browser and Code Interpreter features.

Repository containing the companion code for the tutorial. Go to GitHub {#https://github.com/bsmahi/simple-spring-boot-agent}. Built-In Tool Browser

The use case I am trying to build here is for the given URL; it navigates the entire website and retrieves the content and gives key points and the summary of the page using the AgentCore Browser tool.

Explore Spring AI SDK – Amazon Bedrock AgentCore – Part 2

Mon, 27 Apr 2026 09:09:00 +0000

If you’re joining us from Part 1 or need a quick refresher on the architecture, listen to this brief overview of how Spring AI and Amazon Bedrock work together. Generated using Notebook LLM for my previous article {#https://foojay.io/today/spring-ai-amazon-bedrock-sdk-guide/}

In this article, we explore one of the AgentCore capabilities i.e., memory Source: Amazon

To begin, enable AgentCore memory for the agent you built earlier.

Step 1: Add the Ai model and AgentCore memory dependencies

<dependency>
 <groupId>org.springframework.ai</groupId>
 <artifactId>spring-ai-model</artifactId>
</dependency>
<dependency>
 <groupId>org.springaicommunity</groupId>
 <artifactId>spring-ai-agentcore-memory</artifactId>
</dependency>

Step 2: Create Short/Long Term in AWS Management Console

Navigate to Amazon Bedrock AgentCore > Memory to create short/long-term memories. AgentCore Memory

Explore Spring AI SDK - Amazon Bedrock AgentCore - Part 1

Mon, 20 Apr 2026 13:44:54 +0000

Introduction

Artificial intelligence has rapidly expanded across every industry since the inception of ChatGPT. It represents a breakthrough in how we build and use software. Moreover, this breakthrough technology has driven major transformation. At the same time, it has created significant noise and hype.

Today, AI is no longer experimental. Instead, it has become essential, much like electricity and the internet. As a result, it now plays a key role in our daily lives. Overall, this shift reflects strong technological acceleration across industries.

25 Years of IntelliJ IDEA: The IDE That Grew Up With Java

Mon, 02 Mar 2026 07:21:06 +0000

In this Foojay Podcast, we’re celebrating a major milestone in Java development history: 25 years of IntelliJ IDEA.

Think about it: IntelliJ IDEA launched in 2000, and since then, it has become the go-to IDE for millions of Java developers worldwide. From its revolutionary code completion and refactoring tools to AI-powered features and the recent unified Community and Ultimate release, IntelliJ has shaped how we write Java, and keeps reinventing itself to stay ahead.

Command completion (..) in IntelliJ IDEA

Tue, 20 Jan 2026 07:31:35 +0000

How many shortcuts can you remember? Three? Five? More? I try to learn as many as I can and still forget some of them…

What if you could unlock IntelliJ IDEA features, without having to remember shortcuts? You can still use shortcuts if you want. But you don’t haveto.

Command completion (..) is a new feature in IntelliJ IDEA that lets you discover and execute IDE actions right from your editor.

TornadoInsight - Compatibility with TornadoVM SDK 2.0+ & Configuration Guide

Tue, 30 Dec 2025 09:00:00 +0000

This blog updates the previously published TornadoInsight configuration ++guidelines++ and explains how to configure the required environment variable to ensure that TornadoInsight correctly detects the TornadoVM SDK when IntelliJ IDEA is launched from a graphical environment.

Overview

TornadoInsight requires access to a compatible Java Development Kit (JDK) and the TornadoVM SDK.{#o7o5c20810}

Important update:{#mvwo920904}

Since version ++v1.4.0++ , TornadoInsight can also use the JDK configured directly in IntelliJ IDEA via Project Structure. This means that, in many cases, users no longer need to configure the Java SDK in the plugins settings.{#welj420814}

Java developer's guide : Sync Rules & Stop CI Failures

Tue, 16 Dec 2025 15:53:28 +0000

Hola Java developers! 👋

Welcome back. In Part 1 , we installed SonarQube for IDE in IntelliJ. You are now catching those nasty NullPointerExceptions and Optional.get() risks before they leave your keyboard.

But… you are not working alone. You are part of a team pushing code to a repo full of XML configs, DTOs, and Services.

Here is the nightmare scenario: You spend all day refactoring your Spring Boot service. It looks perfect. You run your tests. They pass. You push it to Git. You grab a coffee. ☕ And then… FAIL. 🔴

SonarQube for IDE in IntelliJ: The Ultimate Java Developer’s Guide

Fri, 12 Dec 2025 15:43:00 +0000

Hola Java developers! 👋

Let’s be honest. We have all been there. You write a piece of code, it compiles perfectly, the unit tests pass, and you think: “This is solid.”

Then… boom. The CI/CD pipeline fails 20 minutes later because of a security vulnerability. Or worse, a NullPointerException wakes you up on the weekend because you forgot to check if that Optional was actually present.

We want to deliver High Code Quality and Security, but we are humans. We get tired, we lose focus.

Spring Boot 4 - OpenTelemetry Guide

Wed, 10 Dec 2025 09:09:58 +0000

In my previous article , I outlined a comprehensive list of features introduced in Spring Framework 7 and Spring Boot 4.

In this series of articles, we will explore these features in detail using a pragmatic approach. In this second article, I will dive deep into integration of Observability framework i.e., OpenTelemetry with SpringBoot.

As an architect and developer, when I engage in system design—whether it involves monolithic architecture, microservices, or contemporary cloud-native applications—I have made the integration of observability patterns utilizing open-telemetry tools a standard practice. Through observability, we can monitor application behavior via metrics, logs, and traces that we trigger

Spring Framework 7 API Versioning Explained

Wed, 29 Oct 2025 06:45:53 +0000

In my previous article , I outlined a comprehensive list of features introduced in Spring Framework 7 and Spring Boot 4.

In this series of articles, we will explore these features in detail using a pragmatic approach. To begin, I will deep dive into the API versioning feature introduced in Spring Framework 7.

Any architectural or feature change stems from evolving business requirements, and API versioning is no exception. In today’s app-driven ecosystem, APIs are central to product integration and user experience.

Spring Cloud Stream for Real-Time Event-Driven Systems

Mon, 21 Jul 2025 13:33:34 +0000

Envision operating a successful e-commerce platform where every moment is crucial. Customers make purchases, adjust inventory levels, process payments, and dispatch shipping alerts—all in real time. In the background, microservices diligently function to guarantee seamless operations. However, how do these services interact effectively, particularly during peak traffic occurrences such as flash sales or holiday shopping events?

An efficient method to execute this use case involves utilizing Spring Cloud Stream (SCS) as the messaging infrastructure. SCS facilitates seamless interaction among microservices, enhancing the system’s responsiveness and scalability. A significant benefit of SCS is that it provides an abstraction layer, allowing developers to transition between messaging technologies such as Kafka or RabbitMQ or Pulsar or Amazon Kinesis without altering their fundamental business logic.

You’re Invited to IntelliJ IDEA Conf 2025!

Mon, 05 May 2025 10:20:30 +0000

We are excited to invite you to IntelliJ IDEA Conf 2025, a free virtual event.

You’ll be able to learn about a variety of topics, including Core Java, Kotlin, Java and AI, Spring Boot, GraalVM, Gradle, Junit and Kafka. For more details, see the agenda below.

Code Reviews with AI a developer guide

Fri, 07 Mar 2025 12:10:37 +0000

Code reviews are a cornerstone of software development. They’re where we share knowledge, catch bugs early, and ensure our code meets the highest standards.

But let’s be honest…

Traditional code reviews can be time-consuming and tedious and sometimes even miss subtle yet critical issues. Enter the age of AI-powered code review, a game-changer that addresses these challenges and elevates code quality to new heights.

This article dives into the common pitfalls of code reviews and explores how AI tools can revolutionize each phase of the development lifecycle.

Review of Junie, a coding agent by JetBrains – Revie

Wed, 26 Feb 2025 01:38:47 +0000

Other languages: Español 한국어 Português 中文

Recently, I talked about Duplicate Finder on the Foojay Podcast hosted by Frank Delporte . We briefly touched upon implementing support for other formats, and Frank asked if I’m planning on adding AsciiDoc, as it could be useful for his technical writing at Azul.

We agreed to think about adding the support soon. At the same time I got access to Junie , a newly announced coding agent by JetBrains, which is currently in early access. After a while, a thought came to me that this is a great opportunity to try it in action.

More Free Shells for your Java IDE

Tue, 31 Dec 2024 14:30:57 +0000

You may be using one of the terminal applications installed on your operating system or use the included terminal panel of the IDE.

Not all shells are included in your IDE. Here is a list of shells by default supported for the IDE’s based on my Windows computer.

|———————————–|—————|———|—————–| | Shell | IntelliJ IDEA | Eclipse | Apache NetBeans | | Command Prompt | ✅ | ✅ | | | Powershell | ✅ | | | | WSL (Windows Subsystem for Linux) | ✅ | ✅ | | | Git Bash | (1) | ✅ | | | Cygwin | (1) | | ✅ | | SSH (Secure SHell) | | ✅ | ✅ |

Build and Run TornadoVM with IntelliJ IDEA

Wed, 20 Nov 2024 19:08:13 +0000

TornadoVM is an open-source Java technology that is developed to aid Java programmers in adapting their code bases for hardware acceleration.

This blog aims to explain how Java programmers can build TornadoVM with IntelliJ IDEA, and how they can run TornadoVM unit-tests or other Java programs.

Prerequisites

This blog uses IntelliJ IDEA 2024.2.4 version and the list of required plugins are as follows:{#r55ph1440}

Python ++plugin++ to be installed in IntelliJ. This plugin allows python scripting from the IDE.

{#x95ro33520}

Spring Boot: Java Template Engine (JTE)

Wed, 13 Nov 2024 09:03:00 +0000

Hello to all Java and Spring enthusiasts. I am the Java Template Engine, a fresh newcomer to the Spring Initializer Ecosystem.

I have gained popularity as a template engine for developing user interface applications that use Java syntax within Spring Boot applications, alongside other engines such as Freemarker, Thymeleaf, Mustache, and Velocity. Many developers widely use Spring Boot, a framework that simplifies Java application development, and incorporating a template engine like mine streamlines the process of creating dynamic and responsive user interfaces.

Book Review: Mastering the Java Virtual Machine

Fri, 18 Oct 2024 13:54:49 +0000

Otávio Santana’s “Mastering the Java Virtual Machine” takes readers on an insightful journey through the inner workings of the JVM. As I read this book, I found myself reconnecting with the fundamentals of Java programming while also discovering new depths of understanding.

The book strikes a perfect balance between nostalgia and innovation. It reminded me of my early programming days, while also introducing cutting-edge concepts that are crucial for modern Java development. Santana uses clever technical metaphors to make complex JVM internals more accessible, bridging the gap between theory and practical application.

Profile IntelliJ IDEA with its own profiler

Wed, 16 Oct 2024 15:49:38 +0000

Other languages: Español 한국어 Português 中文

Just like my previous post , this one is going to be slightly meta. Obviously, you can use IntelliJ IDEA to profile another process , but did you know IntelliJ IDEA can profile itself?

This might be useful if you are writing an IntelliJ IDEA plugin and need to address issues related to your plugin’s performance.

Also, regardless of whether you are a plugin author, the described case might be interesting to you because the profiling strategy that I’ll cover is not exclusive to IntelliJ IDEA – you can use it to troubleshoot similar bottlenecks in other types of projects and using other tools.

Allocation Profiling in Java

Fri, 09 Aug 2024 08:44:59 +0000

Read in other languages : 中文 Español Português

We often find ourselves in situations when code is not working properly, and we have no idea where to even begin investigating.

Can’t we just stare at the code until the solution eventually comes to us? Sure, but this method probably won’t work without deep knowledge of the project and a lot of mental effort. A smarter approach would be to use the tools you have at hand. They can point you in the right direction.

A Beginner's Guide to IntelliJ Profiler

Thu, 04 Jul 2024 06:26:35 +0000

Read in other languages: 中文 Español Português

Sometimes your app works, but you want to increase performance by boosting its throughput or reducing latency. Other times, you just want to know how code behaves at runtime, determine where the hot spots are, or figure out how a framework operates under the hood.

This is a perfect use case for profilers. They offer a bird’s eye view of arbitrarily large execution chunks, which helps you see problems at scale.

Hack a Java application with the debugger

Thu, 13 Jun 2024 04:58:03 +0000

Read in other languages: 中文 Español Português

Back in the day, computer games were different. Not only have graphics and mechanics evolved since, but there’s also one characteristic that doesn’t seem very common in games today: nearly all of them had cheat codes.

Cheat codes were sequences of keys that would give you something extraordinary, such as infinite ammo or the ability to walk through walls. The most common and powerful of them was ‘god mode’ – it made you invincible.

Foojay Podcast #50: JCON Report, Part 2 - Maven, Software Security, Code Quality

Mon, 27 May 2024 08:07:54 +0000

This is part 2 of the interviews we recorded at the JCON conference earlier this month in Germany. In this episode, you get two main topics: Maven and Code Quality.

In the first part, you’ll hear Karl Heinz Marbaise and Steve Poole discuss the Maven project, the repository, Sonaytype, and the security impact of dependencies.

But next to security, we developers are also responsible for creating readable and maintainable code. Miro Wengner, Marit van Dijk, and Hinse ter Schuur dive into this topic, in the second part!

Learn how to debug unresponsive Java/JVM applications, then reload the fix on the fly, using a hands-on example

Thu, 23 May 2024 07:14:31 +0000

Read in other languages: 中文 Español Português

There are a lot of debugger tutorials out there that teach you how to set line breakpoints, log values, or evaluate expressions. While this knowledge alone gives you a lot of tools for debugging your application, real-world scenarios may be somewhat trickier and require a more advanced approach.

In this article, we will learn how to locate code that causes a UI freeze without much prior knowledge of the project and fix faulty code on the fly.

Debug Without Breakpoints – Guide to IntelliJ IDEA's Pause

Mon, 22 Apr 2024 06:59:28 +0000

Read in other languages: 中文 Español Português

In a typical debugging scenario, you would set breakpoints to tell the debugger when to suspend your program. A breakpoint usually corresponds to the moment that marks the starting point of the further investigation.

However, in some situations you aren’t certain about where to set a breakpoint. Other times, you might prefer to suspend the program at a particular time rather than aiming at a specific line.

IntelliJ IDEA and Open Liberty - Effective Java app development

Fri, 12 Apr 2024 13:36:25 +0000

See how you can use Liberty Tools for IntelliJ IDEA to enable rapid, easy, and efficient development of cloud-native Java applications with Open Liberty and WebSphere Liberty

When it comes to integrated development environments, within the Java community, IntelliJ IDEA is the most popular IDE amongst professional developers. It is the preferred IDE of choice by two-fifths of developers, making up the biggest majority of IDE users in this community, according to JRebel’s 2023 Java Developer Productivity Report .

Tips for reading code

Tue, 26 Mar 2024 11:46:58 +0000

As developers, we read code more than we write it. When adding new features or fixing bugs, we first need to understand existing code, so we can make the right changes in the right place.

When reading code inside the IDE, IntelliJ IDEA helps us to read and understand code by providing helpful features like syntax highlighting and inlay hints. But there are more features to help us understand a piece of code.

TornadoInsight: Harness the Power of TornadoVM from IntelliJ IDEA

Fri, 08 Mar 2024 11:59:07 +0000

TornadoInsight is an open-source IntelliJ IDEA plugin for enhancing the developer experience when working with TornadoVM.

It provides a built-in on-the-fly static checker, empowering developers to identify unsupported Java features in TornadoVM and understand the reasons behind these limitations.

Additionally, TornadoInsight introduces a dynamic testing framework that enables developers to easily test individual TornadoVM tasks. It automatically wraps TornadoVM tasks, invoking the native TornadoVM runtime on the developer’s machine for seamless debugging and testing. In this blog, we expand on TornadoInsight by:

You’re Invited to IntelliJ IDEA Conf 2024!

Tue, 27 Feb 2024 08:13:58 +0000

We are back and excited to invite you to IntelliJ IDEA Conf 2024 , a developer-focused, live, online event that is free for all to attend!

IntelliJ IDEA Conf celebrates the developer community and its desire to learn and improve every day.

Join us for this free, live online conference and learn from industry leaders and experts on March 6–7, 2024.

You’ll be able to learn about a variety of topics, like Core Java, Kotlin, Java and AI, Apache Maven 4, Spring Boot, Micronaut, Testcontainers, Secure Coding, and testing frameworks like JUnit, Mockito, and AssertJ.

lntelliJ IDEA: Selectively Commit Changes to a File

Thu, 21 Dec 2023 06:15:09 +0000

Sometimes you’re making multiple changes to a file that you don’t want to commit together. For example, if you’re working on a new feature, but notice some other small things you want to fix. If these changes are in separate files, we can commit each file separately. But what if they’re in the same file?

In IntelliJ IDEA (as of version 2023.3 ), we can now select which chunks and specific lines we want to add to our commit.

Profiling Maven Projects with my IntelliJ Profiler Plugin

Thu, 14 Dec 2023 10:41:34 +0000

Or: I just released version 0.0.11 with a cool new feature that I can’t wait to tell you about…

According to the recent JetBrains survey , most people use Maven as their build system and build Spring Boot applications with Java. Yet my profiling plugin for IntelliJ only supports profiling pure Java run configurations. Configurations where the JVM gets passed the main class to run. This is great for tiny examples where you directly right-click on the main method and profile the whole application using the context menu:

Explore project structure with IntelliJ IDEA's Dependency Matrix

Mon, 20 Nov 2023 10:28:01 +0000

In this tutorial, we’ll look at exploring project structure with IntelliJ IDEA ’s Dependency Matrix.

When working with large, complex software projects, we need to understand the dependencies between components in your projects. IntelliJ IDEA has a feature called Dependency Structure Matrix (DSM ), or Dependency Matrix, that can help us with this.

When you are new to a project, the Dependency Matrix can help you get an overview of the dependencies in the project. The Dependency Matrix can also help us get an idea of how hard it will be to split a project, based on the dependencies between components. Finally, it can help us find and untangle cyclic dependencies.

OpenAPI Generator: From YAML to JetBrains HTTP Client

Fri, 10 Nov 2023 10:41:35 +0000

In this article, I’ll be implementing an OpenAPI generator from scratch so you can too! We’ll be creating a very simple generator for the Jetbrains HTTP Client.

This is the online version of the article with the same name I wrote for the Dutch Java Magazine.

In the previous edition of the magazine, we discussed how the JetBrains HTTP Client could be used to run HTTP Queries, automate them and even use them in your CI/CD pipelines. Just like Postman , but text based and can be part of your source code. Pretty cool.

Working with GitLab Merge Requests in IntelliJ IDEA

Thu, 10 Aug 2023 09:57:10 +0000

In this tutorial, we will take a look at working with GitLab Merge Requests inside IntelliJ IDEA.

When reviewing Merge Requests in a web interface, we don’t have the same support that our IDE gives us, like syntax highlighting and the context within which the code was written.

IntelliJ IDEA has support for reviewing and merging GitLab Merge Requests. These features are available if the IntelliJ IDEA project has a remote that points to GitLab.

How to Create an Open Source Pull Request (PR)

Wed, 19 Jul 2023 11:26:23 +0000

In this tutorial, we are going to take a look at contributing to Open Source Software, specifically how to do a pull request (PR).

We will look at forking and cloning the project, making the changes, committing and pushing these changes, creating the pull request, the review and hopefully merge of your PR.

The same process may apply when making contributions to a project at work that you don’t own. In this example, the project is on GitHub. Other Git code repositories may use a similar process.

Reactive Programming Made Easy

Fri, 14 Jul 2023 08:47:11 +0000

This article discusses essential features and tools in IntelliJ IDEA for Reactor developers. These include live templates, a dedicated debug mode, and a couple of inspections.

We’ve got all of the project Reactor adepts and enthusiasts out there covered! Whether you’re a seasoned pro or just taking your first steps in the field, IntelliJ IDEA will make reactive coding a breeze. It simplifies the complexities of Reactive Streams, ensuring a smooth and efficient experience for all skill levels.

Foojay Podcast #26: The Future of Source Control and CI/CD

Mon, 26 Jun 2023 08:35:21 +0000

As developers, we like to automate the boring parts of our job. This automation includes the source control system, build pipelines, and code analysis tools.

In recent decades, we have seen evolutions from CVS to Subversion to Git. Is this the endpoint? Did we find the holy grail in version control? Or what evolutions are waiting for us?

Let’s find out together with these fantastic guests…

This is the final episode of season 2 of the Foojay Podcast. See you in September for the start of our new season with more JUGs, the launch of Java 21, and much more!

Manifold vs. Lombok: Enhancing Java with Property Support

Mon, 19 Jun 2023 18:04:59 +0000

Today, we’ll explore an intriguing aspect of Manifold: its property support.

In comparison, we’ll also examine Lombok, a popular library that offers similar features.

By analyzing the differences between these two projects, we can gain insight into their core philosophies and advantages.

Let’s dive in and discover how Manifold’s property support stands out.

As always, you can find the code examples and additional resources for this post on my GitHub page .

Announcing the Digma Beta: First Runtime Linter for Java Code

Mon, 22 May 2023 13:52:34 +0000

Call for Developers

We are looking for senior Java developers who are interested in exploring how to use observability to improve their code to join the beta program for Digma: a free runtime linter plugin for Jetbrains/Java.
Digma analyzes your code in runtime, improving coding practices and confidence when working on complex Java code.

The plugin runs locally and doesn’t require sharing data.

We have 20 slots currently open for the beta.

Write Once, Run Embedded in any IDE

Tue, 16 May 2023 13:34:19 +0000

Having written many Java GUI applications, I thought it would be cool to run them embedded in IntelliJ IDEA, Eclipse and NetBeans. I didn’t want to write three plugins per application so I came up with this solution.

The embedded panel criteria

To convert my Java Swing applications to run embedded in an IDE, I had to put the user interface in a panel with minimal implementation changes. I came up with these should ideally criteria:

Analyzing dependencies in IntelliJ IDEA

Thu, 11 May 2023 09:33:40 +0000

If you’re working on a real world project, you’re probably using external dependencies.

You might need to analyze which dependencies your application uses.

For example, you may want to find out how a particular version of a dependency ended up in your application.

Let’s take a look at how IntelliJ IDEA can help you to analyze dependencies.

We can view our dependencies in the Maven or Gradle tool window.

Here, we can expand dependencies to show their transitive dependencies, or collapse them again.

Replacing Postman with the Jetbrains HTTP Client

Thu, 13 Apr 2023 06:59:28 +0000

TL;DR: I’ve created the first version of an openapi-generator for the JetBrains HTTP Client, and together with the CLI runner it allows you to play against APIs without ever going out of your terminal and it can even run in your CI/CD pipeline. See repository here .

I work a lot with APIs, whether for an app I develop myself, or to interact with others. Most people I know tend to use Postman for this. But I personally don’t quite like the product any more , and it forces me to move out of my IntelliJ environment which really kills my productivity.

Cherry-Pick: Move a Commit to a Different Branch

Wed, 05 Apr 2023 13:53:20 +0000

There are several reasons why you might want to move a commit to a different branch.

Let’s take a look at some of them.

Committed to the wrong branch

You’re working on a new feature, but an urgent bug came in.

You fixed the bug and committed the fix, but oops… you forgot to create a new branch for the bugfix!

Now this bugfix is on the wrong branch. How do we fix this? Bugfix commit is on the wrong branch

Watch Area and Renderers

Sat, 25 Mar 2023 07:25:03 +0000

This is it. The debugging book is live . I would really appreciate reviews and feedback!

I also finished recording and editing the entire course .

There are 50 total videos which total in 7 hours… I also recorded additional videos for the two other free courses for beginners and for modern Java .

So keep an eye on those!

Renderers

In today’s video we discuss one of my favorite obscure IDE features: renderers. Very few people are aware of them. I explained them in the past but I feel I didn’t properly explain why they are so much better than any other alternative. This time I think I got the explanation right.

Efficient Memory Mapping for Terabyte Sparse Files in Java

Wed, 15 Mar 2023 11:50:41 +0000

On Linux, you can create sparse files , where only the pages (of 4 KiB) that are touched utilise either memory or disk space.

This allows you to memory map large virtual regions without worrying about wasted memory or disk

In this program, you can see it reserves 8 TiB (8,192 GiB)

Figure 1. Test 1: Sparse file

Tip: x << y means x × 2y therefore:

1L << 10 = 1 KiB (1024 bytes),
1L << 20 = 1 MiB (10242 bytes),
1L << 30 = 1 GiB (10243 bytes),
1L << 40 = 1 TiB etc

Using multiples of 10 for the shift makes them easier to read.

Getting Started with IntelliJ IDEA

Mon, 13 Mar 2023 08:26:00 +0000

First up, I havecreated a tutorial on the IntelliJ IDEA Guide if you want to view the content with videos. I’ll concentrate on text-based for this article.

When someone new joins your team, it can be quite an overwhelming experience.

There are lots of people to meet, new technologies to learn, different processes to learn and of course, an IDE to learn!

It’s helpful to remember what every new starter wants, they want to make a difference, they want to add value, they want to move the needle.

Using Bookmarks in IntelliJ IDEA

Tue, 07 Mar 2023 15:07:04 +0000

In this tutorial, we’re going to take a look at using bookmarks in IntelliJ IDEA .

Bookmarks can come in handy while navigating a codebase, when you see something interesting that you want to come back to later.

You could use Recent Files (⌘E on macOS, or Control+E on Windows/Linux) to find it, but then you have to remember which file it was. This is where bookmarks come in handy.

Let’s take a look!

Is There a Best OS to Develop a Java Application on?

Wed, 22 Feb 2023 11:43:40 +0000

One subject that often evokes a lot of debate is which is the best OS to develop a Java application on. This article gives my view on the issue.

Java runs very well on Windows, macOS and Linux Distributions.

I work for Chronicle Software , and much of our software is open-source Java libraries, so we don’t, or rather we can’t, require our customers to run on a particular operating system. You may be surprised to hear that we don’t mandate which operating system our staff should use either. We let them use the one that causes the least friction, the one that they are most productive with.

What are you Missing by Debugging in VS Code?

Fri, 17 Feb 2023 16:20:16 +0000

In the first chapter of my debugging book, I discuss IDE debugging.

In that chapter, I mostly talk about IntelliJ/IDEA.

People often ask me why I didn’t write as much about VS Code…

The reason is that there isn’t much to write about. Its debugger is simpler for better and for worse. It isn’t as powerful as other IDEs. I created the following video that covers the content of this post:

How to Find & Fix Vulnerabilities with IntelliJ IDEA Ultimate

Mon, 13 Feb 2023 09:09:39 +0000

In this article, we’re going to take a look at the Package Checker plugin , that’s bundled with IntelliJ IDEA Ultimate .

We’ll have a look at how to view known vulnerabilities in your Maven or Gradle projects, how to get more information about the known vulnerabilities in a specific dependency and how to remediate these vulnerabilities inside IntelliJ IDEA Ultimate if a new version with a fix is available.

Remote Debugging Dangers and Pitfalls

Fri, 10 Feb 2023 10:14:47 +0000

This is the last part of the debugging series, to learn the rest you’ll need to get the book or the course .

One of the most frequently asked questions I receive is: can we do these things in VS Code?

The answer is unfortunately no. But I elaborate on the debugging capabilities of VS Code in this video . I’ll do a blog post that covers that next week.

Below is the last video in the series:

Memory Debugging - a Deep Level of Insight

Fri, 03 Feb 2023 10:08:16 +0000

When I mention memory debugging the first thing that comes to the minds of many developers is the profiler. That isn’t wrong but it’s still a partial picture. Profilers are amazing at mapping that “big picture” but when you want to understand the domain, they fall short.

Modern debuggers let us gain a level of insight into the application that’s unrivaled. We can inspect and locate a specific object instance with surgical precision.

Debugging Threads and Asynchronous Code

Fri, 03 Feb 2023 10:07:22 +0000

I’m doing a community interview in the Code Ranch drop by and ask a question to win a free book!

This week we’ll discuss one of the harder problems in programming: threading. For many cases threading issues aren’t as difficult to debug. At least not in higher abstractions.

Asynchronous programming is supposed to simplify the threading model but oftentimes it makes a bad situation worse by detaching us from the core context.

Firefox Profiler Beyond the Web: IntelliJ plugin for JFR

Thu, 02 Feb 2023 13:13:17 +0000

This blog post is the base of the first half of my upcoming talk at FOSDEM 2023 on the topic “Firefox Profiler beyond the web: Using Firefox Profiler to view Java profiling data .”

For the impatient: Take a look at my Java JFR Profiler IntelliJ plugin to easily profile your application and view JFR files directly in your IDE.

I got involved in the Firefox Profiler development, spending significant portions of my time at SAP in the last half year on it. It has been an exciting ride. I learned a lot and contributed a few features. So I was essentially developing React code when I wasn’t working on ASGST or other OpenJDK-related tools.

Foojay Podcast #12: State and Future of the IDEs

Mon, 23 Jan 2023 10:14:45 +0000

In this podcast, we are talking to some of the key people working on different IDEs, Integrated Development Environments.

Those are applications that provide tools to computer programmers for software development.

An IDE typically consists of at least a source code editor, build automation tools, and a debugger.

Let’s learn how these tools evolved, and the challenges they face to stay up-to-date with the many evolutions in Java and all other programming languages.

Debugging Streams and Collections

Fri, 13 Jan 2023 14:59:59 +0000

I will run a book giveaway promotion on the Code Ranch on January 17th . Be sure to be there and let your friends know. It would be great to answer your questions about debugging. I’m very excited by this and by the feedback I’m getting for the course and new videos.

I also launched a free new Java course for complete beginners . No prior knowledge needed. This is probably not the audience for this course. But if you know someone that might be interested I’ll appreciate a share. I hope people find it useful and learn a bit about Java. I’m working on a cadence of one video per week in this beginner course.

The Massive Hidden Power of Breakpoints

Fri, 13 Jan 2023 14:58:57 +0000

It’s been a big week. I’m currently reviewing the final draft of my upcoming debugging book . This is always a sobering, and exciting moment. A moment in which all of a sudden all the months of work become “real”.

I also recorded 9 videos for youtube bringing up the total videos in the course to 29 (with many more on the way). I’m starting two additional free courses one targeted at absolute beginners . Another one about modern Java programming which I’ll launch really soon. Both will be free on my youtube channel (obligatory “like, subscribe and share”).

Managing Dependencies in IntelliJ IDEA

Tue, 10 Jan 2023 15:13:39 +0000

In this tutorial, following on from viewing dependencies , we’re going to take a look at managing dependencies in IntelliJ IDEA.

We’ll look at different ways to add dependencies to your project, and how to add, upgrade and remove dependencies using Package Search.

There are several ways to add new dependencies to your project.

From the build file using copy-paste

You have probably copied a dependency from Maven Repository (or another website) and pasted into your build file.

Debugging Program Control Flow

Fri, 23 Dec 2022 07:36:35 +0000

As of now I published the first three videos of the course and will publish the fourth tomorrow. I plan to publish two videos per week on YouTube to maximize the impact but here I’ll only blog one lesson per week to avoid oversaturation. I shot about four hours of video content and still haven’t finished the 2nd module out of eight. This course will be very detailed and intensive.

Debug Like a Senior Developer

Fri, 16 Dec 2022 06:34:02 +0000

My book on debugging is already on preorder and I’m super thrilled to announce I’m doing a full online course to go along with it.

The course website isn’t ready yet but I already have the full outline and a lot of recorded material. I will try to drop videos at a rate of two per week in the next few months until the full course will be online.

It’s shaping up to be a very detailed course. I recorded the first module and half of the second module and I’m already close to 3 hours of dense recorded material!

Viewing Maven and Gradle Dependencies in IntelliJ IDEA

Wed, 07 Dec 2022 08:54:13 +0000

In this article, we’re going to take a look at different ways to view your external dependencies in IntelliJ IDEA.

Introduction

If you’re working on a real-world application, your project will probably use external libraries and frameworks.

Occasionally, you might want to see which dependencies your project uses, for various reasons.

There are several ways to view dependencies in IntelliJ IDEA .

Each view has a different focus.

Dependency management config file

You can find direct dependencies in the dependency management config file. Direct dependencies are the dependencies that your project depends on directly.

Java on Azure Tooling Update – October 2022

Mon, 07 Nov 2022 22:04:16 +0000

Hi everyone, welcome back to the October update of Java on Azure Tooling.

In this update, we will introduce our new roadmap in the next few months.

In addition, we have made improvements for developers to use deployment slots for Azure Functions in IDEs directly with our latest release.

Please download and install the Azure Toolkit for IntelliJ .

We hope you like these features and enjoy a smooth experience with our Azure toolkit. So let us get started.

When Breakpoints Don't Break

Mon, 24 Oct 2022 07:24:44 +0000

I discussed tracepoints quite a bit in my blog and videos.

They are wonderful, but I feel the nuance of non-breaking is a bit lost.

The true power of this amazing tool is hidden due to our debugging habits and our preconceived notions about debugging. It’s indeed difficult to make the mental shift required for these tools.

The payoff for that mental shift is tremendous when dealing with “weird” bugs. Especially in large systems and with concurrency related issues.

Java on Azure Tooling Update – September 2022

Mon, 17 Oct 2022 09:25:59 +0000

Hi everyone, welcome back to September update of Java on Azure Tooling.

In this update, we will introduce the Azure Cosmos DB Support, Azure Virtual Machine Enhancement.

In addition, we have made some improvements for users to create/update the dependencies with Azure SDK Reference Book.

Please download and install the Azure Toolkit for IntelliJ .

We hope you like these features and enjoy the smooth experience with our Azure toolkit. So let us get started.

Java on Azure Tooling Update – August 2022

Mon, 17 Oct 2022 09:15:27 +0000

Hi everyone, welcome back to August update of Java on Azure Tooling.

In this update, we will introduce the AKS support and Virtual Machine support.

In addition, we make some improvements for users to search for subscriptions and find our tutorials easily.

We hope these features could improve your user experience. So let us get started.

Azure Toolkit for IntelliJ Improvements

AKS Management Support

Azure Kubernetes Service (AKS) simplifies deploying a managed Kubernetes cluster in Azure by offloading the operational overhead to Azure. You can find more details about Azure Kubernetes Service (AKS) .

Presenting with IntelliJ IDEA

Tue, 11 Oct 2022 07:14:30 +0000

In this article, we will take a look at ways to level up your presentation skills with IntelliJ IDEA.

Presentation Assistant plugin

Our first tip is to use the Presentation Assistant plugin. The Presentation Assistant plugin will show which shortcuts are being used.

To install the plugin, open Preferences using ⌘, (on Mac) or Ctrl+Alt+S (on Windows/Linux). Go to Plugins and search for “Presentation assistant” on the Marketplace tab. Click Install and when it’s done, click OK to apply the changes and close the dialog or click Apply to keep the dialog open.

Resolving Git Merge Conflicts in IntelliJ IDEA

Wed, 21 Sep 2022 11:04:06 +0000

At some point in your career, probably many points, you’ll have to resolve merge conflicts.

A common cause of merge conflicts is when you’re working on a feature branch while other changes have been applied to the main branch.

Merge feature branch into main

In this tutorial, we are currently on the main branch, and we want to merge the feature branch into main.

You can do this by selecting the feature branch in the Git tool window which you can open with ⌘9 (macOS), or Alt+9 (Windows/Linux).

Using Git Interactive Rebase

Thu, 25 Aug 2022 09:32:22 +0000

This tutorial will cover how to clean up your Git commit history with Git interactive rebase, both via the IntelliJ IDEA UI and from the command line.

Git interactive rebase allows you to change individual commits, squash commits together, drop commits or change the order of the commits. This allows you to clean up your Git commit history to make it linear and meaningful, which can make it easier to understand the history of the project in the future.

Debugging Java Collections Framework Issues in Production

Fri, 15 Jul 2022 08:49:59 +0000

The Java Collections Framework was a huge leap forward when it was introduced as part of Java 2 (JDK 1.2).

Thanks to the included collection classes we finally moved beyond the limits of Vector and Hashtable to more mature and generic solutions. With the introduction of streams and functional concepts in Java 8 the framework took everything to the next level.

One of the core principles underlying the framework is coding to the interface. As such you would use the List interface or a Collection interface instead of the concrete implementation. This is great engineering but it makes debugging the Java Collections far more challenging.

Java on Azure Tooling Update – July 2022

Mon, 11 Jul 2022 07:21:16 +0000

Hi everyone, welcome back to the July update of Java on Azure Tooling.

In this update, we will introduce the brand new getting started experience with the Azure toolkit for IntelliJ.

In addition, we have added support for Managed Identity Authentication.

Let’s see what these new features are.

Azure Toolkit for IntelliJ Improvements

New Guided Getting Started Experience

In April’s blog , we first talked about why we needed better getting started experience. Currently, there are several challenges for a developer who is new to Azure:

Debugging Gson, Moshi and Jackson JSON Frameworks in Production

Fri, 08 Jul 2022 07:14:01 +0000

Parsing bugs are the gift that keeps on giving in the age of APIs.

We use a service, it works perfectly in debugging, QA, etc.

Then some user input that made its way to the web request returns a result we just can’t parse.

Unfortunately, there isn’t much we can do at this stage. We need to understand why the failure occurred and how we can workaround it and fix it.

Debugging jsoup Java Code in Production Using Lightrun

Fri, 17 Jun 2022 09:35:06 +0000

Scraping websites built for modern browsers is far more challenging than it was a decade ago.

jsoup is a convenient API that makes scraping websites trivial via DOM traversal, CSS Selectors, JQuery-Like methods and more. But it isn’t without its caveat. Every scraping API is a ticking time bomb.

Real-world HTML is flaky. It changes without notice since it isn’t a documented API. When our Java program fails in scraping, we’re suddenly stuck with a ticking time bomb.

Java on Azure Tooling Update – June 2022

Mon, 13 Jun 2022 07:40:38 +0000

Hi everyone, welcome back to June update of Java on Azure Tooling.

In this update, we will introduce the new application-centric view on Azure toolkit for IntelliJ that will make the interface more user-friendly.

In addition, we have added support for more Azure services.

For Gradle plugins, we have some new features for Azure Web Apps and Azure Functions.

We hope you like these new features and share your feedback with us. So let us get right into it…

Remote Debugging and Developer Observability

Fri, 10 Jun 2022 10:12:26 +0000

In this post, we’ll go over remote debugging. Debugging production with developer observability tools and debugging asynchronous code which presents its own unique challenges!

This is actually material from four separate videos because I wanted to pool some ideas together into a single blog post and the asynchronous stuff got pulled in. So without further ado, these are the applicable videos… Read on for the analysis and discussion:

🦆 Duckling the 15th:

Debugging the Java Message Service (JMS) API using Lightrun

Fri, 03 Jun 2022 09:26:12 +0000

The Java Message Service API (JMS) was developed by Sun Microsystems in the days of Java EE .

The JMS API provides us with simple messaging abstractions including Message Producer, Message Consumer, etc. Messaging APIs let us place a message on a “queue” and consume messages placed into said queue.

This is immensely useful for high throughput systems – instead of wasting user time by performing a slow operation in real-time, an enterprise application can send a message. This non-blocking approach enables extremely high throughput, while maintaining reliability at scale.

Debugging Deadlocks and Race Conditions

Fri, 20 May 2022 08:08:00 +0000

Thread debugging has the reputation of being one of the most arduous tasks for developers. I beg to differ.

Asynchronous debugging is so much worse. It’s supposed to solve the problems of threading and to some degree async helps…

But it doesn’t make debugging simpler. I will get into that in the next post.

In the last two ducklings, I talked about threading issues:

🦆 Duckling the 13th:

Debug race conditions and deadlocks easily.

Azure Toolkit for IntelliJ – April 2022 Update

Mon, 16 May 2022 08:28:24 +0000

Welcome to a new series of articles on Azure Toolkit for IntelliJ.

Azure Toolkit for IntelliJ is a plugin that allows you to easily create, develop, configure, test, and deploy Java applications to Azure.

Our goal of this series is to keep you posted on the latest product updates, features, and other exciting news.

In this first article, we are going to take a look at our product roadmap for next few months.

How to run the Java Incubator Module from the Command Line and IntelliJ IDEA

Tue, 10 May 2022 16:52:15 +0000

JEP 425: Virtual Threads (Preview) has been proposed recently. It has been a long-awaited feature in Java. It opens the door to Structured Concurrency. This article isn’t about it, in case you are interested, you can read, the JEP draft: Structured Concurrency (Incubator)

Also, if you are interested in how the incubator module works, please read: JEP 11: Incubator Modules

I downloaded the early access build and wrote the following very simple program that demonstrates structure concurrency.

Setting up and Working with Apache Tomcat in IntelliJ IDEA Ultimate

Tue, 10 May 2022 08:46:17 +0000

In this article, you will learn how to set up IntelliJ IDEA Ultimate to work with Apache Tomcat, herein referred to simply as Tomcat.

We will create a new project that uses Tomcat and then talk about using Tomcat in IntelliJ IDEA so you can benefit from the rich integration capabilities.

Downloading Apache Tomcat

To use Tomcat with IntelliJ IDEA, it needs to be installed on your machine. If you don’t already have Tomcat installed, you can download the latest version, which at the time of writing, is Tomcat 10 .

How to enable java preview feature and run code from IntelliJ IDEA

Sun, 08 May 2022 10:07:50 +0000

JEP 425: Virtual Threads (Preview) has been proposed recently. It has been a long-awaited feature in Java. I wanted to give it a try. So I download the early release of JDK which has the project loom in it. However, it is under preview.

The following snippet was pretty much my first program written for testing virtual threads.

public class Main {
 public static void main(String[] args) throws InterruptedException {
 Thread.startVirtualThread(() -> {
 System.out.println("Hello from virtual thread");
 }).join();
 }
}

It is so simple that I could just run it in the command line using the source code launcher :

Spring Transaction Debugging in Production with Lightrun

Fri, 06 May 2022 15:00:53 +0000

Spring makes building a reliable application much easier thanks to its declarative transaction management.

It also supports programmatic transaction management, but that’s not as common.

In this article, I want to focus on the declarative transaction management angle, since it seems much harder to debug compared to the programmatic approach. This is partially true. We can’t put a breakpoint on a transactional annotation.

But I’m getting ahead of myself!

What is Spring’s Method Declarative Transaction Management?

When writing a spring method or class, we can use annotations to declare that a method or a bean (class) is transactional. This annotation lets us tune transactional semantics using attributes. This lets us define behavior such as:

Debugging Collections, Streams, and Watch Renderers

Fri, 29 Apr 2022 07:54:01 +0000

In the last two ducklings, I finished the extensive discussion on breakpoints and switched my focus to the watch area. In it, we have several amazing and lesser known tools that let us build insight into our running application. Being able to tell at a glance if something works correctly is crucial for many applications.

This is very important for collections and arrays. We can have thousands or millions of elements within a collection. Debugging this is very difficult without some basic tools.

Migrating from Java EE to Jakarta EE with IntelliJ IDEA

Fri, 08 Apr 2022 17:02:37 +0000

In this post, we’re going to migrate some sample code from the javax namespace to jakarta. If you want the history on this change, check out this helpful blog post from Java Magazine. Fundamentally the Java Persistence API was renamed to Jakarta Persistence API meaning that the javax namespace changed to jakarta for frameworks whose APIs have moved to Jakarta EE (which is not all of them).

However, Apache Tomcat recently released version 10 which updated package names from javax to jakarta. SpringBoot also made this change in version 6.

Debugging JAXB Production Issues

Mon, 04 Apr 2022 14:13:10 +0000

Java Architecture for XML Binding (AKA JAXB API) is a popular API for marshalling XML data. It’s a framework for mapping between XML documents and Java POJOs (Plain Old Java Objects, AKA regular Java classes) almost seamlessly. The API is very easy to use and many frameworks leverage it to provide their XML support. JAXB2.0 has gained popularity both in desktop applications (Java SE) and in application server code (Spring Boot, Java EE/Jakarta EE, Microprofile etc.).

Debugging Race Conditions in Production

Wed, 23 Mar 2022 07:45:15 +0000

Race conditions can occur when a multithreaded application accesses a shared resource using over one thread. Unless we have guards in place, the result might depend on which thread “got there first”. This is especially problematic when the state is changed externally.

A race can cause more than just incorrect behavior. It can enable a security vulnerability when the resource in question can be corrupted in the right way. A good example of race condition vulnerabilities is mangling memory. Let’s say we have an admin user name which is restricted and privileged. You can’t change your user name to admin because of validation. But you can change it to anything else…

The Basics of Breakpoints you Might not Know

Thu, 17 Mar 2022 10:41:08 +0000

In episodes 4 and 5 of “140 Second Ducklings”, I got deeper into the more advanced underpinnings of breakpoints. There’s still a lot more to learn to move forward, but even at this stage it’s surprising how many things are relatively unknown in the developer community. And I’m just getting started…

🦆 Duckling the 5th:

Did you know you can disable a breakpoint until you hit another breakpoint?

Do you know what’s a tracepoint?

Java Return Value, IntelliJ Jump to Line

Wed, 02 Mar 2022 15:33:39 +0000

I just published the 3rd episode of the “140 Second Duckling” tutorial series and I’m getting into the rhythm of doing them. I posted the 2nd episode last week and in this post I’ll dig deeper into both.

I tackled a lot of basic stuff about debugging but I picked two big headliners that a surprising amount of developers aren’t familiar with. E.g. How many times did you step over a return statement and cursed?

Working with Multiple Carets in IntelliJ IDEA

Sun, 14 Nov 2021 12:21:26 +0000

Sometimes you need to modify multiple lines of code on separate lines inside IntelliJ IDEA with the same change. The fastest way to achieve that is with multiple carets . In IntelliJ IDEA you can:

Create multiple carets in a vertical line
Create multiple carets at the end of lines
Create multiple carets at any point in your code

Create Multiple Carets in a Vertical Line

Creating carets that are stacked vertically where you have content on different lines, like a list, can save you a lot of time when you’re editing your code.

Debugging Tutorial 1 – Introduction: Conditional Breakpoints & Set Value

Wed, 27 Oct 2021 08:03:53 +0000

In this series, I’ll walk you through the process of debugging applications and finding issues within them. As we debug, we’ll cover the techniques important for most developers. I will cover the following debuggers:

IntelliJ/IDEA – with Java/Kotlin
PyCharm – Python
VSCode – for JavaScript
WebStorm – for JavaScript

These should cover most use cases you’ll run into and some things will seem duplicate/redundant so you can just skip to the applicable section if you feel you “got the gist”.

Git Archeology: Removing the Sands of Time from Code

Sat, 23 Oct 2021 06:55:03 +0000

Working on a large codebase, it’s pretty normal to not remember every small or large subsystem or implementation choice. Be it whether you’re new to a codebase, or you’ve been focused on a specific area of the codebase.

When working on refactorings or bug fixes, I often end up in areas I might not be too familiar with. Generally not dramatic, it happens quite often that I’m stopping what I’m doing because I need to decide on how to move forward. As software engineers, we have to make so many micro-decisions every minute that we’re pretty used to it.

Debug Real World Applications using a Systemic Proven Process

Tue, 28 Sep 2021 08:54:00 +0000

In the Debugger Checklist (Part I) , I introduced some of the high level concepts and reviewed some of the common things you can do. In this part, we’ll get down to the process. Again, it’s important to stress that this is boiled down and concentrated!

I don’t want to discuss issue trackers, unit testing and proper TDD. I think there are many resources covering all of these. The focus of these posts is the debug process itself which often gets neglected as “tools”. There’s a lot of technique that separates the seasoned developer from a junior. Furthermore, there are many small advancements and changes we can’t possibly keep up with. I’d like to cover all of those things (some in future posts).

Debugger Checklist: Bug Solving Process

Tue, 21 Sep 2021 09:37:32 +0000

Win at debugging by following an organized process and leveraging the tools you already have!

I’m a disorganized person by nature. When I follow a process it’s by habit and intuition. But when a debugging problem keeps me up at night and gets me to that state of mind where a career of raising sheep in New Zealand seems like an attractive option… That’s when I need to back off and walk through this process in an orderly fashion. This process never fails. When you walk through it, you can track any problem.

Getting Started with Java 17 and IntelliJ IDEA

Tue, 14 Sep 2021 09:20:56 +0000

A new Java release every six months can be exciting, overwhelming, or both. Given that Java 17 is also an LTS release, it’s not just the developers but enterprises also noticing it. If you have been waiting to move on from Java 8 or 11, now is the time to weigh its advantages.

In this article, I will limit the coverage of Java 17 to its language features – Sealed Classes and Pattern Matching for switch . I’ll cover what these features are, why you might need them, and how you can start using them in IntelliJ IDEA . I will also highlight how these features can reduce the cognitive complexity for developers. You can use this link for a comprehensive list of all the new Java 17 features.

8 Debugging Tips for IntelliJ IDEA Users You Never Knew Existed

Thu, 09 Sep 2021 07:15:54 +0000

As developers, we’re all familiar with debuggers. We use debugging tools on a daily basis – they’re an essential part of programming. But let’s be honest. Usually, we only use the breakpoint option. If we’re feeling frisky, we might use a conditional breakpoint.

But guess what, the IntelliJ IDEA debugger has many powerful and cutting-edge features that are useful for debugging more easily and efficiently. To help, we’ve compiled a list of tips and tricks from our very own developers here at Lightrun . We hope these tips will help you find and resolve bugs faster.

Everyday Shortcuts in IntelliJ IDEA

Mon, 06 Sep 2021 07:27:35 +0000

Let’s take a look at some of my favourite keyboard shortcuts in IntelliJ IDEA .

It’s really helpful to use keyboard shortcuts because it speeds you up and keeps you in the flow of coding!

Intention Actions - ⌥⏎ / Alt+Enter

You can use this shortcut in a number of places, even when it’s not an error or when IntelliJ IDEA has not given you any indication that you could use it. It’s always worth trying it just to see what your options are.

How To Get Your JDK As Easily As Possible!

Tue, 20 Jul 2021 07:00:31 +0000

Have you ever been in the situation where you’ve been looking for a specific JDK version of a specific distribution? I think most of us have been there and, I don’t know how you handle this, but in the past I used to save links to distributions in my browser and then I usually I started searching through the vendor website for the package I was looking for.

Sometimes that was easy… sometimes it was hard… but it never was fun. And if you’re used to working with JavaFX, the whole thing got even harder when JDK 11 came out and JavaFX was not bundled with the distribution any longer.

Gluon Update, Dual Screen Raspberry Pi , IntelliJ JavaFX Project Wizard

Fri, 04 Jun 2021 07:27:41 +0000

Last week, Johan Vos of Gluon, released a video with a status update of JavaFX. In this post we are going to take a deeper look into one of the announcements: dual screen support on Raspberry Pi.

Announcements by Gluon

Since Java switched to a 6-month release cycle, JavaFX has done the same, so next version will be number 17. Keep in mind, although Java and JavaFX are on the same version-number, you can still use Java 11 and combine it with the JavaFX 17 runtime if you want to benefit from its improvements. Up till now, there were no breaking changes in either of the frameworks which force you to use a Java-version higher than 11.

Creating a Simple Spring Boot Application in IntelliJ IDEA

Mon, 31 May 2021 17:06:51 +0000

This tutorial uses IntelliJ IDEA Ultimate because we want to create a new project using Spring Initializr. This functionality is only available with IntelliJ IDEA Ultimate. It is based off Building an Application with Spring Boot .

Creating your Spring Boot Project

If you’re in an IntelliJ IDEA project already, select File > Project . Alternatively click the New Project button on the Welcome screen.
Select Spring Initializr on the left-hand side and then enter the following options:

Fix Java Security Issues While Coding in IntelliJ IDEA

Thu, 29 Apr 2021 17:10:33 +0000

Nowadays, developers are responsible for more than just creating the application. Besides working on features, developers have to focus on their applications’ maintainability, scalability, reliability, and security. Many developers are unsure of where to start with security. In addition, most companies still work with a dedicated security team instead of having security expertise inside the team.

A lot of developers practically live in their integrated development environment (IDE). A good IDE is like a swiss army knife: it is your go-to tool to do almost everything. Having everything I need to build, run, test, debug, andsecure my application, makes a good IDE invaluable for many developers.

Beginning JavaFX Applications with IntelliJ IDE

Wed, 28 Apr 2021 19:33:58 +0000

JavaFX in IntelliJ IDE

This article is for the beginner who wants to get started developing JavaFX applications using Jetbrains’ IntelliJ IDE. The article will create three flavors of a HelloWorld JavaFX application as follows:

Plain - Create a new project from scratch using no build tools
Maven - Create a new project using the Maven build tool
Gradle - Create a new project using the Gradle build tool

While this article may seem elementary for some, I believe it can help newcomers to the JavaFX platform avoid some pitfalls and really hit the ground running.

About IntelliJ IDEA Changelists and Git Staging

Fri, 16 Apr 2021 07:13:37 +0000

Since the release of IntelliJ IDEA 2020.3, there are now two ways to manage your commits to Git. The first one is through existing functionality with IntelliJ IDEA changelists , the second is through support for Git staging . This blog will take you through both approaches and highlight the differences. There is no right or wrong answer, it’s a case of choosing the method that works best for you, or that you’re most familiar with.

Getting Started with Java 16 and IntelliJ IDEA

Tue, 06 Apr 2021 07:11:02 +0000

If you are still working with Java 8, you might have mixed feelings about the news of the release of Java 16 . However, you’ll see these numbers are going to increment at a much faster and predictable rate with Java’s six-month release cadence.

I’m personally excited about Java 16! It adds Records and Pattern Matching for instanceof as standard language features with Sealed classes continuing to be a preview feature (in the second preview).

Generating Boilerplate Code with IntelliJ IDEA

Wed, 10 Feb 2021 09:17:18 +0000

One of the super cool things about IntelliJ IDEA is how much code you can generate with minimum effort. Yes, it’s not the 1990s anymore, we’re no longer measured on how many lines of code we generate (thankfully), but you also know that Java has its fair share of boilerplate code.

Well, there’s a shortcut in IntelliJ IDEA that generates a lot of code for you:

⌘N on macOS
Alt+Insert on Windows and Linux

These shortcuts load the Generate menu. Here’s a quick tour of where you can use it in Java projects in IntelliJ IDEA. It’s not a complete list; let me know where else we can use it please!

IntelliJ IDEA: Let's Go Beyond The Basics!

Mon, 25 Jan 2021 08:32:47 +0000

IntelliJ IDEA Ultimate is the most powerful IDE for JVM developers in the market by now. It has support for various JVM frameworks, complex refactorings, Integration with VCS, and many more.

Java developers spend a tremendous amount of time in front of their IDEs. Unfortunately, I’ve noticed that developers don’t take advantage of IDEA’s powerful features.

In this article, I’ll talk about some tricks I use in my day to day job. And show you some best practices that can boost your productivity.

3 Ways to Refactor Your Code in IntelliJ IDEA

Tue, 12 Jan 2021 08:24:00 +0000

In this article, we’re going to look at 3 ways to refactor your code in IntelliJ IDEA.

Simplifying your code has lots of advantages, including improving readability, tackling technical debt, and managing ever-changing requirements. The three types of refactoring we will look at in this blog are:

Extracting and Inlining
Change Signature
Renaming

The code samples are available in the IntelliJ IDEA sample code repository , specifically the PlanetExtractions and Planet class.

Creating a JavaFX World Clock from Scratch (Part 1)

Mon, 14 Dec 2020 09:27:54 +0000

Good design’s not about what medium you’re working in. It’s about thinking hard about what you want to do and what you have to work with before you start." – Susan Kare [6]

Introduction

Welcome to Creating a JavaFX World Clock from Scratch (Part 1)! In this series of blog entries I would like to show you how I created a “sci-fi” looking world clock that happens to be a cross-platform Java desktop application.

Why I Love IntelliJ IDEA for Java Development

Mon, 30 Nov 2020 09:16:06 +0000

If you’re a Java developer like me, you like to crank out code and get shit done. I like many things about IntelliJ IDEA, but I thought it’d be fun to write about the ones that make me most productive. First, a bit of my development history.

When I first started doing Java development in the late 90s, I used HomeSite as my editor. HomeSite was an HTML editor initially developed by Nick Bradbury. I liked it because it defaulted to a view of your code rather than being WYSIWYG like Dreamweaver and FrontPage. It’s funny to look back now and laugh about how inefficient I was: I used to google for import statements, then copy/pasted them into the editor.

Apple Silicon with Zulu OpenJDK and IntelliJ IDEA

Thu, 26 Nov 2020 09:01:34 +0000

Azul has been leading the OpenJDK community effort (JEP 391 ) initiated in August 2020 to add support for Apple Silicon, Arm-based Macs, in future versions of OpenJDK.

In addition to targeting future Java versions, Azul has made OpenJDK builds of currently popular Java versions, including Zulu builds of OpenJDK 8, 11, and 13, as well as 16-ea, widely available for use on Apple Silicon, Arm-based Macs.

In June 2020, Apple announced a two-year plan to transition the CPUs in its Macintosh line of computers from Intel’s x86-64 processors to Apple-designed chips that use the ARM64 architecture. At its “One More Thing” event on November 10 2020, Apple followed through on its promise and debuted new MacBook Air, MacBook Pro and Mac Mini Arm-based models powered by Apple Silicon.

It's all IntelliJ IDEA's Fault: IntelliJ IDEA Made Me Lazy

Tue, 24 Nov 2020 08:58:42 +0000

I haven’t always been lazy; it’s a fairly recent addition to my repertoire of skills. And do you know who I blame? I blame IntelliJ IDEA. I used to check that I’d completed a statement correctly, I used to look at javadoc, I used to check I’d closed my parentheses correctly, but now I don’t give things a second glance.

It’s all IntelliJ IDEA’s Fault

No, really, it is. Back when I was a cough younger adult, we had to type out all the code, we also thought it was cool to mix drinks that turned into something akin to gorilla snot. Maybe we weren’t that smart, but I am discovering one thing at a rapid rate, IntelliJ IDEA was smarter than me, even 20 years ago (I’d like to say it was a low bar).

Starting a JavaFX Project with Gluon Tools

Tue, 17 Nov 2020 08:38:06 +0000

Here on foojay.io you can already find two posts by Carl Dea to get you started with JavaFX:

Beginning JavaFX Applications with IntelliJ IDE : step-by-step how to start a new JavaFX project without any tools, are by using the Maven and Gradle tools.
A JavaFX App on ZuluFX in 60 Seconds : how to use a popular distribution from Azul to build a JavaFX HelloWorld Application in 60 seconds.

In this post, I want to show you yet another approach that uses the tools provided by Gluon , who are the maintainers, and the driving force behind OpenJFX .

Live Templates for Java Developers in IntelliJ IDEA

Mon, 26 Oct 2020 08:31:52 +0000

Okay, I did the math. If you use all 38 of the Live Templates for Java that are available out of the box in IntelliJ IDEA 2020.2, you will save your finger pads approximately 2092 presses of wear and tear, and that’s just each one once, the reality is likely to be substantially higher.

I will caveat this by saying that I counted the unresolved variables, yours may be longer or shorter. Still, it’s impressive!

New to IntelliJ IDEA by JetBrains? Me Too!

Fri, 02 Oct 2020 10:07:49 +0000

Until recently, I last wrote Java in anger in 2002. IntelliJ IDEA had just been released; it wasn’t remotely on my radar. I honestly can’t remember what IDE we were using back then, but it certainly was a very long way to the fully featured IDE that JetBrains produce today.

Here’s my experience of using IntelliJ IDEA for the first time!

1. Downloading IntelliJ IDEA

There’s a lot going on when you first load IntelliJ IDEA, but I learned pretty quickly that there are also some good first steps you can take to make your experience a little more comfortable.