Meet Apache Netbeans

We had a sneak peak at some of the Apache Netbeans features last night with the informal Netbeans get together at the thirsty bear, when Geertjan Wielenga gave us a quick demo of (the very impressive) Oracle JET.

This session gave us a quick history of Netbeans, and the future plans for it. Especially now that it’s an Apache project.

Oracle is still invested in making this a success as many of their own tools are built on Netbeans. However, other big companies (example Red Hat, Airbus, Boeing) are also building solutions on top of the Netbeans platform and can now contribute to the development and road-map.

We also got shown a quick demo of Netbeans 9, running Java 9 and the tool support for Java 9 features like JShell and Modules, with a cool visual representation of the module graph.

Read more:


Successful Java EE DevOps in the cloud

“Software developers are the most important people in the world”

This talk by Edson Yanaga gave us some background on DevOps, and more specifically DevOps in the cloud.

Cloud vendors might try and lock you in with some extra services like Pipeline automation, Blue Green Deployments etc, making the cost of change too high.

“Outside innovation is always bigger than inside” and this is why Open Source is becoming the default standard for software.

Containers and Container Orchestration will also soon become the de-facto standard.

Kubernetes, as an example, allows you to change cloud providers in minutes.


An open platform to connect, manage, and secure microservices

  • Intelligent Routing and Load Balancing
  • Resilience Across Languages and Platforms
  • Fleet-Wide Policy Enforcement
  • In-Depth Telemetry and Reporting

5 Pillars of a Successful Java Web application

Very interesting talk on some pillars (or principles) to create a sustainable web app in Java.

Eder Ignatowicz and Alex Porcelli from Red Hat took CDI to the browser, allowing you to code with CDI Annotations and bind that to HTML. Very interesting concept. It decouples the code very nicely and abstracts the underlying implementation. This allows you to change to (whatever the latest JavaScript library is) with parts of your system, while other parts stay in the older technology.

They also brought CDI Events to the browser, underlying using a Bus, Long polling, SSE and WebSockets.

Look at

Building a recommendation Engine with Java EE

Otavio Santana and Hilmer Chona explained why recommendations are next in our web journey (Web 3.0). Context matters. And for us to store the information in a way for us to get this context easy, traditional relational DB might not be the choice.

However, graph databases do not have a standard, and this means you lock yourself into the implementation, and this is where Apache TinkerPop and JNoSQL can help.

Microservices Data Patterns: CQRS and Event Sourcing

Edson Yanaga and Víctor Orozco gave a high level talk on the strong eventual consistency model using CQRS and Event Sourcing. Basically this means that your data might be outdated for a moment (but never wrong).

Event sourcing (or the streaming of events) is then basically the storing of changes, rather that the actual updated date. This means you can get to the current value by re-playing the changes (this might be something that you can cache, as the replay might be slow).

When implementing this you need to think about

  • Messages (not messaging) between services, rather than Remote calls between services.
  • Update frequency
  • Update size
  • Staleness
  • Time to build CQRS data
  • Change notifications

We (Multiply) need to do this for User Events and User Scores.

Some projects we need to look at:

We move code rather than data

This was my favorite talk of the day :)

Powerful Lessons from Top Java EE Experts

This was a discussion panel with some of the Java EE Industry experts where the audience could ask question.

This discussion was mostly around

Some notes:

  • For this to work we will need strong community involvement
  • The vendors (Oracle, Red Hat, IBM) are still heavily involved
  • This should be easier to contribute (GitHub Pull request)
  • The way implementors do the TCK and documentation will have to be standardized
  • We need to lookout for fragmentation
  • EE4J is the project name, not necessary the brand

All and all, this is a long overdue positive step and I believe we will see the Java EE specs moving faster now.

Some of the experts on stage:

(Go follow them on twitter)

REST Services with the Play Framework and a security level with JWT

Mercedes Wyss showed us how you can (very easily) use the play framework (that one traditionally links to view technology) to create REST Services. The nice thing is you can choose Java or Scala when implementing this.

Very interesting, and if you are already building your Web app in play it might make sense. It’s very similar to Jersey and Jersey MVC.