Getting access to Java applications inside Docker.

Being an eMobility leader in various projects across multiple startups, Piotr was responsible for OCPI and OCPP integration as well as EMP and CPO platforms development. With extensive expertise in the open standards field and eMobility tech solutions, he is leading teams of experienced developers and contributing with invaluable knowledge and experience.

Piotr Majcher

Docker is a great tool that allows developers not to worry about servers, Ops/DevOps not to think about the servers they maintain. It’s also useful for developers who just want to run dependent components without digging into the details of those dependencies.

But Docker comes at a price. It creates an extra level of abstraction and makes accessing the internals of running code more complicated.

 in an environment that is really close to what we usually have in production.

Introduction - debugging a Java application

In order not to stick to any specific IDE, I’m going to use jdb for debugging. It’s a Java debugger which is a part of jdk. Let’s assume we have an executable fat jar with a Spring Boot application called app.jar.

If we want to run the application without debugging it all we need is:

In order to debug it, we need to add few additional parameters (I’m using a specific setup here):

Since we set the suspend parameter to ‘yes’, the application is hanging waiting for debugger.

In another console we can try to attach the debugger to a running application by using the following command:

After few seconds, we can see all the known logs from Spring:

Attaching the debugger to a Java app running inside Docker container

Now, let’s wrap our sample application and run it inside a Docker container. We can do it manually by using the following Dockerfile:

Then we can add the same debug parameters as previously:

Once we build the image and start the container, we can see the same log as before:

Can we now attach the debugger to the Spring application running inside the Docker? Yes, but first we need to expose port 8000 from the container. For instance, we can run a Docker container with the following command:

Now you should be able to attach the debugger without any problems.

Shell and Exec form of CMD and ENTRYPOINT

CMD and ENTRYPOINT are two commands that may be used to tell Docker what tasks need to be executed when starting the container. Both instructions may be used in two ways:

exec form - <instruction> [<executable>, <param1>, <p>, ...]

For instance, we could rewrite the initial docker file I showed you above using exec from:

It’s a small trap when it comes to passing the debugging parameters to exec form of instruction, as

consists of two separate parameters. To make it work, we need to pass it separately:

It’s important to remember that when working with tools like docker-maven-plugin from Spotify as they use exec form of ENTRYPOINT instruction in their documentation by default and it’s easy to just take “debug string” and pass it as a single parameter.

Summary - how to solve common problems with debugging a Java application on Docker

It’s very easy to connect the debugger to a Java application running inside a Docker container. There are two things we have to remember here:

the exposing port we are going to use for debugging,

properly passing parameters to the JVM, having in mind differences between exec and shell forms of CMD and ENTRYPOINT instructions.

Once we have those two things set up, we can debug our code locally in almost the same environment as the production environment.

Learn the easiest way to debug your Java application by reading this piece of content.

Paweł Baczyński

The Java platform comes with three key components: the Java Development Kit (JDK), the Java Virtual Machine (JVM), and the Java Runtime Environment (JRE). They’re a must-have in any project based on developing and running 

The Java Runtime Environment is software designed to help developers run other pieces of software. When developers need to execute a software program, they need an environment to run in. The runtime environment is responsible for loading class files and ensuring that the program can access memory and other system resources.

The Java Runtime Environment is a software layer that runs on top of a device’s operating system and provides additional services that are specific to Java. The runtime environment for Java includes the Java class libraries, Java class loader, and Java Virtual Machine (JVM).

The class loader helps to correctly load classes and connect them to the core Java class libraries. Developers use the JVM for ensuring that their applications have the resources they require to run and perform well in devices or cloud environments. What about the JRE? It mainly acts as a container for the other components (and orchestrates their activities).

Thanks to JRE, developers can blur the diversity between different operating systems, ensuring that their software runs on any OS without modification.

One of the most important value-added services of JRE is automatic memory management. This ensures that developers don’t need to control the allocation and reallocation of memory manually.

The JRE includes integration libraries such as Java Database Connectivity and Java Naming and Directory Interface.

