DEV Community: The Polymorphic Guy

The Most Used Java Frameworks Nowadays (2026)

The Polymorphic Guy — Tue, 24 Feb 2026 01:20:02 +0000

In the modern Java ecosystem, some frameworks stand out for their broad adoption, community support, and real usage in production applications today. This list reflects what developers and teams are actually using in 2026 — based on recent trends and industry reporting — rather than historical or legacy frameworks. Below I’ve gathered a list and videos that I’ve watched and found very informative about each framework.

1. Spring Boot — The Enterprise Standard

No conversation about Java frameworks is complete without Spring Boot.

Spring Boot remains the most popular Java framework in 2026, thanks to its mature ecosystem, excellent documentation, and wide adoption for building REST APIs, microservices, and large enterprise backends. It has an extensive extension ecosystem (Spring Security, Spring Cloud, Spring Data) that makes it a default choice for many teams.

2. Quarkus — The Cloud-Native Challenger

Quarkus has become one of the most talked-about frameworks for cloud-native applications.

Designed from the ground up for Kubernetes and GraalVM, Quarkus delivers extremely fast startup times and low memory consumption. Teams building containerized microservices and serverless workloads are increasingly turning to it.

3. Micronaut — Lightweight and Fast

Micronaut continues to grow as a framework focused on performance and efficiency.

Its design avoids heavy runtime reflection, resulting in a smaller memory footprint. It’s especially popular in serverless functions and edge environments, where startup speed and efficiency matter.

4. Jakarta EE — Standards-Based Enterprise

Jakarta EE (the successor to Java EE) remains relevant in 2026.

It serves as a standards-based foundation for enterprise applications and is still widely used in regulated industries where standardized specifications are preferred over proprietary frameworks.

5. Hibernate — The Persistence Layer Everyone Uses

Although not a web framework, Hibernate is one of the most widely used Java frameworks for object-relational mapping (ORM).

It simplifies database interactions and is commonly paired with other frameworks like Spring Boot, Quarkus, and Micronaut.

6. Vaadin — Full-Stack Web UI in Java

Vaadin stands out as one of the few frameworks that lets you build full web UIs purely in Java, without writing JavaScript.

It’s often chosen for business applications, dashboards, and internal tools by teams who want to keep front-end and back-end in the same language.

Final Thoughts

In the present day, the Java framework ecosystem remains vibrant and relevant. Spring Boot continues to lead in adoption and community size, with cloud-native options like Quarkus and Micronaut gaining traction, Jakarta EE still serving enterprise standards, Hibernate remaining the dominant ORM, and Vaadin providing a full-stack Java UI option across different types of projects.

This list reflects frameworks that are actively used today, based on current ecosystem trends and industry reporting — not merely legacy popularity.

Let’s connect!
GitHub
LinkedIn

The 11 Most Popular NuGet Packages to Know in 2026 (updated!)

The Polymorphic Guy — Sat, 21 Feb 2026 18:11:48 +0000

In the .NET ecosystem, NuGet remains the primary package manager for dependencies — and some libraries continue to dominate because they solve core development challenges efficiently. Below, I show you the most widely adopted and high-impact packages as of 2026, backed by download statistics from the official NuGet.org registry.

1. Newtonsoft.Json

Newtonsoft.Json has long been the go-to JSON serializer for .NET applications. It handles complex serialization and deserialization scenarios with ease and is still the most downloaded NuGet package overall, boasting hundreds of millions of downloads.

Why it matters: Nearly every .NET project deals with JSON data — from APIs to configuration — and Newtonsoft.Json remains reliable when performance and flexibility matter.

2. Serilog

Serilog is a structured logging library that has become a de-facto standard in .NET. It supports sinks for writing structured logs to files, consoles, and remote systems.

Why it matters: Applications today need rich, searchable logs to diagnose issues in production, especially in distributed or cloud environments.

3. Polly

Polly provides a comprehensive resilience framework for transient fault handling, including retry, circuit breaker, timeout, and fallback policies.

Why it matters: As .NET apps increasingly interact with remote services, built-in resilience becomes essential to avoid cascading failures.

4. CsvHelper

CsvHelper is a fast and flexible library for reading and writing CSV data. It’s ideal for data import/export tasks and lightweight ETL workflows.

Why it matters: CSV remains a ubiquitous format for data exchange across systems — and CsvHelper simplifies working with it in .NET.

5. Swashbuckle.AspNetCore

This library integrates Swagger/OpenAPI into ASP.NET Core applications, enabling automatic API documentation generation and interactive UI at runtime.

Why it matters: Clear, self-documenting APIs are critical for developer productivity and external integrations.

6. awssdk.polly & awssdk.core

