Forem: Hyperskill

5 Java Courses That Help You Build Portfolio-Worthy Projects

Lada Petrushenko — Wed, 28 Jan 2026 14:51:20 +0000

Hi, I’m Lada — Content Project Manager at Hyperskill.
We’ve already covered how our Python and Kotlin courses are structured. Next up is Java.

Java is often chosen by learners who want a strong foundation for backend, enterprise, or full-stack development. It’s also a language where understanding architecture, concurrency, and long-term maintainability really matters. That’s why our Java courses are organized around different development paths — from learning the language fundamentals to building full-scale applications.

As with our other tracks, some topics overlap across Java courses. This is intentional. When you complete a concept in one course, it carries over to others, so your progress is always preserved and you don’t repeat the same material.

Here’s a quick overview to help you choose.

Quick Comparison

Course	Best For	Project Examples	What You’ll Learn
Introduction to Java	Complete beginners	Cinema Room Manager / Amazing Numbers	Java syntax, OOP basics, loops, conditionals, arrays and strings, error handling, algorithmic thinking
Java Developer	Learners with basic Java ready to grow into developers	Learning Progress Tracker / JSON Database with Java	OOP, functional programming, collections, multithreading, design patterns, databases, HTTP requests, JSON/XML, server-side basics, build tools
Java Backend Developer (Spring Boot)	Aspiring backend developers	Web Quiz Engine / Cinema Room REST Service	Spring Boot, REST APIs, relational databases, concurrency and thread safety, JSON handling, unit and integration testing, web security basics, backend architecture
Java Full Stack Developer	Aspiring full-stack developers	Code-sharing Platform / Real-time Chat	Java and JavaScript development, Spring Boot, frontend essentials (HTML, CSS, JS), WebSockets, STOMP protocol, databases, deployment, real-time web applications
Java Desktop Application Developer	Aspiring desktop app developers	Desktop Tic-Tac-Toe / Graph-Algorithms Visualizer	Java core, Swing GUI framework, multithreading, event handling, algorithm visualization, desktop application design

Note: Each course includes more projects than shown here — these are just some highlights.

The Courses

Introduction to Java

CV-ready skills: Java, IntelliJ IDEA basics, functions, data types, control structures, debugging, error handling, OOP basics.

This course is the perfect starting point if you're taking your first steps toward a tech career. You'll learn the core concepts behind Java, one of the most widely used programming languages in the world, and gain confidence working with code from the very beginning. You'll practice using variables, loops, conditionals, functions, strings, arrays, and user input while recognizing foundational object-oriented principles.

By the end of the course, you'll be able to design, implement, and explain your own small application from start to finish. For example, in Cinema Room Manager, you create a program that helps manage a cinema theatre: selling tickets, tracking available seats, and displaying statistics. In Amazing Numbers, you develop a program that analyzes the properties of numbers and identifies patterns, such as whether a number is palindromic or gapful.

Perfect if: You’ve never programmed before or want a clear and structured introduction to Java.

Java Developer

CV-ready skills: OOP and functional programming, collections, multithreading, design patterns, databases, HTTP requests, server-side development basics, build tools.

This course is designed for learners who already understand the basics and want to move toward professional-level development. You'll begin by strengthening your foundation in Java — learning how to write clean and readable code that follows the conventions used in real-world projects. From there, you'll explore object-oriented programming in depth and learn how to apply these concepts to structure larger applications. The course gradually introduces more advanced language features, including functional programming and multithreading, so you can build software that is not only correct but also efficient and scalable.

This course teaches the core skills that allow developers to pick up any framework later. You'll work with collections, design patterns, databases, HTTP requests, and JSON/XML, and use essential build tools. These are the skills that make you adaptable and able to grow into roles like backend developer, full-stack engineer, or platform engineer.

Perfect if: You know basic Java and are ready to move towards professional-level development.

Java Backend Developer (Spring Boot)

CV-ready skills: Spring Boot, REST APIs, relational databases, concurrency and thread safety, JSON handling, Gradle, Git, IntelliJ IDEA, unit and integration testing, basic web security, backend application architecture.

This course is for learners aiming to build practical web development skills and become backend developers. You'll deepen your understanding of core Java concepts such as object-oriented design, data structures, algorithms, and concurrency, then learn how to apply these fundamentals to backend systems using Spring Boot. You'll learn how to structure, design, and deploy real web applications.

You'll work with RESTful APIs, relational databases, JSON data, and unit/integration testing, while following web security practices and using Gradle and Git for professional workflows. Projects include Web Quiz Engine, building a web service for creating and managing quizzes, and Cinema Room REST Service, a ticketing service handling HTTP requests and JSON responses.

Perfect if: You're aiming for backend developer roles.

Java Full Stack Developer

CV-ready skills: Full-stack development with Java and JavaScript, Spring Boot, frontend essentials (HTML, CSS, JavaScript), WebSockets, STOMP protocol, databases, deployment, real-time web applications.

This course is ideal for learners aiming to become versatile full-stack developers who can build both backend and frontend components. You'll strengthen your Java skills while adding knowledge of frontend technologies and how they interact with backend services. The focus is on creating real-life web applications that you can deploy and showcase in your portfolio.

Throughout the course, you'll combine backend and frontend development using Java and JavaScript, working with Spring Boot for server-side logic and databases, and implementing dynamic user interfaces with HTML, CSS, and JavaScript. You'll also learn real-time communication using WebSockets and the STOMP protocol, preparing you for full-stack development challenges.

Perfect if: You're aiming for full-stack developer roles.

Java Desktop Application Developer

CV-ready skills: Java core, Swing GUI framework, multithreading, event handling, desktop application design.

This course is perfect for learners who want to specialize in desktop application development using Java. You'll deepen your Java knowledge while learning to design interactive graphical user interfaces with the Swing framework. The focus is on creating real, functional desktop applications that combine programming logic and visual interaction.

You'll explore GUI components, structure responsive applications with multithreading, handle user input effectively, and use regular expressions to process HTML. The projects are designed to strengthen both programming and interface design skills.

Perfect if: You want to specialize in desktop application development and build GUI-based portfolio projects.

Which One Should You Pick?

Start with Introduction to Java if you’re completely new to programming or new to Java as a language.

Choose Java Developer if you already know the basics and want to grow into a professional developer, learning how real Java applications are structured and maintained.

Go with Java Backend Developer (Spring Boot) if you want to focus on building server-side applications, REST APIs, and scalable backend systems.

