Java

Come see how easy it is for developers to create and build microservices with Spring Boot and WildFly Swarm and deploy them to Kubernetes

In this talk, we'll show how you can refactor your traditional object-oriented Java code using Functional Programming features and APIs from Java 8, following several recipes and refactor legacy code in order to make it more readable and flexible. We discuss: - How to separate concerns using Lambda Expressions - How to handle with requirement changes using first-class functions - How to make several traditional OO design patterns more concise using lambda expressions The talk will consist of a balance between theoretical concepts and practical applications. Attendees will leave with concrete knowledge to refactor their traditional object-oriented Java code to make the best use of Functional Programming features and new APIs Java 8 APIs.

This panel will bring together developers that understand the benefits of containers technologies, to clarify their importance, their problems, and how to apply to real world projects.

Speaker: Jeremy Davis

Yes, Docker is great. We are all very aware of that, but now it’s time to take the next step: wrapping it all and deploying to a production environment. For this scenario, we need something more. For that “more,” we have Kubernetes by Google, a container platform based on the same technology used to deploy billions of containers per month on Google’s infrastructure. Ready to leverage your Docker skills and package your current Java app (WAR, EAR, or JAR)? Come to this session to see how your current Docker skill set can be easily mapped to Kubernetes concepts and commands. And get ready to deploy your containers in production.

Red Hat JBoss Fuse integration services delivers cloud-based integration based on OpenShift by Red Hat to deliver continuous delivery of tested, production-ready integration solutions. Utilizing a drag and drop, code-free UI and combining that with the integration power of Apache Camel, Fuse integration services is the next generation iPaaS. In this session, we'll walk you through why iPaaS is important, the current Fuse integration services roadmap, and the innovation happening in open source community projects to make this a reality.

Kubernetes is a powerful, open source, container orchestration and cluster management tool from Google. It drew upon all the lessons learned from a near-decade of using containers at Google. In this session, we'll look beyond container orchestration with Kubernetes and take a deep dive into more advanced features such as autoscaling. But its most powerful feature is its versatile REST API, which you can use to tailor Kubernetes to your needs. In addition to the out-of-the-box Kubernetes Autoscaler, we'll look at: - How to access the Kubernetes API securely - The different Kubernetes resources such as Pod, Replication Controller, Service, etc. - How to update/manage your entire cluster using the API We'll use the techniques and the REST API to demonstrate how to cluster Infinispan, an in-memory data grid, in Kubernetes, and autoscale Infinispan using custom metrics.

Programmers use a simple sequential model of how a processor executes steps in a program, but in reality the processor's implementation is much more complex. The processor employs techniques that exploit typical characteristics of the code allowing the processor to execute the code much faster than the simple programmer's model and reduce the cost of some individual instructions by a factor of ten to one-hundred. However, the processor must preserve the behavior that the programmer expects and fallback to the slower methods when the optimization would yield results that differ from the programmer's model. Mechanisms such as caches, pipelines, branch prediction, and threading are commonly used in modern processors to improve performance. In this session, we'll explain the performance implications of these mechanisms, how to identify specific performance issues such as poor caching and branch prediction using the tools available on Linux and some optimization techniques that better match code and hardware capabilities.

Users have higher expectations than ever from the applications and websites you deliver. They expect information to be organized, intuitive, and easy to use. With an average of 10 seconds to make a good first impression, it's critical that your application aligns with your user’s expectations, wants, and needs. In this session, you'll learn 7 strategies to use on any project to improve the user’s experience and keep them coming back for more.

Based on a wide variety of surveys taken over recent years, many companies are transitioning to something that looks more like Agile than the processes they were using in previous years. However, that transition doesn’t necessarily mean implementations have been done respectfully of the Agile Manifesto and the principles behind it. In large part, industry trends seem to indicate that the sloganization of the word has done a significant disservice to the ideas that were originally founded in 2001. To add even more pain, most people seem to be entirely unaware of the core basis of Agile which is the idea to embrace change but inspect and adapt to that change. Are we lost as an industry? Is there anyway we can recover from this problem? In this session, attendees can expect to engage in a conversation about the rise of the Agile community, the negative and positive impact it has had on the industry, and how you individually can help your organizations and teams lower the risk of encountering the negative problems, and speed your way towards the positives. Topics will include: - The intentions behind agile - Ways you can rework or improve your not so great agile situation - Things you should avoid from the start.