The AWS SDK packages — including awssdk.polly and awssdk.core — appear among the highest download counts, reflecting widespread use of AWS services from .NET applications.

Why it matters: Integration with cloud services like AWS remains a major use case for enterprise and startup .NET workloads.

7. Google.Protobuf

Google.Protobuf provides support for Protocol Buffers, a compact data serialization format widely used for high-performance communication.

Why it matters: Protocol Buffers are popular in microservices and gRPC scenarios, where efficiency and strong typing matter.

8. Ecng.Collections

Ecng.Collections is a high-performance collection library that offers advanced structures beyond the standard .NET collections.

Why it matters: Many large-scale and performance-sensitive applications adopt specialized collections to optimize memory and speed.

9. Xunit & Moq (Test & Mocking Tools)

Testing libraries like xUnit and mocking frameworks like Moq aren’t always in the top aggregate download list from NuGet.org, but community sources point to them as indispensable development tools.

Why it matters: Unit testing and mocking accelerate development quality and confidence as .NET projects scale.

10. Dapper

Dapper is a lightweight, high-performance micro-ORM for .NET that extends the ADO.NET IDbConnection interface to provide simple methods for executing SQL queries and mapping results to .NET objects. It’s widely appreciated for its speed — nearly as fast as raw ADO.NET — and is ideal in scenarios where performance and control over SQL matter most, such as high-throughput APIs and complex reporting queries. Its simplicity and minimal abstraction make it a popular choice when developers want to avoid the overhead of a full ORM while still benefiting from object mapping.

Why it matters: Dapper streamlines data access with minimal overhead.

11. AutoMapper

AutoMapper is a convention-based object-object mapping library that automates the process of copying data between different types of objects, like transforming domain models into DTOs and vice versa. Rather than manually assigning each property, AutoMapper lets developers define mapping configurations once and reuse them throughout the codebase, reducing boilerplate and improving readability. It remains popular in many projects for handling repetitive mapping logic, especially in applications with many model transformations.

Why it matters: AutoMapper reduces boilerplate when copying data between domain models and DTOs.

Why These Matter for 2026

Modern Architecture: Patterns like resilience (Polly), clean validation (FluentValidation), and decoupled logic (MediatR) are increasingly standard as .NET apps scale.

Developer Tooling: Serilog, Swashbuckle, and Bogus enhance productivity in logging, API documentation, and testing, respectively.

Key Trends Shaping NuGet Usage in 2026

Resilience & Reliability: Packages like Polly show the growing emphasis on robust, fault-tolerant systems.
Cloud Integration: Adoption of AWS and Google libraries reflects the shift toward cloud-native architectures.
Developer Productivity: Tools for logging (Serilog), documentation (Swashbuckle), testing (xUnit/Moq), and mapping (AutoMapper) remain core to efficient workflows.
Performance Focus: Libraries like Dapper and Ecng.Collections are preferred when performance matters most.

In conclusion, these are the top 11 NuGet packages shaping .NET development in 2026. Whether you are a new or experienced .NET developer, these libraries reflect the current ecosystem’s priorities — from JSON handling and resilience to structured logging, API documentation, and high-performance data access. Choosing the right packages can help you write more robust, maintainable, and efficient code, and staying aware of trends keeps your projects up to date with modern .NET practices backed by real-world usage data.

Let’s connect!

GitHub
LinkedIn

Modern C++: Multithreading and Filesystem library (practical example)

The Polymorphic Guy — Thu, 09 Apr 2020 22:09:48 +0000

In this post, I will show you a bit of usage of multithreaded programming (C++11) and the Filesystem library (C++ 17). The idea is to get straight to the point.

Disclaimer: This is just a hypothetical approach that simulates a timer to check for any new files in a directory at regular intervals. The recommended approach for the real scenario would be to use some API from the OS itself (such as inotify on Linux) that notifies processes when a file system event occurs.

Definitions:

//dirmgr.hpp

1  #include <string>
2  #include <thread>

3  using namespace std;

4  class DirManager
5  {
6      private:
7          void watching_task(string path);
8          bool stop_flag = false;
9          int count_items(string path);
10         thread* obj_linked_thd;

11      public:
12          ~DirManager();
13          static void check_dirs();
14          bool start_watching(string path);
15          void stop_watching();
16  };

First of all, I defined a class (DirManager), which will fulfill two roles: 1) To check the existence of the [in] and [out] directories in the current directory where the program was started from and 2) To monitor the [in] directory .

Implementation:

//dirmgr.cpp

1 #include "dirmgr.hpp"
2 #include <filesystem>
3 #include <iostream>

4 using namespace std;
5 namespace _NS_fs = std::filesystem;

Public Methods