Pick Java Full Stack Developer if you’re interested in working across both backend and frontend, building end-to-end web applications and real-time features.

Select Java Desktop Application Developer if you want to create desktop applications and explore GUI development with Java.

As with our other learning paths, these courses are connected. Topics overlap, and your progress carries over — so you never have to relearn the same concepts twice.

Along the way, you’ll build real projects you can add to your GitHub and show to potential employers.

5 Kotlin Courses That Help You Build Portfolio-Worthy Projects

Lada Petrushenko — Wed, 28 Jan 2026 14:20:54 +0000

Hi, I’m Lada — Content Project Manager at Hyperskill.
In the previous article, we looked at our Python courses. This time, we’re doing the same for Kotlin.

Kotlin attracts a different kind of learner — future Android developers, backend engineers, or anyone looking for a modern, strongly typed language. That’s why our Kotlin courses are built around different end goals, from learning the basics to building real applications.

Some topics overlap between courses. If you’ve already completed a concept in one course, it carries over to the others — so you never repeat the same work.

Here’s a quick overview to help you choose.

Quick Comparison

Course	Best For	Project Examples	What You’ll Learn
Introduction to Kotlin	Complete beginners	Cinema Room Manager / Minesweeper	Kotlin syntax, variables, loops, functions, simple OOP
Kotlin Core	Learners ready to go deeper	Parking Lot / Tasklist	Code structure, collections, OOP principles, file I/O, debugging, basic algorithms
Kotlin Developer	Career switchers or multi-platform learners	Maze Runner / Minesweeper	Advanced Kotlin, functional programming, coroutines, flows, algorithms, design patterns
Android Developer with Kotlin	Aspiring mobile app developers	Simple Bank Manager / Secret Diary (IDEA) / Secret Diary (Android Studio)	Dynamic UIs and navigation graphs with Fragments, data storage, Android Studio
Kotlin Backend Developer (Spring Boot)	Aspiring backend developers	Cinema Room REST Service / Web Quiz Engine	REST APIs, Spring Boot, security, basics of HTML, CSS, and JavaScript, deployment tools

Note: Each course includes more projects than shown here — these are just some highlights.

The Courses

Introduction to Kotlin

CV-ready skills: Kotlin syntax, variables and data types, functions, conditionals and loops, lists and collections, basic OOP concepts, project structure, coding best practices.

This is the course to start with if you're completely new to programming or new to Kotlin specifically. You'll learn the fundamentals step by step: how to write and run simple programs, store and process data, control execution flow, and use functions to organize your code. You'll also get an introduction to object-oriented programming, which is essential for building larger applications later on.

Along the way, you'll learn why Kotlin is popular among developers today — especially in Android development — and how its modern features make coding cleaner and more efficient than in many older languages.

Perfect if: You've never written code before or are new to Kotlin specifically.

Kotlin Core

CV-ready skills: Object-oriented programming, functional decomposition, data structures, text processing, file system operations, debugging, working with Kotlin libraries.

Once you're comfortable with Kotlin basics, Kotlin Core takes you deeper into how real applications are designed and structured. You'll move beyond simple syntax and start writing cleaner, scalable code that's easier to maintain and extend. The course focuses on building problem-solving skills.

You'll practice decomposing programs into meaningful functions and classes, work with Kotlin's standard libraries, and learn to process text, store data, handle files, and debug your code effectively.

Perfect if: You know basic Kotlin and want to understand how things work under the hood.

Kotlin Developer

CV-ready skills: Advanced Kotlin features, functional programming, coroutines, flows, algorithms, data structures, design patterns, testing.

In Kotlin Developer, you'll explore advanced language constructs, functional programming techniques, and concurrency with coroutines and flows. You'll also deepen your understanding of algorithms, data structures, and testing while working with professional development tools such as Git. By the end, you'll be ready to take on Android, backend, or multiplatform projects.

Perfect if: You already know the core of Kotlin and want to build production-level problem-solving skills — or prepare for Android, backend, or multiplatform development.

Android Developer with Kotlin

CV-ready skills: Android Studio, UI layout and navigation, Fragments, data storage (local and remote), user input handling, app lifecycle, modern Android development practices.

If your goal is to build mobile apps, this is the course that takes you there. Android Developer with Kotlin focuses on creating interactive applications. You'll learn how Android apps are structured, how screens are displayed and connected, how data is stored, and how to design UIs that are functional and easy to use.

The course guides you through Android Studio step-by-step, from simple interface controls to multi-screen navigation and secure data storage. By the end, you'll be comfortable designing and implementing your own Android applications.

Perfect if: You want to start a career in mobile development or build apps that run on Android devices.

Kotlin Backend Developer (Spring Boot)

CV-ready skills: Spring Boot, REST APIs, JSON handling, authentication and authorization, data persistence, Gradle, Git, testing, deployment tools.

This course teaches you how to build server-side applications that handle real-world tasks, like managing data, securing access, and responding to user requests. You'll learn how to structure a web application using Spring Boot, connect it to a database for persistent storage, and implement RESTful APIs to allow clients to interact with your service. Along the way, you'll practice debugging, testing, and deploying your applications. You'll also gain foundational skills in HTML, CSS, and JavaScript to better understand the client side of web apps. By completing this course, you'll be able to design and develop scalable backend systems ready for production.

Perfect if: You're aiming for backend developer roles.

Which One Should You Pick?

Start with Introduction to Kotlin if you’re completely new to programming or new to Kotlin as a language.

Move to Kotlin Core if you already know the basics and want to understand how real applications are structured and how developers approach problem-solving.

Choose Kotlin Developer if you’re switching careers or want a deeper, more comprehensive view of Kotlin for professional development across different platforms.

Go with Android Developer with Kotlin if your main goal is to build Android apps and work with modern mobile development tools and workflows.

Pick Kotlin Backend Developer with Spring Boot if you want to focus on server-side development, APIs, and building scalable backend systems.

The nice thing about our approach is that all these courses are connected. Topics overlap, and your progress carries over — so you don’t have to relearn the same concepts from scratch.

No single course can teach you everything. But our Kotlin courses give you solid practical experience and portfolio-ready projects to help you grow as a developer and build skills that last.

Modern Java Features: Part 2 - From Java 22 to 25

Vahram Papazyan — Tue, 23 Dec 2025 16:57:58 +0000

Welcome back to our series exploring the latest innovations in Java! In Part 1, we covered foundational features like pattern matching and records. Now we turn our attention to features that dramatically improve developer experience and application performance.