Java memory is made of three components: the heap, stack, and metaspace (called permgen until Java 8). The metaspace is where Java keeps the program's unchanging info (for example, class definitions). Heap space is where you’ll find variable content. Java stores function execution and variable references in the stack space.

Since Java 8, developers can take advantage of metaspace which introduced a significant change in how developers interact with the memory space of this programming language. Before, they would have to use the command java -XX:MaxPermSize to monitor the size of the space available in permgen. From Java 8, the technology is able to automatically increase the size of the metaspace to accommodate the meta-needs of software. Java 8 also introduced a brand-new flag called MaxMetaspaceSize, which development teams can use to limit the metaspace size.

Application monitoring is primarily a function of the Java Virtual Machine. However, the JRE also provides a range of configuration options that form the foundation for monitoring. Developers can use a variety of tools for monitoring Java applications, from simpler ones like the Unix command top to sophisticated solutions for remote monitoring (such as Oracle's infrastructure monitoring).

Moreover, programmers also get to benefit from visual profilers like VisualVM that allow inspecting a running JVM. Thanks to all of these tools, a development team can identify and track down hotspots and memory leaks, and monitor the overall memory consumption of your system.

Are you looking for an experienced team of Java developers for your project? Do you need help in expanding your product with extra Java skills on board? Get in touch with us. We help companies all over the world to make the most of this incredibly powerful technology and realize their business goals efficiently.

Read about the benefits of Java Runtime Environment

Java Runtime Environment

See what's coming with the newest update of Java.

Java 14 release is scheduled for general 

 14 introduces three changes to the language and one useful feature for runtime:

Introducing Records to reduce the number of boilerplate code (preview)

Better debugging with more descriptive stack traces

In this article, we take a closer look at these new features to show you what to expect in Java 14. Two of them are preview features which means that they’re not permanent and may be changed or removed in future releases. You can enable preview features by using the following compiler flags:

There are several problems with the design of the existing switch statements which were taken from C and C++ languages. A new form of switch called switch expression was created to mitigate them.

The first problem with the old switch statement is that it uses fall through semantics. This means that the break statement must be used in the code..

By the way, did you notice a bug in the code? There is a missing break statement for the third quarter. When a programmer forgets the “break;” statement, they’re going to face a nasty bug. The switch expression uses an arrow notation (->) instead of the color (:) used by the older form. The above example can be rewritten to the new form like this:

Another issue is the scoping of variables. A variable declared in one case is in the scope of the entire switch statement.

This problem doesn’t exist in switch expression.

Also, until version 14 switch statements couldn't yield a value leading to constructs where a variable declaration is separated from the code that assigns a value.

In the case where more than one line is needed, all of them have to be included in curly braces. As all cases need to yield a value, we need to use the newly introduced yield statement. It must be the last statement in the block (similar to return in methods).

Note that yield is not a new keyword. It’s rather what we call a restricted identifier (similar to var). It can only exist at the end of the case branch. If it was a new keyword, a lot of the existing code would be broken - including the JDK itself -> Thread. yield().

From time to time, a Java developer needs to use the intanceof operator. If this is the case, usually a cast to a given type follows right away:

This is too verbose (note that BigDecimal is repeated three times). Pattern matching allows declaring a binding variable (big) that relates to a predicate (number instanceof BigDecimal)

Isn't it cleaner? The binding variable can also be used in the same if condition:

 14, the only predicate supported for pattern matching is instanceof check, but future releases are expected to extend the set of supported predicates.

Java Records to get rid of boilerplatecode

Did I mention verbose code? Imagine that you need a class that groups just two fields (first and last name). To make this class complete, you’d have to generate an enormous amount of code.

Records to the rescue! With a simple declaration like this:

We can omit all of the required boilerplate code. The Java compiler will generate a constructor, private final fields, accessors, equals/hashCode and toString methods automatically. We could also solve this issue by using 

 @Value annotation. It will be great when it will be possible to do it in the JDK itself without resorting to third party libraries.

The generated class can be examined with javap:

There are two differences between the class and the record from the example above.

First, the accessors are named exactly as the fields, so it's firstName() instead of getFirstName(). Not much can be done about this. To accommodate it, a number of libraries need to be updated.

Second, the record implementation does no checks in the generated constructor. Here some things can be changed. It’s possible to modify the generated constructor like in this example:

Note that the construction declaration doesn’t declare any parameter list, not even empty parentheses.

You can also add other methods like constructors as well as initialization blocks or static fields. However, you can use no member fields other than in the record declaration. Also, records must not extend any class. They implicitly extend java.lang.Record.

A perceptive reader may have noticed that the Person record wasn’t declared as final while the class was final. There’s no difference here. In the case of records, they are final by default.

The purpose of records is to serve as value classes. Please don’t abuse them by declaring a service class as record. ;)