check_dirs(): Fulfills the role mentioned in 1). It was defined as static method, that is, it does not need to be invoked through an object, this can be done via class directly, such as at main.cpp:6.

11 void DirManager::check_dirs()
12 {
13    try
14    {
15       if (!(_NS_fs::exists("in")))
16          _NS_fs::create_directory("in");

17       if (!(_NS_fs::exists("out")))
18          _NS_fs::create_directory("out");
19    }
20    catch (const exception &e)
21    {
22       cout << "Error on trying to create [in]/[out] directories." << endl;
23       cerr << e.what() << endl;
24       exit(EXIT_FAILURE);
25    }
26 }

start_watching(string path): Creates an object of class thread on the heap and stores its address in the pointer obj_th. The class constructor used in this case takes 3 arguments as input: 1. the address of the method that will be executed in a new thread (DirManager :: watching_task in this case), 2. the pointer to the instance of the class that has the method (this pointer in this case), and 3. the argument used by the method (path).

The private member obj_linked_thd receives the contents of obj_th in order to be accessed in the class destructor (dirmgr.cpp:8).

40 bool DirManager::start_watching(string path)
41 {
42    try
43    {
44       thread* obj_th = new thread(&DirManager::watching_task, this, path);
45       this->obj_linked_thd = obj_th;
46       return true;
47    }
48    catch (const std::exception &e)
49    {
50       std::cerr << e.what() << '\n';
51       return false;
52    }
53 }

stop_watching(): Just sets the data member stop_flag to true.

~DirManager(): The class destructor uses the join() method of the thread class. This causes the parent thread to wait for the child thread to finish before proceeding. Since the obj_dm (main.cpp:7) object will be dropped at the end of program execution, this ensures that the child thread has completed before exiting the program, avoiding problems.

Note: On line 9, the delete operator is used to release the allocated memory addressed by obj_linked_thd as it was allocated through the new operator (line 44). Since C++11, the standard library has been supported smart pointers, making it unnecessary to use the delete operator to release allocated memory.

6 DirManager::~DirManager()
7 {
8    this->obj_linked_thd->join();
9    delete this->obj_linked_thd;
10 }

Private Methods

watching_task(string path): Initially, it uses the count_items() method to get the number of files in path before entering the loop in which monitoring will be active while stop_flag is false. The thread is suspended inside the loop for 3 seconds (simulating a timer with this interval). Then the number of files is cheked; if it is larger than previous one, it means that a new file has been created.

27 void DirManager::watching_task(string path)
28 {
29    int files_count = this->count_items(path);

30    while (!this->stop_flag)
31    {
32       this_thread::sleep_for(chrono::seconds(3));

33       cout << "Monitoring [in] directory, interval 3 secs." << endl;

34       if (this->count_items(path) > files_count)
35          cout << "New file created." << endl;

36       files_count = this->count_items(path);
37    }

38    cout << "Monitor finished." << endl;
39 }

count_items(string path): Traverses all elements of the directory contained in path through the directory_iterator. Each element p is an object of the directory_entry class. If p is a file (line 63), the counter is incremented.

58 int DirManager::count_items(string path)
59 {
60    int items = 0;

61    for (auto& p : _NS_fs::directory_iterator(path))
62    {
63       if (_NS_fs::is_regular_file(p.path()))
64          items++;
65    }
66    return items;
67 }

The program entry point:

//main.cpp

1 #include "dirmgr.hpp"
2 #include <iostream>

3 using namespace std;

4 int main()
5 {
6    DirManager::check_dirs();
7    DirManager obj_dm;

8    if (!obj_dm.start_watching("./in"))
9    {
10       cout << "Could not start Directory Monitor." << endl;
11       return EXIT_FAILURE;
12   }

13   for (int n = 0; n <= 20; n++)
14   {
15       this_thread::sleep_for(chrono::seconds(2));
16       cout << "Main thread alive." << endl;
17   }

18   obj_dm.stop_watching();

19   cout << "Main thread finished." << endl;

20   return EXIT_SUCCESS;
21 }

Execution:

https://dev-to-uploads.s3.amazonaws.com/i/2vrhfbdusr179s9kstux.png

In a terminal the program is launched. During its execution, in another terminal a file is created in the [in] directory. Then the message “New file created.” is shown in the fisrt one.

It is important to note that in this multithreading use model, the execution is asynchronous, that is, one task does not need to wait for another to finish. Therefore, the ending message of the main thread is shown before the ending message of the child thread, although obj_dm.stop_watching() is invoked before the line where the ending message of the main thread is printed out (lines 18–19).

Full repo and build info:

prog-lessons / multithreading_fs_sample

Small sample program to demonstrate multithreading and filesystem lib usage in CPP17.

C++

Threads & FileSystem (C++17)

View on GitHub