This installment covers five game-changing additions to modern Java:

Compact Source Files & Instance Main Methods — Write Java programs without boilerplate, making the language more accessible to beginners and perfect for scripting
Primitive Types in Patterns — Extend Java's pattern matching capabilities to work seamlessly with primitive types
Scoped Values — A modern, efficient alternative to ThreadLocal for passing context in concurrent applications
ZGC — A production-ready garbage collector that keeps pause times under 1ms, even with massive heaps
AOT Class Loading — Dramatically reduce startup times by caching class loading work

Whether you're building microservices that need instant startup, teaching Java to newcomers, or running latency-sensitive applications, these features offer practical solutions to real-world challenges.

Let's dive in.

Compact Source Files & Instance Main Methods

✅ Key JEPs

JEP 445: Unnamed Classes and Instance Main Methods (Preview, Java 21)
JEP 463: Implicitly Declared Classes and Instance Main Methods (Second Preview, Java 22)
JEP 477: Implicitly Declared Classes and Instance Main Methods (Third Preview, Java 23)
JEP 495: Simple Source Files and Instance Main Methods (Fourth Preview, Java 24)
JEP 512: Compact Source Files and Instance Main Methods (Final, Java 25)

🔍 What’s New

JEP 512 finalizes features that simplify writing small Java programs by removing boilerplate and allowing more natural entry points. It combines two ideas:

Compact source files — Java files that omit explicit class declarations.

Methods and fields can appear directly at the top level.
The compiler implicitly wraps them in a generated class.
All public types from the java.base module are automatically imported.

Instance main methods — Java can now start programs from instance methods (like void main() or void main(String[] args)), not only from public static void main(...).

The launcher instantiates the implicit class and calls the method automatically.

A new helper class, java.lang.IO, provides simple console I/O utilities such as IO.println() and IO.readln().

void main() {
    IO.println("Hello, world!");
}

This code compiles and runs directly — no class, no static, no public.

💡 Why It matters

Makes Java friendlier for beginners and small scripts.
Reduces boilerplate for quick demos, exercises, or tools.
Preserves full compatibility: compact source files are still standard .java files.

⚠️ Considerations

Compact files can’t define package statements or named classes.
These files must have exactly one top-level declared class.
IO methods are not implicitly imported; you must qualify them as IO.println() or use import static IO.*.
IDE and build tool support may vary during early adoption.

Primitive types in patterns, `instanceof`, and `switch`

✅ Key JEPs

JEP 455: Primitive Types in Patterns, instanceof, and switch (Preview, Java 23)
JEP 488: Primitive Types in Patterns, instanceof, and switch (Second Preview, Java 24)
JEP 507: Primitive Types in Patterns, instanceof, and switch (Third Preview, Java 25)

🔍 What’s new

This JEP expands the pattern-matching, instanceof, and switch capabilities of Java to primitive types (such as int, long, double, boolean) — not only reference types. Key changes include:

Allowing primitive type patterns in both nested and top-level pattern contexts, e.g., x instanceof int i or case int i in switch.
Extending instanceof so that it can test a value for conversion to a primitive type safely: e.g., if (i instanceof byte b) { … } means “if i can safely convert to byte without loss”.
Extending switch so that the selector and case labels may be any primitive type, and case patterns can bind primitives: e.g.,

  switch (v) {
    case int i -> System.out.println("int value: " + i);
    case double d -> System.out.println("double value: " + d);
  }

Aligning pattern matching uniformly across types: whether reference or primitive, you can decompose and test with patterns.

💡 Why it matters

Improves uniformity and expressiveness: Previously Java’s pattern matching, instanceof, and switch were limited or uneven when it came to primitives versus reference types. Now primitives join the party.
Reduces boilerplate and error-prone code for primitive conversions and range checking: For example, the old pattern:

  int i = …;
  if (i >= Byte.MIN_VALUE && i <= Byte.MAX_VALUE) {
    byte b = (byte) i;
    …
  }

This can now become:

  if (i instanceof byte b) {
    …
  }

Enhances switch flexibility: You can switch on long, float, double, boolean, etc., and use pattern guards and binding for primitives, making certain control-flow clearer and more powerful.

⚠️ Considerations

Preview feature: This capability is still under preview in Java 25, meaning the specification is finalized for now but may still change and requires --enable-preview.
Safety & conversions: The feature does not introduce new implicit conversions that lose information. Patterns only match when the conversion is safe (i.e., no information loss). Developers still need to understand when a primitive value can fit into a target type.
Tooling / backwards compatibility: Because this is preview, IDE support, build tool integration, and migration for large codebases may lag or require extra configuration.
Readability for teams: While this adds expressive power, over-use in contexts not suited to pattern matching (especially primitives) might reduce clarity for developers used to more explicit code.

This feature brings Java's type system and pattern matching into better alignment, making primitive types first-class citizens in modern control flow constructs.

Scoped Values (Preview)

✅ Key JEPs

JEP 446: Scoped Values (Preview, Java 21)
JEP 464: Scoped Values (Second Preview, Java 22)
JEP 481: Scoped Values (Third Preview, Java 23)
JEP 487: Scoped Values (Fourth Preview, Java 24)
JEP 506: Scoped Values (Final, Java 25)

🔍 What’s new

The JEP introduces the concept of scoped values — immutable values that can be bound to a thread (and its descendant tasks) for a well-defined lifetime, allowing code deep in a call chain to access context without explicitly passing parameters.
Key characteristics:

A scoped value is created via ScopedValue.newInstance() and bound for execution via something like ScopedValue.where(USER, value).run(…).
Inside that dynamic scope, any method — even far down the stack or running in a child thread (via structured concurrency) — can call V.get() and retrieve the bound value.
The binding has a bounded lifetime: once run(...) completes, the binding ends and V.get() becomes invalid (or must be checked).
Scoped values are preferred over ThreadLocal for many use-cases: they require immutable data, allow sharing across virtual threads efficiently, and trace the lifetime of the binding in the code structure.

Code sample:

static final ScopedValue<String> USER = ScopedValue.newInstance();

void handleRequest(Request req) {
    String userId = /* extract user id from req */;
    ScopedValue.where(USER, userId)
               .run(() -> processRequest(req));
}

void processRequest(Request req) {
    System.out.println("Current user: " + USER.get());
    // deeper calls can also see USER.get() without passing userId explicitly
}

💡 Why it matters