It’s interesting that this time, Java architects didn’t introduce a new keyword (like they did when enums were added). So, no existing code using the record as an identifier will be broken.

. Rather, it’s a change to the runtime environment. It allows for easier spotting of a cause to a 

. It's disabled by default (for performance reasons, among other things). The feature can be useful in debugging. To enable it, the Java process has to be started with option

Let’s see it in action. There is a line of code that causes 

It shows which line caused the exception, but which method call? Not that helpful. Using the new feature we can get this stack trace:

Now everything is clear. The value of object.a().b().c() is null and this is the reason for error. This also works for arrays of arrays.

Currently stacktrace would look like this:

And with descriptive stack traces enabled:

Again, this is a lot more useful as it clearly points to the part of the code that causes the problem.

The features added to respond to programmers' needs. They’ll make working with Java easier as they allow to reduce the need for boilerplate code. Pattern matching for instanceof doesn’t seem like an important change but it’s a start to adding pattern matching to other places. Records look like a little revolution that should have been added a long time ago. I hope these features will soon move out of the preview stage and into the stable set of features.

The release of Java 14 brings some other changes as well. Some of them affect garbage collection, removing deprecated tools, etc. For a full list of features, visit this 

Java 14 new features

Our rank of the best JavaScript frameworks which you can use in 2020.

According to the Stack Overflow Developer Survey, JavaScript is the most commonly used programming language – for the seventh year in a row! There's no denying that JavaScript is the go-to technology choice for any web development project. The greatest advantage of JavaScript lies in its rich ecosystem of tools, libraries, and frameworks. New JavaScript frameworks emerge on a regular basis, helping to make the language more accessible and easier to use for software developers.

However, the profusion of tools also makes choosing the best-suited framework for the job a challenge. What are the most popular JavaScript frameworks in 2021? And what factors should developers take into account when choosing the technologies for their projects?

Read this article to get an overview of the best JavaScript frameworks on the market and their defining characteristics.

earned considerable popularity very quickly – it's the fastest-growing JavaScript framework today. Developers use this handy library to build and operate dynamic User Interfaces of websites that experience high traffic. That's why it's such a great technology fit for enterprise-grade applications. High-traffic platforms like Facebook and Instagram use React to support their UIs.

is widespread open-source framework companies use primarily for developing dynamic single-page web applications (SPA). Companies like PayPal, Freelancer, and LinkedIn use the framework for powering their UIs.

What's the key strategic advantage of using Angular in a project? It's one of the most powerful and efficient JavaScript frameworks on the tech scene. Its component-based architecture provides a high quality of code, and the use of TypeScript helps developers to write clean code and scale applications easily. The long-term support of Angular by Google is a mark of its quality – but it also means that the framework has a bright future ahead of it.

Since developers get to work with independent libraries, React is more flexible than Angular – and it offers comparatively better response time. All in all, the technology is an excellent pick for applications that need to deliver optimal performance under significant traffic pressure.

Vue was developed in 2014 and is currently used by giants such as Baidu, Grammarly, WizzAir, Facebook, and Buzzfeed. Vue is a great pick for building single-page applications, but it can also support more complex projects and deliver optimal performance.

The framework is known for its accessibility – it's a perfect starting point for developers who want to learn a new framework quickly. Since it goes back to its JavaScript roots, it's also very convenient to use – accelerating the development process and allowing teams to deliver value faster.

