DevNation Live Blog: fabric8-ing Continous Improvement with Kubernetes and Jenkins Pipeline

I’m sure you have heard and read a lot about microservices in the recent past  and how they are here to defend our end users from the horrible monolith. Breaking an application up into many components is a great start, but to take your organization to the next level requires a platform focused on integrating microservices into your continuous improvement process. Red Hat’s James Rawlings & James Strachan led us through achieving our new goal of continuous delivery with containerized microservices. The way to go fast while developing is ensuring that all microservices have their own release cycle. Splitting your team up to align with your microservices will allow faster changes, the ultimate goal. In order to take advantage of many rapid releases your deployment and testing processes must be automated. Automating your build process and creating continuous feedback loops is the way to go.

Continue reading DevNation Live Blog: fabric8-ing Continous Improvement with Kubernetes and Jenkins Pipeline

DevNation Live Blog: Drools 7.X Happenings and Roadmap

Drools is an open source rules expert engine and today the Drools co-founder and platform architect Mark Proctor from Red Hat gave an overview of the future of the KIE (Knowledge Is Everyhting) family. I’ll cover only a subset of what Mark covered, be sure to check out his slide deck for more details.

IMG_20160629_102117

UI and UX

With the recent addition of a dedicated User Experience and Design (UXD) team and full adoption of PatternFly for consistent and polished theming the UI is looking better than ever. The UXD team has been working on creating personas for different use cases ranging from  developers to project managers. The latest release will be targeting GWT 2.8 which will continue to bring outstanding efficiency in designing the frontend to the primarily Java based team. The Errai framework built on top of GWT brings extended benefits to the ecosystem rounding out some of GWT’s rough edges. Uberfire will continue to be used and enhanced to provide perspectives, screens, page composition, security, permissions and more on top of Errai to help Business Central provide a rich user interface and experience.

Bootstrap grid views for building custom forms brings responsiveness and consistent styling to your task forms. This allows for stylized user interfaces to be developed and maintained within the system and used for process and rule interaction.

Deployment

In the upcoming release of Drools you will be able to deploy applications directly to target environments such as OpenShift and WildFly. This allows your application with minimal code, which can now be comprised of just some Data Models and forms, to run directly on OpenShift or WildFly with no extra configuration! KIE will create all the glue code and use your custom forms to create and deploy a webapp. Look to more automatic application generation features coming in the future.

Engine Enhancments

The engine enhancement that Mark covered are numerous and broad in coverage, I won’t try to enumerate them all here. Two that stood out to me are the aggregate decision tables and thread safety updates. A new decision table editing UI has been created that will infinitely scale and can even compose decision tables to represent more complex rules than ever before.

IMG_20160629_104719

In previous versions of Drools, there existed a lot of synchronization code in many places and behavior was unreliable. To address this the team has re-factored the main engine and introduced a state machine at its core. This allowed one point of synchronization (a propagation queue) which simplifies the design and even added some performance benefits.

IMG_20160629_110103

Continue reading “DevNation Live Blog: Drools 7.X Happenings and Roadmap”


Join Red Hat Developers, a developer program for you to learn, share, and code faster – and get access to Red Hat software for your development.  The developer program and software are both free!

 


DevNation is now part of Red Hat Summit.  See www.redhat.com/Summit.  Red Hat Summit is for developers!

Summit Live Blog: Building Exascale Active Archives with Red Hat Ceph Storage

Software defined storage is a leading technology in our industry with more and more platforms and enterprises are using software defined storage (SDS) to store unstructured data. Today, object storage is a primary workload on SDS as organizations are looking to implement active archives for enhanced access and long term storage. Red Hat’s Steve Bohac and Neil Levine covered the bright future for SDS: object storage, active archives, and how Red Hat Ceph provides a solid foundation for all of your storage needs.

Continue reading Summit Live Blog: Building Exascale Active Archives with Red Hat Ceph Storage

DevNation Live Blog: Decomposing a Java EE Monolith into WildFly Swarm Microservices

WildFly Swarm is a “Just Enough” Application Server. If you don’t need EJB, don’t bundle it. Likewise for JPA, JAX-RS, or whatever subsystem. Bringing only the portions of an App Server that you need is the strategy that makes Java EE and the JVM a real contender in the microservices space. Ken Finnigan, Co Founder/Lead of WildFly Swarm, walked us through how easy it is to move a monolith deployment to a WildFly Swarm Microservice.

Continue reading DevNation Live Blog: Decomposing a Java EE Monolith into WildFly Swarm Microservices

DevNation Live Blog: Analyzing Java applications using Thermostat

Omair Majid, a Red Hat Senior Software Engineer, addressed the primordial issue of performance on the Java Virtual Machine. Performance issues of OS, CPU, Memory, and IO origins plague modern systems and present a complex issue to developers so the Thermostat tool focuses on alleviating and easing serviceability while enhancing monitoring of the JVM.

Continue reading DevNation Live Blog: Analyzing Java applications using Thermostat

DevNation Live Blog: Java 9 modularity in action

Common to all solid architecture design is the notion of encapsulation, hiding the internals of a component and exposing a strict contract for consumers. This allows implementation changes to happen while giving strong guarantees about the behavior of other components. At DevNation 2016 Sander Mak and Paul Bakker from Luminis Technologies presented on the upcoming modularity features in Java 9 provided by the Jigsaw JSR which will introduce native mechanisms for enforcing strong encapsulation and service abstraction in the Java language. Java modules are a way of grouping java files and defining what services they provide and consume.

You might think “Hey, Java class files are typically distributed in JAR files, doesn’t that count for modularity?” or maybe even “What about OSGi? Isn’t that modularity for the JVM.”. Although JAR files look like modules during compile time they get clumped together during runtime and there are no “fences” between the classes to hide implementation details. OSGi is a great modular framework but suffers from narrow adoption and adding modularity to the JDK will provide those same encapsulation benefits to many libraries and applications. Furthermore part of the Java 9 specification is targeting modularizing the JDK itself, which cannot be done with OSGi (a framework built on top of the JVM).

Stronger encapsulation means hiding whole packages that are implementation specific from consumers of your API and these principles apply to the JDK as well as other libraries. Currently implementation specific code (like classes from the packages com.sun.* and jdk.internal.* from the JDK) ideally should not be used but that doesn’t stop developers. Those fortunate developers among us tasked with maintaining existing legacy systems might at this point question these fundamental changes and how they will impact existing code which could be using JDK internals. For now, the modularity refactoring in Java 9 will include exposing the internal unsafe classes to maintain backwards compatibility but will be provided with tooling to help migrate your legacy code. Automatic modules is one of these tools that will take your existing code and partially migrate it to modules. A plain JAR on the module path is an Automatic Module which will export everything and reads all other modules.

Theory is great, lets talk details. Say we are using a module that exposes some Java interfaces, like a good encapsulated library, how do we get a reference to an Implementation of the interface? Including the concrete type directly will necessitate a compile time visibility to the implementation which is the exact type of dependency we are trying to avoid with modularity. Enter the ServiceRegistry. The Java modules system utilizes a services loader which has been around for quite a while but is getting a face-lift for new usage in Java 9. Using just a reference to the interface a Java class can look up implementations via the ServiceLoader and then call any methods.

Continue reading “DevNation Live Blog: Java 9 modularity in action”


Join Red Hat Developers, a developer program for you to learn, share, and code faster – and get access to Red Hat software for your development.  The developer program and software are both free!

 


DevNation is now part of Red Hat Summit.  See www.redhat.com/Summit.  Red Hat Summit is for developers!