Cleaner argument passing: Instead of threading contextual data (like user IDs, request-context, tracing IDs) through many method parameters, scoped values let you bind once and let nested methods access when needed.
Better suitability for many threads (including virtual threads): Because the data is immutable and the lifetime is bounded, there’s far less memory overhead versus thread-locals in large-scale concurrent systems.
Improved reasoning: The dynamic scope is explicit in the code (via the where().run() structure), so it’s easier to understand when the data is valid, and when it is not. This contrasts with thread-locals that may leak or remain bound beyond desired lifetimes.

⚠️ Considerations

As a preview feature, the API or semantics may change in future releases.
Scoped values are immutable once bound; they are not a replacement for thread-locals in cases where you need mutable per-thread state or long-lived caching.
Code needs to ensure that get() is only called within a valid bound scope; outside that, an exception may be thrown (or isBound() should be checked).
Tooling, frameworks, and IDE support may lag since this is in preview; plus, migrating from existing thread-local heavy code will need careful design.
Scopes propagate to child threads only when using compatible concurrency constructs (such as via the preview structured concurrency features) — simple new Threads might not inherit the binding automatically unless explicitly supported.

ZGC: Low-latency garbage collector

✅ Key JEPs

JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental, Java 11)
JEP 351: ZGC: Uncommit Unused Memory (Experimental, Java 13)
JEP 377: ZGC: A Scalable Low-Latency Garbage Collector (Production, Java 15)
JEP 439: Generational ZGC (Final, Java 21)
JEP 474: ZGC: Generational Mode by Default (Java 23)
JEP 490: ZGC: Remove the Non-Generational Mode (Java 24)

ZGC (Z Garbage Collector) is a low-latency, concurrent GC designed to keep pause times below 1 ms, regardless of heap size. It supports heaps from MBs to multi-terabyte ranges and is fully production-ready since JDK 15.

🔍 What it does

Performs most GC work concurrently with the application.
Uses colored pointers and load barriers to relocate objects without long stop-the-world pauses.
From JDK 21, supports Generational ZGC (JEP 439) for better throughput in allocation-heavy workloads.

Enable it via:

java -XX:+UseZGC -Xmx8g

💡 Why it matters

Ideal for latency-sensitive systems (finance, real-time analytics).
Scales efficiently to very large heaps.
Requires minimal tuning compared to older collectors.

⚠️ Considerations

Slightly higher memory overhead due to concurrent design.
Throughput may be a bit lower than G1 in CPU-bound tasks.

Ahead-of-time class loading & linking

✅ Key Jeps

JEP 483: Ahead-of-Time Class Loading & Linking (Final, Java 24)

🔍 What the JEP does

JEP 483 introduces a JVM feature that allows Java applications to load and link classes ahead of time, then store that state in a cache for later runs. The goal is to reduce startup time by shifting part of the class-loading work from runtime to a prior “training” phase.

Essentially:

You run your application once (a “training run”) to record which classes are loaded and linked.
You create an AOT cache (archive) containing that information.
On the next startup, the JVM reuses that cache, skipping much of the load/link process to start faster.

💡 Why it matters

Applications, especially large frameworks like Spring, spend noticeable time at startup loading and linking classes. By caching this work, the JVM can cut startup time dramatically—benchmarks show up to around 40% improvement in some cases.

Because this mechanism works without changing your code, it’s easy to adopt in existing projects. It also supports Java’s broader effort to improve startup and footprint, especially for cloud-native and serverless workloads.

⚙️ How it works (high Level)

JEP 483 makes it possible for Java to load and link classes ahead of time, caching that work for faster subsequent startups. It’s a simple yet powerful feature for improving startup performance in modern Java applications—particularly useful for microservices, short-lived workloads, and cloud deployments. Here is how it works (you need to have the jar file of your app with the Manifest file):

Training phase:

  java -XX:AOTMode=record -XX:AOTConfiguration=app.aotconf -cp app.jar

This records which classes are loaded and linked.

Cache creation phase:

  java -XX:AOTMode=create -XX:AOTConfiguration=app.aotconf -XX:AOTCache=app.aot -cp app.jar

This generates the AOT cache file app.aot.

Production run:

  java -XX:AOTCache=app.aot -cp app.jar

The JVM uses the cache to start up faster. If the cache isn’t valid, it gracefully falls back to normal startup.

⚠️ Considerations

The classpath and module configuration during the training phase must match those used later.
The optimization targets startup performance, not runtime throughput.
The training and caching workflow adds a bit of setup overhead, especially in containerized or CI/CD environments.

Conclusion

The features covered in this article reflect Java's commitment to staying relevant in a rapidly changing software landscape. From compact source files that make Java approachable for beginners and scripters, to ZGC delivering microsecond-level pause times for demanding production workloads—these aren't just incremental improvements. They represent fundamental shifts in how we can use Java.

Java continues to evolve rapidly, balancing its enterprise heritage with modern development needs. Whether you're building cloud-native microservices, teaching programming fundamentals, or optimizing high-frequency trading systems, these features provide concrete solutions to real problems.

Hyperskill's Coding Christmas Challenge🎄

Igor Kirillov — Tue, 23 Dec 2025 12:46:57 +0000

Fresh snow outside. Warm lights inside. The quiet days between Christmas and New Year stretch ahead like a blank canvas. You've got time between celebrations, and your mind is already reaching for something to build.

Why not enhance your skills in 12 Days of Coding challenge — a festive journey created for Hyperskill learners that runs from December 25th through January 5th? It's part puzzle, part celebration, and entirely about rediscovering the joy of programming during the most magical time of year.

Why I Built This

The holidays are a unique time. Everyone slows down, but our minds don't. I wanted to create something for those quiet moments between family gatherings, when you're sipping cocoa and feel like solving something elegant. Not a work project. Not a deadline. Just pure problem-solving for the love of it.
This challenge is my gift to the community: 12 days of puzzles that make you think, smile, and remember why you fell in love with code in the first place.

The Countdown Tradition

There's something special about counting down days during the holidays. Advent calendars, New Year's Eve countdowns — we mark time differently in these weeks. Each day feels significant. Each challenge in this series follows that rhythm, building momentum as we transition from one year to the next.

Who Is This For?

This challenge is for developers who want to stay sharp during the break without the pressure of real work. Maybe you're on vacation. Maybe you're between projects. Maybe you just enjoy a good puzzle with your morning coffee.
The difficulty curve is gentle but rewarding. If you can write a for-loop and understand basic logic, you can solve every single challenge. Some might take longer than others, but that's part of the journey.