Ever wondered how your Java application is actually working? How it's making use of scarce resources on your machine? Ever tried to look under the hood of the Java Virtual Machine (JVM) and felt lost with various tools that don't provide an overall picture, only local details? Thermostat is an open source serviceability tool to help Java developers understand what's happening inside the JVM when their programs are running. Thermostat collects and combines information from various sources—including the Hotspot JVM—to present a complete picture of how the application is behaving. In this session, you'll get a chance to see Thermostat in action as it's used to examine various Java applications, identify what's wrong and fix those problems—often without even modifying the application code. You'll also learn how to add more features to Thermostat through plug-ins. If you're a developer, sysadmin, or QA, and if there's Java in your technology stack, you'll want to learn how Thermostat can make your life easier.

With the recent advancements in modern browsers, more native app-like features are coming to the browser. Things like push notifications, background sync, offline capabilities and home screen app icons have been added to browsers allowing developers to continue building web apps, but now include features that users expect from native apps. In this session we'll take an existing web app and transform it into a progressive web app. We’ll learn how to make the web app installable, how to make it work offline and finally we’ll learn how to add push notifications to re-engage our users.

Just like a spoon full of sugar will cure your hiccups, running your JVM with -XX:+UseShenandoahGC will cure your Java garbage collection hiccups. Shenandoah GC is a new garbage collector algorithm developed for OpenJDK at Red Hat, which will produce much better pause times than the currently-available algorithms without a significant decrease in throughput. In this session, we'll explain how Shenandoah works and compare it to the currently-available OpenJDK garbage collectors.

The new era of JavaScript is here. Survey the ECMAScript 2015 (ES6) landscape. Master arrow functions, let & const variables, modules, classes, and more. Gain JavaScript superpowers and impress your friends. See old code transformed into elegant ES6 syntax. Grow your web development skills as Michael and Joshua take you through the latest in the JavaScript universe.

Containers: they’re all the rage. But you need to stay grounded in trusted technology such as Java and .NET. Wouldn’t it be great if someone showed an example of bringing Java and .NET and containers together? Oh, and don’t be limited to just one technology stack. Well, this is that session. I’ll be using as many technologies as we can cram into 60 minutes to show how open source brings the old and new together to make both even better. You won’t want to miss this.

In this session, we'll talk about what's different about this generation of web applications and how a solid development approach must consider the latency, throughput, and interactivity demand by users across mobile devices, web browsers, and Internet of Things (IoT). We'll demonstrate how to include Couchbase in such applications to support a flexible data model and the easy scalability required for modern development. We'ill demonstrate how to create a full stack application focusing on the CEAN stack, which is composed of Couchbase, Express Framework, AngularJS, and Node.js.

Through the years, Java has become much more than just a programming language. It's also an enterprise platform for JEE application development. However, at some level, security and cryptography are easy to get wrong. Most of the time, we don't care which algorithms—SHA-256 or SHA-512, RSA or ECC, AES-128 or AES-256, padding schemes, iteration number, key sizes—are or aren't ideal for encryption, or if a poor choice could benefit attackers. In this technical session, we won't use complex math, and most of the concepts will be illustrated with source code, as we explore: - Broken cryptography - Libraries available for development - Hashing passwords and what people have been doing wrong - Usage of digital signatures - Protecting local data - How to properly exchange encryption keys - Securely sending data over the network - Preventing illegal tampering on client/server applications - SSL best practices - Cryptography in our daily basis