Vue is surrounded by an active community of developers who are happy to share their knowledge. The framework also offers detailed documentation that flattens the learning curve for developers who are Vue newbies.

Ember was developed in 2015 and since then has taken the tech scene by storm. The undeniable strength of this framework lies in the fact that it supports two-way data binding that allows developing a reliable platform for handling complex User Interfaces. Companies like LinkedIn, Netflix, and Nordstrom use Ember to build their websites.

The open-source framework is an excellent technology for single-page applications, but also large, complex web apps. However, Ember is known for being a highly opinionated framework – it makes many assumptions about the application and requires developers to conform to these expectations.

Meteor comes in handy to both frontend and backend developers, covering a major portion of software development. This open-source, full-stack framework provides support in a wide range of tasks, from database management and backend development to business logic and frontend rendering. Meteor was written using Node.js, so it allows creating cross-platform code and supports rapid prototyping. It easily integrates with other frameworks such as React, Angular, or Express. It allows developers to build hybrid applications using JavaScript, CSS, and HTML. All in all, Meteor boosts the productivity of development teams by helping developers write less code. Companies like Qualcomm, Honeywell, Mazda use Meteor to build applications.

s is a server-side JavaScript run-time environment that enables development teams to carry out cross-platform projects to help them save time. One of the most frequently downloaded frameworks, Node is an open-source technology used for building backend services or APIs and developing server-side networking applications. Node is built on top of Google Chrome's JavaScript Engine (V8 Engine).

Node can handle multiple requests asynchronously thanks to a non-blocking single-threaded event loop – that's why it works so well for distributed systems that involve numerous network requests. Used by companies like Uber, PayPal, and Walmart, Node helps developers all over the world to boost the performance of their apps while writing fewer lines of code.

This framework is a collection of open-source modern JavaScript modules. Development teams can use it to implement any sort of interface – it comes in handy, especially for more robust websites. Aurelia is able to extend the HTML for various purposes – for example, data binding.

The framework offers a robust platform for building browser, desktop, and various mobile applications. Companies like Freska, Ordami, and BTEK Software use Aurelia in their projects. This is the only framework that allows developers to build components using TypeScript or JavaScript.

This client-side JavaScript framework is mainly used for developing single-page applications. It's easy to implement, small (< 8kb gzip), fast, and provides plenty of useful features out of the box.

Currently used by companies like Nike and Fitbit – as well as open-source platforms like Lichess – Mithril uses a sophisticated virtual DOM algorithm to minimize the number of updates and accelerate the development process and ensure high performance. It has a gentle learning curve that allows software developers to start using the framework after spending very little time learning about it.

Polymer is an open-source JavaScript library developed by Google. Development teams can use it to create various website elements without having to get into the complex level. Polymer supports both one-way and two-way data binding. That's why it can be applied to solve many different problems.

The framework has gained considerable traction on the market because it provides a structured design process. Polymer was built to take advantage of the features present in the web platform to allow developers to build components easily. It was the first library to enable interactive building applications by composing components. Many Google services and sites use Polymer – for example, YouTube and Google Play Music. Netflix benefits from Polymer as well.

Used by companies such as Sony Entertainment Network, Airbnb, and SoundCloud, Backbone is one of the most famous JavaScript frameworks. It has a gentle learning curve, and developers have an easy time understanding it. You can use it to create single-page applications and client-side applications that run in a web browser. The idea behind the framework was keeping all the server-side functions flowing through an API – that's how teams can build complex functionalities by writing less code. This lightweight library is highly flexible and allows developers to choose the right tools for a specific project.

Which is the best JavaScript framework for my project?

JavaScript frameworks bring many benefits to the development process by making it easier for developers to work with JavaScript. When choosing the framework for your project, pay attention to the level of complexity it can handle and key problems it promises to solve. If you're looking for a technology that would enable your team to bring a product to market fast, choose a framework known for accelerating the development process.

Are you looking for JavaScript experts who could help you pick the best technologies for your project? Get in touch with us; we have a lot of experience working with different JavaScript frameworks in projects across many industries.

Debugging Java applications running on Docker.

11 APRIL 2019 • 9 MIN READ