What I Hope You'll Get From It

I want you to close your laptop after each challenge feeling satisfied. That "aha!" moment when the solution clicks. That reminder that programming can be playful, creative, and deeply rewarding outside of sprint planning and code reviews.
Plus, complete all 12 days and you'll earn an exclusive profile cover, gems, and maybe even some secret rewards from our partners, which I won't reveal just yet.

The Technical Side

I built everything in Python because it's my comfort zone, but I deliberately designed each challenge to be language-agnostic. Whether you're a JavaScript developer, a Java enthusiast, or exploring something new like Rust or Go — the logic works everywhere.
Use whatever tools make you happy. Your IDE, our playground, a text editor and terminal. This is your challenge, your way.

A Peek Behind the Curtain

Special little spoiler for dev.to readers: we're going full algorithm crash course mode this year. Await tasks that rely on the most popular computational theory questions. Good for refreshing your knowledge from that one CompSci class you completely forgot about! Can't wait to see you rebuilding Dijkstra's algorithm in your favorite language.

How to Join

If this sounds like your kind of holiday tradition, here's how to start:

Sign up to Hyperskill - https://hyperskill.org
Find 12 Days of Coding Challenge in My Learning or your Study Plan and begin with Day 1
Join our Discord community and visit the #12-days-of-coding channel for hints and camaraderie
Code in any language that brings you joy — use your favorite setup or try our playground
Most importantly: enjoy the journey!

Happy coding, and happy holidays!🎄

Modern Java Evolution: Part 1 - From Java 22 to 25

Vahram Papazyan — Mon, 22 Dec 2025 09:10:02 +0000

Java has undergone a transformative evolution from versions 22 through 25, introducing features that significantly enhance readability, performance, native interop, and structured concurrency. This article breaks down key JEPs from recent releases, grouped by theme, and highlights both their benefits and potential considerations.

Flexible Constructor Bodies

✅ Key JEPs

JEP 447: Statements before super(...) (Preview, Java 22)
JEP 482: Flexible Constructor Bodies (Second Preview, Java 23)
JEP 492: Flexible Constructor Bodies (Third Preview, Java 24)

🔍 What’s New

Traditionally, Java required that the first line in a constructor must be a call to super(...). These JEPs progressively relax that restriction, allowing:

Preliminary statements (e.g., input validation, logging) before calling super(...).
Explicit control flow logic before initializing the superclass.

Here is what it looks like:

class Student extends Person {
    public Student(String name) {
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException("Name cannot be null or blank");
        }

        System.out.println("Validated name: " + name);

        super(name);
    }
}

💡 Why It Matters

This aligns Java with more intuitive OOP practices, particularly in constructors, where argument validation is often required. It enables safer, more flexible class hierarchies.

⚠️ Considerations

Developers must still ensure that fields are not accessed before full initialization, preserving constructor safety.

Foreign Function & Memory API

✅ Key JEPs

JEP 424: Foreign Function & Memory API (First Preview, Java 19)
JEP 454: Foreign Function & Memory API (Stable, Java 22)

🔍 What’s New

This API replaces JNI with a safer, more efficient, and idiomatic way to:

Call native (C/C++) libraries.
Allocate and manage memory off-heap using MemorySegment, MemoryLayout, and Linker.

try (Arena arena = Arena.ofConfined()) {
    MemorySegment segment = arena.allocate(100);
    // Use memory directly
}

The Foreign Function & Memory API (FFM API) defines classes and interfaces so that client code in
libraries and applications can:

Control the allocation and deallocation of foreign memory (MemorySegment, Arena, and SegmentAllocator),
Manipulate and access structured foreign memory (MemoryLayout and VarHandle), and
Call foreign functions (Linker, SymbolLookup, FunctionDescriptor, and MethodHandle). The FFM API resides in the java.lang.foreign package of the java.base module.

💡 Why It Matters

Java can now operate with native libraries without boilerplate JNI code. This is huge for performance-sensitive
applications like machine learning, image processing, and systems integration.

⚠️ Considerations

Still evolving, and requires an understanding of low-level memory and ABI (Application Binary Interface) details. Avoid misuse that could cause memory leaks or segmentation faults.

Unnamed Variables & Patterns

✅ Key JEPs

JEP 443: Unnamed Patterns and Variables (Preview, Java 21)
JEP 456: Unnamed Variables & Patterns (Final, Java 22)

🔍 What’s New

You can now use _ as a placeholder in places where a variable is syntactically
required, but the actual value is not used. Here is what this JEP adds:

An unnamed variable, declared by using an underscore character, _ (U+005F), to stand in for the name of the local variable in a local variable declaration statement, or an exception parameter in a catch clause, or a lambda parameter in a lambda expression.

try {
    // some risky code
} catch (IOException _) {
    System.out.println("I/O error occurred");
}

An unnamed pattern variable, declared by using an underscore character to stand in for the pattern variable in a type pattern.

if (obj instanceof String _) {
    System.out.println("It's a string, but we don't care about the value.");
}

An unnamed pattern, denoted by an underscore character, is equivalent to the unnamed type pattern var _. It allows both the type and name of a record component to be elided in pattern matching.

record Point(int x, int y) {}

Point p = new Point(3, 4);

if (p instanceof Point(_, int y)) {
    System.out.println("Matched, but ignored both fields.");
}

⚠️ Important: You cannot use _ more than once in the same pattern expression. For example, if (p instanceof Point(_, _)) is not allowed.

💡 Why It Matters

This is a small syntax change with big readability improvements, especially in exhaustive pattern matching or placeholder variables.

⚠️ Considerations

Overusing _ may make the code obscure. Use it where the intention is clear.

Stream Gatherers

✅ Key JEPs

JEP 461: Stream Gatherers (First Preview, Java 22)
JEP 473: Stream Gatherers (Second Preview, Java 23)
JEP 485: Stream Gatherers (Final, Java 24)

🔍 What’s New

Stream.gather() introduces a mechanism to support intermediate stream operation that processes the elements of a stream by applying a user-defined entity called a gatherer. With the gather operation, we can build efficient, parallel-ready streams that implement almost any intermediate operation. This gather method is to intermediate operations what Stream::collect(Collector) is to terminal operations.

An example of a built-in gatherer:

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7);

List<List<Integer>> grouped = numbers.stream()
        .gather(windowFixed(3))
        .toList();

System.out.println(grouped);

You can also define a custom gatherer and use it.

💡 Why It Matters

