@Bean
@WebController
public class App {

    @WebRoute( path = "/hello")
    public String hello() {
        return "Hello, world!";
    }

    public static void main(String[] args) {
        Application.run(new SampleApp.Builder());
    }
}

Create Microservices applications in minutes that start in milliseconds and run blazingly fast.


Modularity Modularity

Modularity is a key aspect of modern applications development. It allows to properly separate the concerns by isolating the different parts of an application into modules with clear interfaces. A modular application can then be effectively developed by a large group of people while promoting reusability resulting in highly maintainable and extensible applications.

The Inverno Framework embraces the Java™ module system. An Inverno module is assembled through IoC/DI at compile time, it exposes a clear interface describing the features provided and the dependencies required for the module to operate. This greatly improves program stability over time and clarifies module usage.

Performance Performance

Performance is a multi-faceted topic, modern applications running in containers, sometimes even serverless, must start as quickly as possible and support very high throughput while making fair use of resources.

The Inverno Framework reduces to the minimum the runtime processing required to bootstrap an application by relying on the compiler to generate the exact code that instantiates and wires the objects of the application together without use of reflection resulting in fast startup and small runtime overhead.

It also combines a best-in-class reactive threading model with non-blocking I/O in order to absorb very high throughput without wasting resources.

Reactive Reactive

In a fully reactive application, processing is asynchronous and non-blocking, the execution can switch between active tasks without going into an idle state waiting for some blocking operation to finish maximizing the use of hardware resources.

The Inverno Framework has been designed from scratch to follow the reactive programming paradigm, making it easy to create fully and truly reactive applications.

Microservices Microservices

Microservices architecture has become the de facto standard for backend applications. It ensures a great modularity that makes complex applications easier to understand. Microservices can be monitored and scaled independently, they are easier to integrate with legacy systems and their development can be easily distributed and parallelized. All this makes it a perfect match for the Cloud and DevOps practices.

The Inverno Framework facilitates the development of Microservices and exposes corresponding Open API specifications with no runtime overhead by generating them from JavaDoc comments at compile time.

Configurability Configurability

Modern applications can no longer be configured in a simple property files as they have become more complex and require more advanced configuration capabilities. An application can run in multiple situations on multiple environments, geographical locations or servers and targeted by different tenants or users. All these aspects define particular contexts for which particular configurations are needed.

The Inverno Framework provides a unified Configuration API which can be used to create agile and highly configurable applications from low-level configuration required to bootstrap the application to high-level tenant specific configuration used to customize the behavior of the application at runtime.

Maintainability Maintainability

Information systems must adapt to an ever-changing environment. Features must be continuously added or removed while guaranteeing limited defects with the lowest MTTR.

The Inverno Framework produces modular applications which makes it easy to replace a faulty or worn-out module or add a new one without impacting the rest of the application. Modules expose clear interfaces generated at compile time and only expose what needs to be exposed, the rest of the implementation being properly encapsulated by the Java™ module system protecting against intentional or unintentional misuse.

There is no magic, the generated code is human readable, it can be debugged and we can actually see how objects are created and wired together.


The Inverno Framework provides high-end performance.

Benchmarks

Startup Time

The Inverno Framework reduces application startup time on the JVM.