The document provides an overview of the Java EE 8 specification update including proposed enhancements and changes. Key points include:
- Servlet 4.0 will add support for HTTP/2 to improve performance. Other specifications like JAX-RS 2.1 and JSF 2.3 will be enhanced.
- Some originally planned specifications like JMS 2.1 and Java EE Management 2.0 may be dropped from Java EE 8.
- A "reboot" was conducted and the scope of some specs like Security 1.0 was expanded. New specifications around areas like health checking and configuration may be added.
- Specification groups are actively working on drafts and milestones for specs like CDI
Java EE 8 Presentation given at NYC Java SIG on May 4, 2017. This presentation provides the latest information on the forthcoming release of Java EE 8 in June.
JDK.IO 2016 (http://jdk.io)
Java EE 7 introduced a new batch processing API. This session will go over how to use the batch processing API introduced with Java EE 7. This API is makes it easy to implement long running data/compute intensive jobs which need to be scheduled or initiated on-demand. Basics of the API will be demonstrated via code samples. The API will also be compared to Spring Batching and Hadoop to provide context and guidance on when these technologies are appropriate.
In this session, we take a look at a handful of the features that will be part of the upcoming Java EE 8 release, as well as a few of the existing features that can be utilized in Java EE 7 today. Each of the features are presented via a recipe in the "Problem", "Solution", and "How it Works" format.
Jakarta EE is now over 20 years old and despite its age, it is as relevant today as it was back in 1999. It is one of the few open standards for developing enterprise applications with multiple independent vendor implementations. Its APIs are central to developing Java based cloud solutions. It is as relevant today as it was back in 1999. This presentation will provide context to Jakarta EE and why businesses choose to use it.
Node.js Development with Apache NetBeansRyan Cuprak
This session covers the basics of developing Node.js applications with NetBeans. NetBeans includes fully integrated support for both JavaScript and Node.js. You’ll get a tour of the features and learn how NetBeans can accelerate your projects. The presentation looks at basic code editing capabilities provided by the IDE, tool integration (npm/Grunt/Bower/Webpack), frameworks such as Express, and debugging capabilities. You’ll see why NetBeans is the best free JavaScript/Node.js IDE.
Java 9 ships in July, are you ready for Java 9 modules? Java 9 modules (aka Project Jigsaw) is the biggest fundamental change to the Java runtime. Code that use Oracle/Sun private APIs will break. This session will cover the basics of Java 9 modules and also the current state of tooling. The ramifications to existing and legacy applications will be covered along with the steps you’ll need to take to harness the power of modules and write more maintainable systems.
Java EE 8 Presentation given at NYC Java SIG on May 4, 2017. This presentation provides the latest information on the forthcoming release of Java EE 8 in June.
JDK.IO 2016 (http://jdk.io)
Java EE 7 introduced a new batch processing API. This session will go over how to use the batch processing API introduced with Java EE 7. This API is makes it easy to implement long running data/compute intensive jobs which need to be scheduled or initiated on-demand. Basics of the API will be demonstrated via code samples. The API will also be compared to Spring Batching and Hadoop to provide context and guidance on when these technologies are appropriate.
In this session, we take a look at a handful of the features that will be part of the upcoming Java EE 8 release, as well as a few of the existing features that can be utilized in Java EE 7 today. Each of the features are presented via a recipe in the "Problem", "Solution", and "How it Works" format.
Jakarta EE is now over 20 years old and despite its age, it is as relevant today as it was back in 1999. It is one of the few open standards for developing enterprise applications with multiple independent vendor implementations. Its APIs are central to developing Java based cloud solutions. It is as relevant today as it was back in 1999. This presentation will provide context to Jakarta EE and why businesses choose to use it.
Node.js Development with Apache NetBeansRyan Cuprak
This session covers the basics of developing Node.js applications with NetBeans. NetBeans includes fully integrated support for both JavaScript and Node.js. You’ll get a tour of the features and learn how NetBeans can accelerate your projects. The presentation looks at basic code editing capabilities provided by the IDE, tool integration (npm/Grunt/Bower/Webpack), frameworks such as Express, and debugging capabilities. You’ll see why NetBeans is the best free JavaScript/Node.js IDE.
Java 9 ships in July, are you ready for Java 9 modules? Java 9 modules (aka Project Jigsaw) is the biggest fundamental change to the Java runtime. Code that use Oracle/Sun private APIs will break. This session will cover the basics of Java 9 modules and also the current state of tooling. The ramifications to existing and legacy applications will be covered along with the steps you’ll need to take to harness the power of modules and write more maintainable systems.
Java EE 8 Web Frameworks: A Look at JSF vs MVCJosh Juneau
This session provides an overview of both the JSF and MVC 1.0 frameworks. The frameworks are then compared to each other. Finally, JSF 2.3 upcoming features are previewed.
Faster java ee builds with gradle [con4921]Ryan Cuprak
JavaOne 2016
It is time to move your Java EE builds over to Gradle! Gradle continues to gain momentum across the industry. In fact, Google is now pushing Gradle for Android development. Gradle draws on lessons learned from both Ant and Maven and is the next evolutionary step in Java build tools. This session covers the basics of switching existing Java EE projects (that use Maven) over to Gradle and the benefits you will reap, such as incremental compiling, custom distributions, and task parallelization. You’ll see demos of all the goodies you’ve come to expect, such as integration testing and leveraging of Docker. Switching is easier than you think, and no refactoring is required.
In this session we’ll highlight Microsoft’s open source offerings for Azure, and talk about how Java developers could benefit from using Azure services in their applications. The focus will be on real-world examples using Microsoft’s open source SDKs on GitHub and tools available for non-Microsoft developers, with a drill-down into our Java offerings and how they can enhance Java applications. We also want to gather feedback from attendees on some exciting new offerings designed to make it easier to deliver Java in the cloud.
===========================================================================
Brian Benz is a Senior Program Manager, focusing on Java at Microsoft. These days Brian spends his time helping Java developers and customers recognize the value and benefits of working on the Cloud with Microsoft Azure. Brian is a former Philly area resident and used to attend Philly JUG many years ago.
WebLogic 12.1.3 was released late last year. It brings a large set of changes including support for some key new Java EE 7 APIs such as WebSocket, JAX-RS 2, JSON-P and JPA 2.1, support for Java SE 8, WebSocket fallback support, support for Server-Sent Events (SSE), improved Maven support, enhanced REST administration support, Oracle Database 12c driver support and much, much more. In this session we will take a detailed tour of these features. In addition we will also cover updated WebLogic support in the Oracle Cloud, the new Oracle public Maven repository, using WebLogic with Arquillian for testing and well as official Docker support for WebLogic.
Towards the end of the session we will discuss what's coming in WebLogic 12.2.1 this year including full support for Java EE 7, multi-tenancy and more.
Changes in WebLogic 12.1.3 Every Administrator Must KnowBruno Borges
WebLogic 12c has evolved quite a lote since its first release (12.1.1). Now on 12.1.3 it has more to offer, optimizations for Exalogic, support of some Java EE 7 APIs and more.
Connecting to MySQL in Java via Connector/J. With High Availability feature in MySQL using Replication, Fabric or MySQL Cluster, There are different ways of usage in connector/J.
jDays2015 - JavaEE vs. Spring SmackdownMert Çalışkan
From the heavy weight authors of Wiley, on Java EE side Murat Yener with Professional Java EE Design Patterns (http://www.amazon.com/Professional-JavaEE-Design-Patterns-Murat/dp/111884341X) and on Spring side Mert Caliskan with Professional Spring (http://www.amazon.com/Beginning-Spring-Mert-Caliskan/dp/1118892925). The talk will expose good, bad and the ugly sides of both Java EE and Spring by hands on illustration of creating a crud app from scratch. Both speakers will introduce best parts of their platform on demos meanwhile point out weaknesses of the opponent. Both platforms will demonstrate their strengths on best practices, tool support, 3rd party libraries, community support and design patterns. Get ready for a family size huge fun while watching two most commonly used platform on Java.
Spring 3.1 to 3.2 in a Nutshell - Spring I/O 2012Sam Brannen
Spring 3.1 introduced several eagerly awaited features including bean definition profiles (a.k.a., environment-specific configuration), enhanced Java-based application and infrastructure configuration (a la XML namespaces), and a new cache abstraction. This session will provide attendees a high-level overview of these major new features plus a quick look at additional enhancements to the framework such as the new c: namespace for constructor arguments, support for Servlet 3.0, improvements to Spring MVC and REST, and Spring's new integration testing support for profiles and configuration classes. In addition, this talk will introduce new features under development in the Spring 3.2 roadmap.
With Java 9, modularity comes to your doorstep (whether you ordered it or not). This isn't your average language feature: making the most out of it may involve rewiring your brain. In this session we explore the benefits of a modular codebase using Java 9 modules. Because who doesn’t like more reliable and secure applications, meanwhile killing the dreaded classpath?
After reviewing the basic concepts of modules, we'll explore modularity patterns that enhance your design and development skills. We all have existing software, so migration of codebases to a modular world is an important topic as well. Automatic modules and other new concepts are added to your toolbox to this end.
Want examples? We've got plenty in this practical and code-driven talk. Even if you intend to use Java 9 without modules, this talk helps you prevent common issues. You'll be ready for Java 9 before you know it.
Both speakers are currently writing “Java 9 Modularity” for O’Reilly, expected early 2017. They have extensive experience under the belt already with the Java 9 Jigsaw early access builds.
Migrating a JSF-Based Web Application from Spring 3 to Java EE 7 and CDIMario-Leander Reimer
This talk is a detailed case study about the migration of a JSF-based web application from Spring 3 to Java EE 7 and CDI. It is presented at the JavaOne 2014 conference.
At first sight this didn’t seem to be too difficult. Both technologies are based on similar concepts and provide similar mechanisms for dependency injection (DI). So migrating pure annotation based bean wiring from Spring to CDI was obvious and straight forward.
But the deeper we looked into the source code the more Spring specific code we found with no direct and easy mapping in neither of JEE7, EJB3 or CDI available. Some of the problems and challenges we were confronted with were:
- How to migrate XML based bean wirings?
- How to migrate FactoryBeans?
- How to migrate AspectJ based AOP proxies?
- How to implement Spring profiles for environment based wiring?
- How to implement custom bean scopes?
- How to implement custom Spring XML schema notations and wiring?
- How to migrate code that is built against Spring APIs?
- How to migrate unit test based on Spring Test?
To answer these questions the talk will present the patterns and strategies used to map, transform and migrate the different concepts from Spring 3 to JEE7with CDI. The talk will discuss the changes and implications of the migration on the system’s architecture.
CDI portable extensions are one of greatest features of Java EE allowing the platform to be extended in a clean and portable way. But allowing extension is just part of the story. CDI opens the door to a whole new eco-system for Java EE, but it’s not the role of the specification to create these extensions.
Apache DeltaSpike is the project that leads this brand new eco-system by providing useful extension modules for CDI applications as well as tools to ease the creation of new ones.
In this session, we’ll start by presenting the DeltaSpike toolbox and show how it helps you to develop for CDI. Then we’ll describe the major extensions included in DeltaSpike, including 'configuration', 'scheduling' and 'data'.
Top 50 java ee 7 best practices [con5669]Ryan Cuprak
JavaOne 2016
This session provides 50 best practices for Java EE 7, with examples. The best practices covered focus primarily on JPA, CDI, JAX-WS, and JAX-RS. In addition, topics involving testing and deployment are covered. This presentation points out where best practices have changed, common misconceptions, and antipatterns that should be avoided. This is a fast-paced presentation with many code samples.
Configuration for Java EE: Config JSR and TamayaDmitry Kornilov
Slides from our joint talk with Werner Keil about configuration proposal for Java EE and Tamaya we've done on 16 Mov 2016 in Sofia on Java2Days conference.
Java EE 8 Web Frameworks: A Look at JSF vs MVCJosh Juneau
This session provides an overview of both the JSF and MVC 1.0 frameworks. The frameworks are then compared to each other. Finally, JSF 2.3 upcoming features are previewed.
Faster java ee builds with gradle [con4921]Ryan Cuprak
JavaOne 2016
It is time to move your Java EE builds over to Gradle! Gradle continues to gain momentum across the industry. In fact, Google is now pushing Gradle for Android development. Gradle draws on lessons learned from both Ant and Maven and is the next evolutionary step in Java build tools. This session covers the basics of switching existing Java EE projects (that use Maven) over to Gradle and the benefits you will reap, such as incremental compiling, custom distributions, and task parallelization. You’ll see demos of all the goodies you’ve come to expect, such as integration testing and leveraging of Docker. Switching is easier than you think, and no refactoring is required.
In this session we’ll highlight Microsoft’s open source offerings for Azure, and talk about how Java developers could benefit from using Azure services in their applications. The focus will be on real-world examples using Microsoft’s open source SDKs on GitHub and tools available for non-Microsoft developers, with a drill-down into our Java offerings and how they can enhance Java applications. We also want to gather feedback from attendees on some exciting new offerings designed to make it easier to deliver Java in the cloud.
===========================================================================
Brian Benz is a Senior Program Manager, focusing on Java at Microsoft. These days Brian spends his time helping Java developers and customers recognize the value and benefits of working on the Cloud with Microsoft Azure. Brian is a former Philly area resident and used to attend Philly JUG many years ago.
WebLogic 12.1.3 was released late last year. It brings a large set of changes including support for some key new Java EE 7 APIs such as WebSocket, JAX-RS 2, JSON-P and JPA 2.1, support for Java SE 8, WebSocket fallback support, support for Server-Sent Events (SSE), improved Maven support, enhanced REST administration support, Oracle Database 12c driver support and much, much more. In this session we will take a detailed tour of these features. In addition we will also cover updated WebLogic support in the Oracle Cloud, the new Oracle public Maven repository, using WebLogic with Arquillian for testing and well as official Docker support for WebLogic.
Towards the end of the session we will discuss what's coming in WebLogic 12.2.1 this year including full support for Java EE 7, multi-tenancy and more.
Changes in WebLogic 12.1.3 Every Administrator Must KnowBruno Borges
WebLogic 12c has evolved quite a lote since its first release (12.1.1). Now on 12.1.3 it has more to offer, optimizations for Exalogic, support of some Java EE 7 APIs and more.
Connecting to MySQL in Java via Connector/J. With High Availability feature in MySQL using Replication, Fabric or MySQL Cluster, There are different ways of usage in connector/J.
jDays2015 - JavaEE vs. Spring SmackdownMert Çalışkan
From the heavy weight authors of Wiley, on Java EE side Murat Yener with Professional Java EE Design Patterns (http://www.amazon.com/Professional-JavaEE-Design-Patterns-Murat/dp/111884341X) and on Spring side Mert Caliskan with Professional Spring (http://www.amazon.com/Beginning-Spring-Mert-Caliskan/dp/1118892925). The talk will expose good, bad and the ugly sides of both Java EE and Spring by hands on illustration of creating a crud app from scratch. Both speakers will introduce best parts of their platform on demos meanwhile point out weaknesses of the opponent. Both platforms will demonstrate their strengths on best practices, tool support, 3rd party libraries, community support and design patterns. Get ready for a family size huge fun while watching two most commonly used platform on Java.
Spring 3.1 to 3.2 in a Nutshell - Spring I/O 2012Sam Brannen
Spring 3.1 introduced several eagerly awaited features including bean definition profiles (a.k.a., environment-specific configuration), enhanced Java-based application and infrastructure configuration (a la XML namespaces), and a new cache abstraction. This session will provide attendees a high-level overview of these major new features plus a quick look at additional enhancements to the framework such as the new c: namespace for constructor arguments, support for Servlet 3.0, improvements to Spring MVC and REST, and Spring's new integration testing support for profiles and configuration classes. In addition, this talk will introduce new features under development in the Spring 3.2 roadmap.
With Java 9, modularity comes to your doorstep (whether you ordered it or not). This isn't your average language feature: making the most out of it may involve rewiring your brain. In this session we explore the benefits of a modular codebase using Java 9 modules. Because who doesn’t like more reliable and secure applications, meanwhile killing the dreaded classpath?
After reviewing the basic concepts of modules, we'll explore modularity patterns that enhance your design and development skills. We all have existing software, so migration of codebases to a modular world is an important topic as well. Automatic modules and other new concepts are added to your toolbox to this end.
Want examples? We've got plenty in this practical and code-driven talk. Even if you intend to use Java 9 without modules, this talk helps you prevent common issues. You'll be ready for Java 9 before you know it.
Both speakers are currently writing “Java 9 Modularity” for O’Reilly, expected early 2017. They have extensive experience under the belt already with the Java 9 Jigsaw early access builds.
Migrating a JSF-Based Web Application from Spring 3 to Java EE 7 and CDIMario-Leander Reimer
This talk is a detailed case study about the migration of a JSF-based web application from Spring 3 to Java EE 7 and CDI. It is presented at the JavaOne 2014 conference.
At first sight this didn’t seem to be too difficult. Both technologies are based on similar concepts and provide similar mechanisms for dependency injection (DI). So migrating pure annotation based bean wiring from Spring to CDI was obvious and straight forward.
But the deeper we looked into the source code the more Spring specific code we found with no direct and easy mapping in neither of JEE7, EJB3 or CDI available. Some of the problems and challenges we were confronted with were:
- How to migrate XML based bean wirings?
- How to migrate FactoryBeans?
- How to migrate AspectJ based AOP proxies?
- How to implement Spring profiles for environment based wiring?
- How to implement custom bean scopes?
- How to implement custom Spring XML schema notations and wiring?
- How to migrate code that is built against Spring APIs?
- How to migrate unit test based on Spring Test?
To answer these questions the talk will present the patterns and strategies used to map, transform and migrate the different concepts from Spring 3 to JEE7with CDI. The talk will discuss the changes and implications of the migration on the system’s architecture.
CDI portable extensions are one of greatest features of Java EE allowing the platform to be extended in a clean and portable way. But allowing extension is just part of the story. CDI opens the door to a whole new eco-system for Java EE, but it’s not the role of the specification to create these extensions.
Apache DeltaSpike is the project that leads this brand new eco-system by providing useful extension modules for CDI applications as well as tools to ease the creation of new ones.
In this session, we’ll start by presenting the DeltaSpike toolbox and show how it helps you to develop for CDI. Then we’ll describe the major extensions included in DeltaSpike, including 'configuration', 'scheduling' and 'data'.
Top 50 java ee 7 best practices [con5669]Ryan Cuprak
JavaOne 2016
This session provides 50 best practices for Java EE 7, with examples. The best practices covered focus primarily on JPA, CDI, JAX-WS, and JAX-RS. In addition, topics involving testing and deployment are covered. This presentation points out where best practices have changed, common misconceptions, and antipatterns that should be avoided. This is a fast-paced presentation with many code samples.
Configuration for Java EE: Config JSR and TamayaDmitry Kornilov
Slides from our joint talk with Werner Keil about configuration proposal for Java EE and Tamaya we've done on 16 Mov 2016 in Sofia on Java2Days conference.
JavaOne 2016
JMS is pretty simple, right? Once you’ve mastered topics and queues, the rest can appear trivial, but that isn’t the case. The queuing system, whether ActiveMQ, OpenMQ, or WebLogic JMS, provides many more features and settings than appear in the Java EE documentation. This session looks at some of the important extended features and configuration settings. What would you need to optimize if your messages are large or you need to minimize prefetching? What is the best way to implement time-delayed messages? The presentation also looks at dangerous bugs that can be introduced via simple misconfigurations with pooled beans. The JMS APIs are deceptively simple, but getting an implementation into production and tuned correctly can be a bit trickier.
Hybrid Mobile Development with Apache Cordova and Java EE 7 (JavaOne 2014)Ryan Cuprak
Java EE 7 provides a strong foundation for developing the back end for your HTML5 mobile applications. This heavily code-driven session shows you how you can effectively utilize Java EE 7 as a back end for your Apache Cordova mobile applications. The session demonstrates Java EE 7 technologies such as JAX-RS 2.0, WebSocket, JSON-P, CDI, and Bean Validation. It provides an overview of the basics of Apache Cordova as well as the tooling support added in NetBeans 8. The session also demonstrates an integrated approach to rapidly developing HTML5 mobile applications with Java EE 7 and NetBeans and concludes with best practices and pitfalls.
Updates to the java api for json processing for java ee 8Alex Soto
One of the additions of Java EE 7 was the JSON-P specification for processing JSON documents. But JSON-P spec is moving forward and for Java EE 8 it will come with a lot of new features like support for JSON Pointer (RFC6901), JSON Patch (RFC6902) or JSON Merge Patch (RFC7386). But also improvements on performance, Java 8 integration and how to process big JSON data.
The first part of this session presents the JSON Processing API that comes with Java EE 7 to understand the basis for improvements of next version. The second part of the session presents the updates that are coming on the Java API for JSON Processing that they will be added inside Java EE 8.
Java script nirvana in netbeans [con5679]Ryan Cuprak
JavaOne 2016
NetBeans is not just a Java IDE. It supports JavaScript as a first-class citizen and provides a complete integrated development environment. It also provides project types for server-side JavaScript (Node.js) as well as web browsers and mobile (Apache Cordova). In addition, it supports Grunt, Mocha and Selenium, Angular and Knockout, and more. This session provides an update on NetBeans 8.1 and demonstrates the top new JavaScript features. You will see a Node.js application in action, look at the support for JavaScript unit testing, and also see how easy it is to debug an Apache Cordova application running on a tethered iPhone.
Kotlin is a statically-typed programming language for the JVM and the browser, built by a team at JetBrains and designed as a pragmatic and easy-to-use Java alternative. In this presentation we'll explore the most notable Kotlin features, such as:
- Extension functions
- Null-safety
- Smart casts
- and many more
Check out and see that programming in Kotlin is fun!
A modern web browser supports a surprising number of protocols designed for fast, efficient, and secure communication. Even though some goals of these protocols might overlap, their features are different enough to make them all worth our attention. This session focuses on HTTP/2, SSE, and WebSocket. It is based on experience gained during development of popular Jersey and Tyrus libraries. It explains all mentioned protocols and compares them, in both theory and practice, using java-based examples.
Youtube: https://www.youtube.com/watch?v=G4V3b_z5TVk
Configuring and maintaining a continuous integration environment is quite a bit of work. It requires ongoing resources both in terms of manpower and hardware infrastructure. As an application evolves so does the number of ongoing projects. The challenge is creating a scalable continuous integration environment which does not impede development and can handle the complexities of Java EE testing. This session covers how to setup and configure a cloud-based continuous integration environment for Java EE applications.
The presentation will focus on demonstrating how to use Atlassian Bamboo running on AWS to build and test a Maven/Gradle Java EE project that uses Arquillian for testing. Topics that will be covered include creating a custom AWS VM for use with Bamboo, creating an Amazon VPC (Virtual Private Cloud) along with test database using Amazon RDS. The presentation will delve into the specifics of testing EJBs, WebSocket endpoints, RESTful web services, as well as performing load testing in this environment. Security, cost control, and build monitoring will be covered as well.
This presentation takes a pragmatic approach to comparing JavaFX and HTML5, using an application written in JavaFX versus the same functionality written in HTML5 to illustrate the pros and cons of each.
Combining R With Java For Data Analysis (Devoxx UK 2015 Session)Ryan Cuprak
Java is a general-purpose language and is not particularly well suited for performing statistical analysis. Special languages and software environments have been created by and for statisticians to use. Statisticians think about programming and data analysis much different from Java programmers. These languages and tools make it easy to perform very sophisticated analyses on large data sets easily. Tools, such as R and SAS, contain a large toolbox of statistical tools that are well tested, documented and validated. For data analysis you want to use these tools.
In this session we will provide an overview of how to leverage the power of R from Java. R is the leading open source statistical package/language/environment. The first part of the presentation will provide an overview of R focusing on the differences between R and Java at the language level. We’ll also look at some of the basic and more advanced tests to illustrate the power of R. The second half of the presentation will cover how to integrate R and Java using rJava. We’ll look at leverage R from the new Java EE Batching (JSR 352) to provide robust statistical analysis for enterprise applications.
A look at trends in mobile banking and whether a mobile app or mobile website makes more sense.
Lots of data from the Federal Reserve's March 2012 study.
Reactive Java EE - Let Me Count the Ways!Reza Rahman
As our industry matures there are pockets of increased demand for high-throughput, low-latency systems heavily utilizing event-driven programming and asynchronous processing. This trend is gradually converging on the somewhat well established but so-far not well understood term "Reactive".
This session explores how vanilla Java SE and Java EE aligns with this movement via features and APIs like JMS, MDB, EJB @Asynchronous, JAX-RS/Servlet/WebSocket async, CDI events, Java EE concurrency utilities and so on. We will also see how these robust facilities can be made digestible even in the most complex cases for mere mortal developers through Java SE 8 Lambdas and Completable Futures.
Java EE 8 Overview (Sept 2015). A lot of work is already done by the Expert Groups so lets have a brief look for what we can expect in the some areas.
- Servlet 4 will embrace the new HTTP/2 protocol.
- JSON-B will bring the same high level features of JAXB to the JSON data format.
- Server-Sent Events(SSE) is the WebSocket variant where you only send data from the server to the client.
- MVC will be the Action based MVC complement of the Component based MVC of JSF.
- Some major restructuring of CDI so that we can use it standardised in Java SE to mention one thing.
The Java EE security API will be covered in more detail. Security related things became old and dusty and needs to move away from proprietary configuration to be able to make the transition to the cloud. An introduction to JSR 375 is given, which promotes self-contained application portability across Java EE servers, and promotes the use of modern programming concepts such as Expression Language, and CDI. It will holistically attempt to simplify, standardize, and modernize the Security API across the platform in areas identified by the community.
Overview of Java EE 6 by Roberto Chinnici at SFJUGMarakana Inc.
Roberto Chinnici, Java EE 6 spec lead, gives an overview of Java EE 6 for San Francisco Java User Group on August 10th, 2010.
http://www.sfjava.org/calendar/13940755/
What’s new in Java SE, EE, ME, Embedded world & new StrategyMohamed Taman
In this presentation, I have presented the history of Java EE from v1.0 to our latest Java EE 7.0, what is new and a brief introduction to each minor and major change to existing JSRs, and new JSRs with code to show simplifications and enhancements.
Also talked about our future Java EE 8 components alongside JDK 8 with major updates and JSRs, profiling concepts and more.
In addition, I have explained the IoT concepts with demo. Intro to the importance of Java Embedded systems world. With intro to Raspberry Pi and dukePad.
Agenda:
http://egjug.org/page/java_ee_7_8_and_beyond
In this presentation I will go through latest features being added in Spring 3.1/3.2 one more time and also will try to look behind the scene on what new features are comming in Spring 4 which should be released at the end of this year.
Mumbai Academics is Mumbai’s first dedicated Professional Training Center for Training with Spoke and hub model with Multiple verticles . The strong foundation of Mumbai Academics is laid by highly skilled and trained Professionals, carrying mission to provide industry level input to the freshers and highly skilled and trained Software Professionals/other professional to IT companies.
Embracing Jakarta EE 10 not only enable you to write better structured applications, it also enables you to write more testable applications. Correctly leveraging CDI enables integration testing where you can simulate a database error and verify that JMS messages are lost due to a RuntimeException. This session will focus on strategies and techniques for testing message handing, transaction management, security, and data model integrity. You will see how you can check message delivery and error handling, session failover, database versioning, and two-phase commits with JMS and databases. All too often assumptions are made that are proven wrong in production. This session will show you how to take your testing to the next level.
DIY Home Weather Station (Devoxx Poland 2023)Ryan Cuprak
Weather is a fascinating and important aspect of our lives, and with the rise of smart home technology, it has become easier than ever to track and monitor weather conditions in your own backyard. In this presentation, I will explore the process of building a home weather station.
I will discuss the hardware components needed to build a weather station, including sensors for temperature, humidity, pressure, and precipitation, as well as the embedded board itself. I will also cover the programming aspect of the project, including how to read data from the sensors and transmit it wirelessly to the cloud.
By the end of this presentation, you will have a solid understanding of how to build and program a home weather station using Arduino, and how to customize and expand the project to fit your specific needs.
The new GraalVM from Oracle supports multiple language including JavaScript, Python, Ruby, R, C++ as well as Java and other JVM languages. This opens up interesting possibilities for polygot enterprise applications. Now you can use a Node library in a Java application or call an R statistical function from an EJB. Previously, this type of integration was extremely challenging. This session will provide recipes to get up and running along with best practices and some cool demos.
Code: https://github.com/rcuprak/graalvm_jee
Exploring Java Heap Dumps (Oracle Code One 2018)Ryan Cuprak
Memory leaks are not always simple or easy to find. Heap dumps from production systems are often gigantic (4+ gigs) with millions of objects in memory. Simple spot checking with traditional tools is woefully inadequate in these situations, especially with real data. Leaks can be entire object graphs with enormous amounts of noise. This session will show you how to build custom tools using the Apache NetBeans Profiler/Heapwalker APIs. Using these APIs, you can read and analyze Java heaps programmatically to ask really hard questions. This gives you the power to analyze complex object graphs with tens of thousands of objects in seconds.
50 EJB 3 Best Practices in 50 Minutes - JavaOne 2014Ryan Cuprak
This session provides 50 best practices for EJB 3 in 50 minutes with examples. These best practices involve not only EJB 3.2 but also its integration with other Java EE 7 technologies, not only coding best practices but also testing and production practices. The presentation targets Java EE 7 and also points out where best practices have changed, what patterns you should embrace, and antipatterns to avoid. This is a fast-paced presentation with many code samples. Categories covered include configuration, JPA, concurrency, testing, performance tuning, exception handling, CDI integration, JMS queue patterns, pattern changes, and many more.
Quarkus Hidden and Forbidden ExtensionsMax Andersen
Quarkus has a vast extension ecosystem and is known for its subsonic and subatomic feature set. Some of these features are not as well known, and some extensions are less talked about, but that does not make them less interesting - quite the opposite.
Come join this talk to see some tips and tricks for using Quarkus and some of the lesser known features, extensions and development techniques.
AI Pilot Review: The World’s First Virtual Assistant Marketing SuiteGoogle
AI Pilot Review: The World’s First Virtual Assistant Marketing Suite
👉👉 Click Here To Get More Info 👇👇
https://sumonreview.com/ai-pilot-review/
AI Pilot Review: Key Features
✅Deploy AI expert bots in Any Niche With Just A Click
✅With one keyword, generate complete funnels, websites, landing pages, and more.
✅More than 85 AI features are included in the AI pilot.
✅No setup or configuration; use your voice (like Siri) to do whatever you want.
✅You Can Use AI Pilot To Create your version of AI Pilot And Charge People For It…
✅ZERO Manual Work With AI Pilot. Never write, Design, Or Code Again.
✅ZERO Limits On Features Or Usages
✅Use Our AI-powered Traffic To Get Hundreds Of Customers
✅No Complicated Setup: Get Up And Running In 2 Minutes
✅99.99% Up-Time Guaranteed
✅30 Days Money-Back Guarantee
✅ZERO Upfront Cost
See My Other Reviews Article:
(1) TubeTrivia AI Review: https://sumonreview.com/tubetrivia-ai-review
(2) SocioWave Review: https://sumonreview.com/sociowave-review
(3) AI Partner & Profit Review: https://sumonreview.com/ai-partner-profit-review
(4) AI Ebook Suite Review: https://sumonreview.com/ai-ebook-suite-review
Unleash Unlimited Potential with One-Time Purchase
BoxLang is more than just a language; it's a community. By choosing a Visionary License, you're not just investing in your success, you're actively contributing to the ongoing development and support of BoxLang.
Understanding Globus Data Transfers with NetSageGlobus
NetSage is an open privacy-aware network measurement, analysis, and visualization service designed to help end-users visualize and reason about large data transfers. NetSage traditionally has used a combination of passive measurements, including SNMP and flow data, as well as active measurements, mainly perfSONAR, to provide longitudinal network performance data visualization. It has been deployed by dozens of networks world wide, and is supported domestically by the Engagement and Performance Operations Center (EPOC), NSF #2328479. We have recently expanded the NetSage data sources to include logs for Globus data transfers, following the same privacy-preserving approach as for Flow data. Using the logs for the Texas Advanced Computing Center (TACC) as an example, this talk will walk through several different example use cases that NetSage can answer, including: Who is using Globus to share data with my institution, and what kind of performance are they able to achieve? How many transfers has Globus supported for us? Which sites are we sharing the most data with, and how is that changing over time? How is my site using Globus to move data internally, and what kind of performance do we see for those transfers? What percentage of data transfers at my institution used Globus, and how did the overall data transfer performance compare to the Globus users?
OpenFOAM solver for Helmholtz equation, helmholtzFoam / helmholtzBubbleFoamtakuyayamamoto1800
In this slide, we show the simulation example and the way to compile this solver.
In this solver, the Helmholtz equation can be solved by helmholtzFoam. Also, the Helmholtz equation with uniformly dispersed bubbles can be simulated by helmholtzBubbleFoam.
Code reviews are vital for ensuring good code quality. They serve as one of our last lines of defense against bugs and subpar code reaching production.
Yet, they often turn into annoying tasks riddled with frustration, hostility, unclear feedback and lack of standards. How can we improve this crucial process?
In this session we will cover:
- The Art of Effective Code Reviews
- Streamlining the Review Process
- Elevating Reviews with Automated Tools
By the end of this presentation, you'll have the knowledge on how to organize and improve your code review proces
TROUBLESHOOTING 9 TYPES OF OUTOFMEMORYERRORTier1 app
Even though at surface level ‘java.lang.OutOfMemoryError’ appears as one single error; underlyingly there are 9 types of OutOfMemoryError. Each type of OutOfMemoryError has different causes, diagnosis approaches and solutions. This session equips you with the knowledge, tools, and techniques needed to troubleshoot and conquer OutOfMemoryError in all its forms, ensuring smoother, more efficient Java applications.
Enhancing Research Orchestration Capabilities at ORNL.pdfGlobus
Cross-facility research orchestration comes with ever-changing constraints regarding the availability and suitability of various compute and data resources. In short, a flexible data and processing fabric is needed to enable the dynamic redirection of data and compute tasks throughout the lifecycle of an experiment. In this talk, we illustrate how we easily leveraged Globus services to instrument the ACE research testbed at the Oak Ridge Leadership Computing Facility with flexible data and task orchestration capabilities.
Globus Compute wth IRI Workflows - GlobusWorld 2024Globus
As part of the DOE Integrated Research Infrastructure (IRI) program, NERSC at Lawrence Berkeley National Lab and ALCF at Argonne National Lab are working closely with General Atomics on accelerating the computing requirements of the DIII-D experiment. As part of the work the team is investigating ways to speedup the time to solution for many different parts of the DIII-D workflow including how they run jobs on HPC systems. One of these routes is looking at Globus Compute as a way to replace the current method for managing tasks and we describe a brief proof of concept showing how Globus Compute could help to schedule jobs and be a tool to connect compute at different facilities.
May Marketo Masterclass, London MUG May 22 2024.pdfAdele Miller
Can't make Adobe Summit in Vegas? No sweat because the EMEA Marketo Engage Champions are coming to London to share their Summit sessions, insights and more!
This is a MUG with a twist you don't want to miss.
Climate Science Flows: Enabling Petabyte-Scale Climate Analysis with the Eart...Globus
The Earth System Grid Federation (ESGF) is a global network of data servers that archives and distributes the planet’s largest collection of Earth system model output for thousands of climate and environmental scientists worldwide. Many of these petabyte-scale data archives are located in proximity to large high-performance computing (HPC) or cloud computing resources, but the primary workflow for data users consists of transferring data, and applying computations on a different system. As a part of the ESGF 2.0 US project (funded by the United States Department of Energy Office of Science), we developed pre-defined data workflows, which can be run on-demand, capable of applying many data reduction and data analysis to the large ESGF data archives, transferring only the resultant analysis (ex. visualizations, smaller data files). In this talk, we will showcase a few of these workflows, highlighting how Globus Flows can be used for petabyte-scale climate analysis.
Gamify Your Mind; The Secret Sauce to Delivering Success, Continuously Improv...Shahin Sheidaei
Games are powerful teaching tools, fostering hands-on engagement and fun. But they require careful consideration to succeed. Join me to explore factors in running and selecting games, ensuring they serve as effective teaching tools. Learn to maintain focus on learning objectives while playing, and how to measure the ROI of gaming in education. Discover strategies for pitching gaming to leadership. This session offers insights, tips, and examples for coaches, team leads, and enterprise leaders seeking to teach from simple to complex concepts.
Navigating the Metaverse: A Journey into Virtual Evolution"Donna Lenk
Join us for an exploration of the Metaverse's evolution, where innovation meets imagination. Discover new dimensions of virtual events, engage with thought-provoking discussions, and witness the transformative power of digital realms."
In 2015, I used to write extensions for Joomla, WordPress, phpBB3, etc and I ...Juraj Vysvader
In 2015, I used to write extensions for Joomla, WordPress, phpBB3, etc and I didn't get rich from it but it did have 63K downloads (powered possible tens of thousands of websites).
Cyaniclab : Software Development Agency Portfolio.pdfCyanic lab
CyanicLab, an offshore custom software development company based in Sweden,India, Finland, is your go-to partner for startup development and innovative web design solutions. Our expert team specializes in crafting cutting-edge software tailored to meet the unique needs of startups and established enterprises alike. From conceptualization to execution, we offer comprehensive services including web and mobile app development, UI/UX design, and ongoing software maintenance. Ready to elevate your business? Contact CyanicLab today and let us propel your vision to success with our top-notch IT solutions.
2. Agenda
• Java EE 8 specification overview and current status
• Example of proposed enhancements
• JavaOne 2016 Java EE Reboot
• How to get involved and help
3. Importance of Java EE
https://javaee-guardians.io/java-ee-adoption-surveys
6. Java EE: Past, Present, Future
J2EE 1.2
Servlet,
JSP,
EJB,
JMS,
RMI
J2EE 1.3
CMP,
JCA
J2EE 1.4
Web
Services,
Mgmt,
Deploy
Java EE 5
Ease of
Use,
EJB 3,
JPA, JSF,
JAXB,
JAX-WS
Java EE 6
Pruning,
Ease of
Use,
JAX-RS,
CDI,
Bean-
ValidationWeb Profile
Servlet 3,
EJB 3.1 Lite
Java EE 7
JMS 2,
Batch, TX,
Concurrency
Web-
Sockets,
JSON
Java EE 8
SERVLET 4,
JSON-B,
JSON-P 1.1,
JSF 2.3, CDI
2.0, JAX-
RS 2.1,
SECURITY
7. Java EE 8 Community Survey
https://java.net/downloads/javaee-spec/JavaEE8_Community_Survey_Results.pdf
https://blogs.oracle.com/ldemichiel/entry/results_from_the_java_ee
8. Java EE 8 Overview – Original Plan
• Continued Enhancements for Web Standards Alignment
• HTTP/2, JSON Binding, JSON-P, MVC
• Cloud enhancements
• Security, RESTful Management API
• CDI Programming Model
• Ease of use, EJB via CDI
• Smaller, but Important Features
• Caching, Better Messaging
• Alignment with Java SE 8
15. Servlet 4.0
• Principal goal to support HTTP/2
• Request/response multiplexing over single connection
• Transparent to most developers, although possibly slight
changes to the Servlet API
• Most affected: frameworks
JSR 369
16. Servlet 4.0 – Exposing HTTP./2
• Stream Prioritization
• New Priority class
• Enhance HttpServletRequest and HttpServletResponse to
accommodate
• Server Push
• Frameworks can push resources to the client
• Not replacing WebSockets
JSR 369
17. Servlet 4.0 - HttpClient API
• Plans to provide easy to use API
• Target HttpClient in Java 9
• Support both HTTP/1.1 and 2
• Builds on existing Java API Classes
JSR 368
18. JMS 2.1 Asynchronous Batches
Example:
@MessageDriven
public class MyFlexibleMDB {
@JMSQueueListener(destinationLookup="java:global/
myQueue")
public void myMessageCallback(@Batch(maxSize=10,timeout=
1000) Message[] messages) {
...
}
JSR 368
20. JAX-RS 2.1
• JSR 370 - In Early Stages
• No builds available for testing.
• Reboot: Add Circuit Breaker support
JSR 370
Expert Group
Activity
21. JAX-RS 2.1
• Hypermedia API
• Reactive API
• Security API
• Support for SSE (Server Sent Events)
• Improved CDI Integration
• Support for Non-Blocking IO in Providers
JSR 370
22. JAX-RS 2.1
• Conditional JAXB on Runtimes
• Integration with JSON-B
• Support for CDI in Java SE
JSR 370
23. JSF 2.3
• JSR 372 - in active progress
• Milestones available for testing
• Read, Test, Supply Feedback
JSR 372
Emails from
Oracle spec
leads
26. JSF 2.3 Enhanced CDI Integration
• Wider Support of Injection into JSF Artifacts
• javax.faces.convert.Converter
• javax.faces.validator.Validator
• javax.faces.component.behavior.Behavior
• Upgraded to CDI qualifiers
JSR 372
27. CDI 2.0
• JSR 365 - in active progress
• Early draft review 2 published August 2016
• Test Releases of Reference Implementation
http://weld.cdi-spec.org/news/
JSR 374
28. CDI 2.0
• Java SE Bootstrap
• XML Configuration
• Asynchronous Events
• @Startup for CDI Beans
• Portable Extension SPI Simplification
• Small features and enhancements
JSR 374
29. CDI 2.0
Workshop Status Description
Parts API was split Working on modularity (sub specs)
Events Finished Enhance events (asynchronous,
ordering,etc… )
AOP Started Interceptors & Decoractors enhancement
Java SE First part done Boostrap CDI in Java SE
JDK 8 Started Enhancements from Java 8
SPI Not Started more open SPI for 3rd party
Contexts Not Started Provide a way to start/stop contexts for SE
mode
JSR 374
31. CDI 2.0 @Schedule Outside EJB
@ApplicationScoped
public class MyScheduledBean {
...
@Schedule(...)
public void myScheduledTask() { ... }
}
@ApplicationScoped
@Stereotype
@Retention(RUNTIME)
@Target(TYPE)
@Schedule(...)
public @interface MonthlyTask {}
JSR 365
32. JSON-P 1.1
• JSR 374 - In Early Draft Review
• More Information:
• https://json-processing-spec.java.net/
• Sources: https://java.net/projects/jsonp
JSR 374
33. JSON-P 1.1
• Updates to new API in Java EE 7
• New JSON Standards
• JSON-Pointer and JSON-Patch
• Editing Operations on JSON objects and arrays
• Helper Classes and Enhanced Java SE 8 support
JSR 374
34. JSON-P 1.1 Java SE 8 Support
• Java 8 Stream Support
• JsonArray persons;
persons.getValuesAs(JsonObject.class).stream()
.filter(x->x.getString(“age”) >= 65)
.forEach(System.out.println(x.getString(“name”)));
JSR 374
36. JSON-P 1.1: JSON-Patch
public void
shouldBuildJsonPatchExpressionUsingJsonPatchBuilder() {
JsonPatchBuilder patchBuilder = new JsonPatchBuilder();
JsonObject result = patchBuilder.add("/email",
"john@example.com")
.replace("/age", 30)
.remove("/phoneNumber")
.test("/firstName", "John")
.copy("/address/lastName", "/lastName")
.apply(buildPerson());
}
JSR 374
37. Java EE Management API 2.0
• Oracle proposing to drop JSR from EE 8.
• Currently working on Early Draft
• Java EE Management API 1.0 – released 2002
• Join mailing list of JSR 373
JSR 373
38. Java EE Management API 2.0
• REST Based Interface to Supersede EJB Management
APIs of JSR 77
• Monitoring and deployment
• SSE for Event Support (WebSockets also under
consideration)
JSR 373
39. Bean Validation 2.0
• Add support for LocalTime, Optional, etc.
• Leverage type annotation, repeatable annotations,
reflective parameter name retrieval
• Potential enhancements:
• Customized constraint validations
• Object graph validation
• Example:
List<@Email String> emails;
JSR 380
41. MVC
• Model - View - Controller
• JSR 371
• Active Progress…download milestones
• Ozark: https://ozark.java.net/
JSR 371
42. MVC
• Action-Based Web Framework for Java EE
• Follows suit of Spring MVC or Apache Struts
• Does Not Replace JSF
• Model: CDI, Bean Validation, JPA
• View: Facelets, JSP (Extensible)
• Controller: Layered on top of JAX-RS
JSR 371
45. JSON-B
• Java API for JSON Binding
• JSR 367 - Public Review
• Read the spec, start testing:
https://java.net/projects/jsonb-spec/pages/Home
JSR 367
46. JSON-B Next Logical Step
• Standardize means of converting JSON to Java objects
and vice versa
• Default mapping algorithm for converting Java classes
• Draw from best of breed ideas in existing JSON binding
solutions
• Provide JAX-RS a standard way to support
“application/json” for POJOs
• JAX-RS currently supports JSON-P
JSR 367
47. JSON-B Mapping
@Entity public class Person {
@Id String name;
String gender;
@ElementCollection
Map<String, String> phones;
...
}
Person duke = new Person();
duke.setName("Duke");
duke.setGender("Male");
phones = new HashMap<>();
phones.put("home", "650-123-4567");
phones.put("mobile",
"650-234-5678");
duke.setPhones(phones);
{
"name":"Duke",
"gender":"Male",
"phones":{
"home":"650-123-4567",
"mobile":"650-234-5678"
}
}
JSR 367
48. JSON-B: Proposed Custom Mapping
• Utilization of annotations to map fields to JSON Document Elements
@JsonProperty(“poolType”)
public String poolType;
@JsonPropertyOrder(“poolType”,”shape”)
public class Pool(){
public String poolType;
public String shape;
…
}
{
poolType : “Inground”,
}
{
poolType : “Inground”,
shape : “Rectangle”
}
JSR 367
49. Java EE Security
• Improve Java EE platform by ensuring that the security
API is useful in the modern cloud/PaaS paradigm
• Simplify, standardize, modernize
• Promotes modern concepts (EL and CDI)
JSR 367
50. Java EE Security
• Simplify security providers
• Easy pluggability and mapping
• Enabling existing security annotations for all beans
• Proposed examples:
• https://github.com/javaee-security-spec/javaee-security-proposals
JSR 375
51. Java EE Security: Proposed Provider
@SecurityProvider
public class MySecurityProvider {
@Inject UserService userService;
@OnAuthentication
// The parameters could suit the credentials mechanism being used.
public Principal getPrincipal(String username, String password) {
// Construct the principal using the user service.
}
@OnAuthorization
public String[] getRoles (Principal principal) {
// Construct an array of roles using the principal and user service.
}
}
JSR 375
52. Java EE Security – JavaOne 2016
• Add OAuth and OpenID support
• Secret management
JSR 375
53. JCache
• Java Temporary Caching API
• JSR 107 - Started in 2001
• Provides a common way for Java applications to create,
access, update, and remove entries from caches
JSR 197
54. JCache
• Provide applications with caching
functionality…particularly the ability to cache Java objects
• Define common set of caching concepts & facilities
• Minimize learning curve
• Maximize portability
• Support in-process and distributed cache implementations
JSR 107
57. Configuration
• Standardize a mechanism of defining, injecting and using
configuration within an application.
• Define configuration persistence mechanisms, formats,
and bindings.
• Support for merging, overriding, and federating
configurations from different sources
• Provide a standard mechanism for working with
mutable/dynamic configurations
58. Health Check
• Goal: Standardize health reporting
• Proposed new REST API enabling health checking
• Available via configurable context (/healthcheck)
• Will include semantics for reporting health
• Health status codes
• Reasons/warnings
• Health of dependencies
59. Java EE Roadmap - JavaOne 2016
2016
• Feedback through Survey
• Launch Java EE Next JSRs
2017
• Java EE 8
• Specs, RI, TCK complete
• Initial microservices support
• Define Java EE 9
• Early access implementation
of Java EE 9
2018
• Java EE 9
• Specs, RI, TCK complete
• Modular Java EE runtime
• Enhanced microservices
support
60. Java EE: Take Action
• Start working with Java EE 8 today
• Tools:
• GlassFish v5 (or Payara)
• Tomcat 9 web sockets
• Milestones
• Examples and Specification Docs
61. Java EE Resources
• JavaOne 2016 EE 8 Update/Reboot
• http://tinyurl.com/zeark5t
• Java EE 8 by Arjan Tijms
• https://javaee8.zeef.com/arjan.tijms
• JavaOne 2016 Sessions
• https://www.oracle.com/javaone/
• JSR 366
• https://www.jcp.org/en/jsr/detail?id=366
63. Adopt-A-JSR
• Started in 2007, easy way for JUGs to get involved
• What you can do depends upon what you want to do &
what spec leads are looking for