This allows complex grouping, windowing, buffering, and merging logic to be cleanly expressed in the Stream API, e.g., batching or handling sliding windows, making stream pipelines more flexible and expressive.

⚠️ Considerations:
It adds complexity. Understanding Gatherer mechanics (accumulator, finisher) takes practice.

Structured Concurrency

✅ Key JEPs

JEP 453: Structured Concurrency (First Preview, Java 21)
JEP 462: Structured Concurrency (Second Preview, Java 22)
JEP 480: Structured Concurrency (Third Preview, Java 23)
JEP 499: Structured Concurrency (Fourth Preview, Java 24)
JEP 505: Structured Concurrency (Fifth Preview, Java 25)

🔍 What’s New

Structured concurrency is an approach to concurrent programming that preserves the natural relationship between tasks and subtasks, which leads to more readable, maintainable, and reliable concurrent code. It treats concurrent tasks as a structured unit of work—bound together by lifecycle and failure policies. It introduces APIs like StructuredTaskScope.

Structured concurrency derives from a simple principle: If a task splits into concurrent subtasks then they all return to the same place, namely the task's code block.

Response handle() throws InterruptedException {
    try (var scope = StructuredTaskScope.open()) {
        Subtask<String> user = scope.fork(() -> findUser());
        Subtask<Integer> order = scope.fork(() -> fetchOrder());

        scope.join();   // Join subtasks, propagating exceptions

        // Both subtasks have succeeded, so compose their results
        return new Response(user.get(), order.get());
    }
}

💡 Why It Matters

Makes parallel code easier to reason about.
Simplifies error handling, cancellation propagation, and resource management.
Promotes better structured and maintainable multithreaded applications.

⚠️ Considerations:
Still under preview (5th round). Developers must migrate gradually and understand ForkJoin-based semantics.

Module Import Declarations

✅ Key JEPs

JEP 476: Module Import Declarations (Preview, Java 23)
JEP 494: Module Import Declarations (Second Preview, Java 24)
JEP 511: Module Import Declarations (Final, Java 24)

🔍 What’s New

Module import declarations allow a Java source file to declare which modules it depends on — directly in the source code.

Instead of relying solely on the module system (via module-info.java) or command-line options to express module dependencies, developers can now specify module usage within individual .java files using the new import module syntax.

✅ Syntax Example

import module com.example.graphics;

import com.example.graphics.Image;

This tells the compiler that this file uses types from the com.example.graphics module.

💡 Why It Matters

Simplifies modular development: Especially useful for small programs, scripts, or single-source-file applications.
Reduces boilerplate: No need for a separate module-info.java just to use a few modules.
Improves clarity: The source file shows all its external module dependencies up front.
Enables better tooling: IDEs and compilers can provide better feedback and autocomplete when module dependencies are declared explicitly.

⚠️ Considerations

Using one or more module import declarations leads to a risk of name ambiguity due to different packages declaring members with the same simple name

Conclusion

From enabling pre-super() logic to opening Java to native interop and empowering concurrent designs, these JEPs collectively represent Java’s steady transformation into a modern, expressive, and high-performance platform. While many of these features are still in preview, developers are encouraged to explore them now to prepare for their production maturity in the near future.

Hyperskill's Fright Night Coding Challenge🎃

Igor Kirillov — Wed, 22 Oct 2025 12:06:23 +0000

A miserable autumn day. Rain and gray skies. Two vacation days that aren't enough for the beach, but enough to visit your old uncle in the middle of nowhere. Wrong turns. A dead GPS. Then — a pop, a hiss. Your tire quits.

This is how Day 1 of the Fright Night coding challenge begins — a 10-day journey created for Hyperskill learners that runs from October 22nd through October 31st. It's part puzzle, part story, and entirely about rediscovering why programming is fun.

Here's what inspired it.

Why I Built This

I really love all kinds of puzzles and riddles. I think programming is the perfect sandbox for creating your own puzzles, because the possibilities are endless, and you can solve problems even knowing the language at a surface level — the main thing is being able to recognize algorithms and patterns.

For me, coding isn't just about business logic and production deployments. It's a hobby. It's a playground. And I wanted to create something that reminded other developers of that too.

The Rocky Horror Connection

When I was designing this challenge, I kept thinking about my favorite film — the horror musical Rocky Horror Picture Show. I think those who go through the challenge will definitely notice the parallels. I won't spoil what they are, but keep your eyes open for Easter eggs.

Who Is This For?

This challenge is for everyone who understands that programming is not only writing code for business tasks, but also a very fun hobby.

I tried to make the tasks as accessible as possible for all levels of developers. For some, it will just take a little more time to figure it out. The minimum requirement is simple: know any programming language well enough to understand a for-loop. That's it.

What I Hope You'll Get From It

I hope that all programmers who participate in the challenge will have a good time. The tasks will help them remember algorithms and language elements they haven't used in a long time.

And if you complete all 10 challenges, you'll earn a unique profile cover, a bag of gems, and exclusive rewards from our partners.

The Technical Side

Everything from start to finish was conceived, developed, and tested in Python. But our challenge is specifically designed so that it can be comfortably solved in any programming language.

You can use Python, JavaScript, Java — whatever you're comfortable with.

What I Learned Building This

I once again became convinced of how difficult it can be to describe even the simplest task in a way that is understandable to the maximum number of people. I learned to better abstract from my code and look at the task I just wrote from the outside. This is very valuable, especially for those who often interact with other developers and assign them tasks.

A Peek Behind the Curtain

I don't want to spoil it, but closer to the end there will be one good task for finding the shortest path, for which I had to write a procedurally generated map. It was fun.

What Day 1 Looks Like

The code to the gates is four digits. It is the first, the second, the third and the fourth most common digit in today's sequence, in that particular order. If there are equal number of appearances, higher digit should come first.

How to Join

If this sounds interesting, here's what you need to do:

Sign up to Hyperskill
Find Fright Night Challenge in My Learning and start with Day 1
Join our Discord community and check out the #fright-night-coding channel for hints if you feel stuck
Use any programming language you want — write and run code in IDE of your choice or use our code playground
Have fun!

Happy coding, and happy Halloween. 🎃

5 Python Courses That Help You Build Portfolio-Worthy Projects

Lada Petrushenko — Fri, 17 Oct 2025 19:31:13 +0000

Hi, I’m Lada — Content Project Manager at Hyperskill.

One of the questions we get a lot from our students is: “Which Python course should I start with?”