Java 9 comes to your doorstep with major changes for all of us, whether we ordered it or not. Modularity is the big theme of the Java 9 release, and it requires rethinking how we structure, build, and run Java applications. This is great, because who doesn't like more reliable and secure applications, meanwhile killing the dreaded classpath? Additionally, Java 9 has several other smaller, but useful, features, including support for HTTP 2 and collection factory methods. In this session, we'll dive deep into the module system and other new features. We'll review the basic concepts of modules and explore modularity patterns to enhance your design and development skills, and see examples of what else to expect in Java 9. We'll give plenty examples in this practical and code-driven presentation. You'll be ready for Java 9 before you know it.

Red Hat Software Collections, OpenShift and the Red Hat Container Development Kit open up many new possibilities for Python developers targeting Red Hat Enterprise Linux. At the same time, the wider Python ecosystem is undergoing two significant transitions - one being the ongoing migration from Python 2 to Python 3, and the other the shift to correctly validating HTTPS connections by default. In this session we will cover the currently available options for developing with Python on Red Hat platforms, as well as provide some insight into where things are headed in the context of the wider Python ecosystem.

The main consequence of the introduction of lambda expressions in Java 8 is the possibility of conveniently mixing the object-oriented and the functional paradigms. It's still uncommon to see functions used together with data in the business domain model. For example, it's usual to pass a list of data to a function that processes them, but there are cases when you may want to create a list of functions and pass a single data through all of them. Immutable objects leads to an inherently thread-safe domain model. Functions often compose better than objects. Side-effect-free code allows better reusability. In this session, we're: -- Not going to compare object-oriented and functional programming -- Are going to show how the two styles can be combined to take advantage of the good parts of each -- Going to look at practical examples to distill the essence of functional programming

Node.js is a very popular framework for developing asynchronous, event-driven, reactive applications. Red Hat JBoss Data Grid, an in-memory distributed database designed for fast access to large volumes of data and scalability, has recently gained compatibility with Node.js letting reactive applications use it as a persistence layer. Thanks to near caching, JBoss Data Grid offers excellent response times for data queried regularly, and its continuous remote event support means data can get pushed from the data grid to the Node.js application instead of having to wait for the data grid to serve it. In this session, we'll show how to build Node.js applications that use JBoss Data Grid as a persistence layer.

JBoss EAP7 brings support for the most recent industry standards and technologies, including Java EE7, the latest edition of the premier enterprise development standard. This session will provide an overview of the major additions to Java EE7, and how your team can use these capabilities on the advanced EAP7 runtime to produce better applications with less code.

In this session we'll introduce you to WildFly Swarm through the migration of TicketMonster from a Java EE monolith to Java EE microservices for parts of the stack. The services will be discoverable, provide failover with Netflix Ribbon, and utilize Netflix Hystrix for circuit breaking. TicketMonster, a full Java EE application, will be dissected into appropriate services while also retaining Java EE pieces that are appropriate. We'll then walk through several required aspects for a full services architecture. This will include securing these services with Keycloak; registering services for discovery via JGroups, Consul or Zookeeper; service logging to external sources such as logstash; and capturing service metrics with Hawkular and DropWizard Metrics. By the end of the session, we'll have converted some pieces of a Java EE application into services, while learning how WildFly Swarm integrates with external tools to provide a complete solution for service delivery.

In this session, we'll present an overview of Node.js with examples pertinent to Java developers who want to learn more about this Javascript environment. We'll discuss some design patterns of interest to Java developers and look at some live examples. The session will discuss enterprise-scale Node.js, and in particular, the use of microservices.

Thermostat is a Red Hat monitoring solution for middleware that lets you capture performance statistics from one or more Java deployments. In this session, we'll look at an extension to Thermostat that allows it to capture and present arbitrary application-specific data in a variety of different formats. By integrating Thermostat with Byteman, a tool that easily injects Java code almost anywhere in a running Java application, the Byteman-Thermostat integration package can gather simple data or statistics and pass them to the Thermostat back end. The back end automatically displays it in a suitable graphical format alongisde all other monitored statistics. Byteman supports un-injection and re-injection of code, making it possible to gather ad hoc statistics and tune in to specific, problematic behaviors. We'll mostly proceed by demonstrating Byteman and Thermostat in action—showing how to set up and run Thermostat with Byteman in place and providing examples of how to gather several interesting application-specific statistics from a sample Java deployment.