It's a fair question. We have several Python courses, and yes, they overlap. Each one focuses on different goals and project types, but many topics show up across multiple courses. The good news? If you've already completed a topic in one course, it automatically counts toward another. So you're never redoing work.

Whether you're starting from zero or building on what you already know, you can choose any course and move at your own pace. The main difference is how deep you want to go — and what skills you need right now.

Here's how to figure out which Python course fits you best.

Quick Comparison

Course	Best For	Project Examples	What You’ll Learn
Python Fundamentals with Practical Projects	Complete beginners	Bill splitter / Chatbot	Variables, loops, functions, PyCharm basics
Python Core	Learners ready to go deeper	Password hacker / Flashcards	OOP, data structures, testing, multithreading
Python Developer	Career switchers	Code analyzer / Web scraper / Translator	Databases, web tech, Docker, design patterns
Python Backend Developer with Django	Future backend devs	Service center / HyperSchool	Django REST, Redis, deployment, testing
Python with Algorithms for Tech Interviews	Interview prep	Sorting tool / Password checker / PageRank	Classic algorithms, problem-solving

Note: Each course includes more projects than shown here — these are just some highlights.

The Courses

Python Fundamentals with Practical Projects

CV-ready skills: Python, PyCharm, Git, debugging, functions, data types, control structures, basic problem-solving.

This is where you should start if you've never coded before.
You’ll learn the basics — variables, data types, loops, conditionals, functions, and error handling — and get comfortable with PyCharm, a popular Python development tool.

You’ll also build small projects like a bill splitter for your next group dinner or a chatbot that could help customers on a website.

Perfect if: You've never written a line of code.

What learners say:

"It is a great course with a strong theoretical focus and excellent practical assignments and projects that will help you develop your skills through hands-on experience." — Oleksii Savenko

"I came into this without a single piece of information about Python, besides knowing it's a programming language. This course was great for teaching and mastering not only the basics but also building on those basics as a foundation to actively solve problems and create projects. I liked how the problems weren't too long or overwhelming, and that I didn't have to read a novel or watch multiple hours of videos to learn a topic." — Fahad Rahu

Python Core

CV-ready skills: Object-oriented programming, data structures, algorithms, testing (unittest/pytest), multithreading, version control, code architecture.

Once you're past the fundamentals, Python Core takes you deeper into the language.

Beyond basic syntax, you'll explore algorithms, data structures, object-oriented programming, and testing. You'll also dive into advanced topics like multithreading and become familiar with essential tools, including Jupyter Notebook, PyCharm, and GitHub.
This course is great for building a solid foundation so you can choose your path later — whether that's backend development, data science, or something else.

The projects here show that you understand not just syntax, but how to structure code properly. That's what hiring managers look for when they review portfolios.

Perfect if: You know basic Python and want to understand how things work under the hood.

What learners say:

"I have learned essential Python programming concepts, including syntax, data processing techniques, and object-oriented programming principles. This course has significantly improved my ability to use standard and third-party libraries to enhance code functionality and efficiency. Additionally, I have gained experience in implementing automated tests to ensure code quality." — Evgenii Morgunov

Python Developer

CV-ready skills: Database design (SQL/NoSQL), web scraping, REST APIs, Docker, ORM (SQLAlchemy), design patterns, performance tuning, automation.

This course assumes you already understand Python syntax and want to see how it fits into real projects.

You'll expand on core Python knowledge and explore the broader ecosystem around it. The course covers databases (SQL, NoSQL, MongoDB), web technologies (HTML, CSS, Requests, BeautifulSoup), design patterns, performance optimization, and developer tools such as Docker and SQLAlchemy.

You’ll build projects like a static code analyzer (to catch bugs in your own code), a memorization tool (to help you study or learn new languages), and a multilingual online translator (that works a lot like Google Translate). They’re real applications that you can showcase in job interviews or use to demonstrate your technical skills.

Perfect if: You want to work as a Python developer and need to understand the full development workflow.

What learners say:

"5 stars because this was the course with the most practical applications that I have ever done." — Thomas Buchberger

"During this course, I learned both basic and advanced features of the Python programming language. I gained experience in problem-solving and code development through challenging and interesting projects." — Andrei Raugas

Python Backend Developer with Django

CV-ready skills: Django, Django REST Framework, ORM design, Redis, Pytest, deployment, REST APIs, database optimization, authentication, production best practices.

If you want to build web applications, this is the course that gets you there.

Django is a popular Python framework for backend development, and this course covers it thoroughly. You learn Django's ORM, templates, and admin interface, but also the ecosystem around it: APIs with Django REST Framework, caching with Redis, testing with Pytest, and deployment best practices.

By the end, you'll have full-stack Django applications in your portfolio — real web apps with databases, APIs, and proper testing. That's exactly what companies want to see when they're hiring backend developers.

Perfect if: You're aiming for backend developer roles.

Python with Algorithms for Tech Interviews

CV-ready skills: object-oriented programming, data structures, algorithms, testing (unittest/pytest), multithreading, version control, code architecture.

In this course, you'll learn the essential theory of algorithms and data structures, understand time-complexity analysis, and develop algorithmic thinking — a crucial skill for developers preparing for technical interviews.

The course shows how various real-world algorithms work and how to implement them in Python. In the graduate projects, you'll implement classic algorithms from scratch and even build your own version of PageRank — the algorithm Google used to figure out which web pages are most important.

Perfect if: You're preparing for technical interviews or want to write more efficient code.

What learners say:

"This track has good projects to sharpen and practice your thinking skills with a good number of well-known algorithms."

Which One Should You Pick?

Start with Python Fundamentals if you're new to programming entirely.

Move to Python Core if you know the basics but want to understand how professional developers think and work.

Choose Python Developer if you're looking to switch careers and need a comprehensive view of the development workflow.

Go with Python Backend Developer with Django if you specifically want to build web applications and APIs.

Pick Python with Algorithms for Tech Interviews if you're preparing for job interviews or want to level up your problem-solving skills.

The nice thing about our approach is that these courses are all connected. The topics overlap and your progress carries over — so you don’t have to go through the material twice.

Along the way, you’ll build real projects you can add to your GitHub and show to potential employers.

No course will teach you everything. But our courses give you enough practical experience and portfolio pieces to grow as a developer and build skills that last.

Building Hyperskill: My Story as a Developer

Igor Kirillov — Mon, 13 Oct 2025 20:36:18 +0000

Hi everyone! I’m a Tech Lead at Hyperskill — a project-based learning platform for programmers.
Here’s a bit about how I found my way into tech — and why I still love what I do.

My Role at Hyperskill

At Hyperskill, I handle most of the technical stuff. I'm the one keeping our web interface, mobile app, and IDE plugin running smoothly and integrated with our backend. So if something breaks, most likely you should blame me — sorry! ‍ ‍

My days typically start with a health check: reviewing logs and metrics to catch any issues that surfaced overnight. Then I sync with our support team to understand what challenges our learners are facing in real-time. The bulk of my work involves tracking down and fixing the inevitable small bugs that pop up across our platforms, plus implementing new features based on user feedback.

There are definitely moments when I feel frustrated by code that refuses to cooperate. But what keeps me going is knowing that our platform helps people learn new skills and potentially transform their careers. That mission makes every struggle worthwhile.

How I Got Into Tech

For most of my life, I saw myself as firmly in the liberal arts camp. While I did well enough in STEM subjects and had a knack for the limited programming we covered in school, my real passion was creative work — especially writing. I even pursued a degree in Political Science, about as far from code as you can get.

The turning point came through my tech-savvy friends and those Friday night conversations about computational theory and neural networks that somehow captivated me. I tried Python and experienced almost an epiphany: programming isn't fundamentally different from other creative disciplines! You start with a vision of what you want to create, then explore countless paths to get to that vision. It's actually very similar to creative writing if you think about it. That realization completely shifted my perspective. Programming is actually a form of art. Once I understood that, something clicked that I didn't even know was missing. One project led to another, and here I am writing code professionally for many years.

If you had told my 2015 self that I'd become a programmer, I would have thought you were absolutely out of your mind.

Building for Developers, as a Developer

Building a learning product for developers feels incredibly meaningful to me, especially as someone who taught myself programming without formal computer science training. I wish Hyperskill had existed when I was starting out. Instead, I used countless other platforms and felt every frustration that comes with trying to get a grip on those complex CS concepts.

What genuinely excites me is witnessing our student's journey firsthand. Reading posts in our Discord or comment sections under topics, I see learners making the exact same mistakes I once did, then pushing through those same mental barriers I remember hitting. Watching them struggle with complex concepts and then finally break through, that gives me real joy. Our students' success stories are what really drive me though. People around the world are completely transforming their lives with nothing more than a computer, internet access, and sheer determination. Programming is such a powerful social mobility tool nowadays. That's genuinely extraordinary, and knowing our platform plays a part in those transformations makes everything I do feel worthwile.

How AI Changed My View on Coding

I see AI as simply the latest tool in programming's continuous evolution toward greater efficiency and focus. You see, just three generations ago, developers were programming with punch cards and binary code. We've progressively abstracted away the tedious parts — first with programming languages, then keyboards and terminal screens, then sophisticated IDEs and version control systems like Git.

25 years ago, we were writing code in text editors with barely more functionality than Notepad, and 'version control' meant copying files to floppy disks. Each innovation freed us from mechanical tasks so we could focus on solving more complex problems. AI fits perfectly into this pattern. It handles routine code generation and reduces my time scrolling through Stack Overflow, which means I can dedicate more energy to building meaningful features for our students. But the fundamentals haven't changed — you still need to understand basics of programming to successfully create, verify, debug and optimize. If anything, these skills have become more critical since you can now offload syntax entirely and focus on architecture, logic, and user experience.

AI hasn't fundamentally altered my view of programming, it has simply refined it. The craft is still about problem-solving and creating value for users — we just have better tools to do some dull work for us.

Outside of Work

I'm a committed lifelong learner, so in my free time I inevitably find myself going down Wikipedia rabbit holes at 2am, discovering something like the biological differences between turtles and tortoises (they're not the same, by the way!). I genuinely can't help myself when it comes to exploring new topics. As for recharging, I like watching lighthearted coming-of-age films, reading mid-to-late 20th century American literature, and listening to jazz. Recently, I've also re-discovered absolutely amazing modern Japanese music — there are some phenomenally creative bands emerging from that scene right now. Their music is perfect for powering through challenging work weeks.

My Advice to New Learners

Be ready to learn hard and adapt quickly. Never forget that even though AI can handle routine work now, understanding how things actually work is genuinely rewarding and fun.

Forem: Hyperskill

5 Java Courses That Help You Build Portfolio-Worthy Projects

Quick Comparison

The Courses

Introduction to Java

Java Developer

Java Backend Developer (Spring Boot)

Java Full Stack Developer

Java Desktop Application Developer

Which One Should You Pick?

5 Kotlin Courses That Help You Build Portfolio-Worthy Projects

Quick Comparison

The Courses

Introduction to Kotlin

Kotlin Core

Kotlin Developer

Android Developer with Kotlin

Kotlin Backend Developer (Spring Boot)

Which One Should You Pick?

Modern Java Features: Part 2 - From Java 22 to 25

Compact Source Files & Instance Main Methods

✅ Key JEPs

🔍 What’s New

💡 Why It matters

⚠️ Considerations

Primitive types in patterns, instanceof, and switch

✅ Key JEPs

🔍 What’s new

💡 Why it matters

⚠️ Considerations

Scoped Values (Preview)

✅ Key JEPs

🔍 What’s new

💡 Why it matters

⚠️ Considerations

ZGC: Low-latency garbage collector

✅ Key JEPs

🔍 What it does

💡 Why it matters

⚠️ Considerations

Ahead-of-time class loading & linking

✅ Key Jeps

🔍 What the JEP does

💡 Why it matters

⚙️ How it works (high Level)

⚠️ Considerations

Conclusion

Hyperskill's Coding Christmas Challenge🎄

Why I Built This

The Countdown Tradition

Who Is This For?

What I Hope You'll Get From It

The Technical Side

A Peek Behind the Curtain

How to Join

Modern Java Evolution: Part 1 - From Java 22 to 25

Flexible Constructor Bodies

✅ Key JEPs

🔍 What’s New

💡 Why It Matters

⚠️ Considerations

Foreign Function & Memory API

✅ Key JEPs

🔍 What’s New

💡 Why It Matters

⚠️ Considerations

Unnamed Variables & Patterns

✅ Key JEPs

🔍 What’s New

💡 Why It Matters

⚠️ Considerations

Stream Gatherers

✅ Key JEPs

🔍 What’s New

💡 Why It Matters

Structured Concurrency

✅ Key JEPs

🔍 What’s New

💡 Why It Matters

Module Import Declarations

Primitive types in patterns, `instanceof`, and `switch`