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.
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
This document summarizes a presentation about using Gradle to build Scala and Play applications. It discusses Scala and Play support in Gradle, continuous compilation mode, and demos building a basic Play app and using hot reload in Gradle. The presenter is a LinkedIn software engineer who provides an overview of Scala, Play, Gradle, and the benefits of using Gradle for Play application builds.
As the leading full-stack application framework for Java SE and EE, the Spring Framework continues to deliver significant benefits to Java developers, increasing development productivity and runtime performance while improving test coverage and application quality.
In this talk, core Spring Framework committer Sam Brannen will provide attendees an overview of the new features in Spring 3.2 as well as a sneak peak at the roadmap for 4.0.
Spring Framework 3.2 builds on several themes delivered in 3.1 with a continued focus on asynchronous MVC processing with Servlet 3.0, support for using @Autowired and @Value as meta-annotations, support for custom @Bean definition annotations, and early support for JCache 0.5. Regarding the internals, CGLIB 3.0 and ASM 4.0 have been inlined, and the framework is now built with Gradle and hosted on GitHub. For those interested in testing their Spring-based web applications, Spring 3.2 offers new support for loading WebApplicationContexts in the TestContext framework, and the formerly standalone Spring MVC Test project is now included in the spring-test module, allowing for first-class testing of Spring MVC applications.
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.
Java 9 will introduce a new module system that will provide code encapsulation and a way to explicitly declare dependencies between modules. Some key changes include the ability to define modules using a module-info.java file, and new parameters for javac and java to support modules. There are still some unresolved issues around module declarations, artifacts, descriptors, graphs, reflection, and versioning that need to be addressed prior to final release. The new module system is aimed at addressing problems like large runtime footprints, classpath issues, and lack of visibility controls between packages.
Web application development using Play Framework (with Java)Saeed Zarinfam
This document provides an overview of the Play Framework for web application development using Java. It discusses the history and architecture of Play, how to set up a Play project, the MVC structure, routing, controllers, views, sessions, assets, hot code reloading, databases, testing, deployment, and scaling. Play uses Netty as its web server, is stateless, supports hot code reloading, and allows building asynchronous and reactive applications. It also has integrations for Akka, WebSockets, caching, internationalization, and more.
The document provides an overview of the Java Platform Module System (JPMS) introduced in Java 9. Key points include:
- JPMS addresses issues with strong encapsulation, reliable dependency management, and API evolution in Java applications and libraries.
- The module is a new abstraction that more finely controls access and dependencies through package exports and module declarations.
- The module path replaces the classpath, and the modularized JDK itself is composed of platform modules.
- Projects can begin adopting a modular structure immediately while the ecosystem transitions over time.
The document provides an introduction to Typesafe Activator and the Play Framework. It discusses how Activator is a tool that helps developers get started with the Typesafe Reactive Platform and Play applications. It also covers some core features of Play like routing, templates, assets, data access with Slick and JSON, and concurrency with Futures, Actors, and WebSockets.
Typesafe trainer and consultant Will Sargent describes just how Play Framework is so "fast" for Java and Scala production apps.
More Play, Akka, Scala and Apache Spark webinars, presentations, and videos:
http://typesafe.com/resources/videos
With Java 9 modules coming to us soon, you want your existing code to be fully ready for the module system. Making code modular can be a daunting task, but Java 9 comes with a number features to ease migration. This includes automatic modules, the unnamed module and a number of command line arguments.
In this talk we will look at examples of migrating real code. It discusses common problems youll run into during migration, leading to practical tips and the ability to set realistic goals. Its also a good way to understand the module system itself and the various migration paths it supports. This talk is an excellent preparation to start migrating your own code.
* Understanding modules and the module path
* Automatic modules
* Mixing classpath and modulepath
* Dealing with reflection
* Escape switches
* Jdeps
All topics will be based on examples of often used libraries and frameworks.
Java(ee) mongo db applications in the cloud Shekhar Gulati
This document provides an agenda and summary for a workshop on developing MongoDB applications on OpenShift presented by Shekhar Gulati. The agenda includes getting started with OpenShift, developing a location-aware Java EE application using JAX-RS and CDI for REST services, and MongoDB for the database. The document discusses OpenShift, JAX-RS, CDI, and MongoDB concepts. It also outlines code samples and steps to create and deploy a sample Twitter-like application on OpenShift that supports creating, finding, and geo-searching statuses.
The document compares several Java build tools: Ant + Ivy, Maven, Gradle, and Buildr. It describes their key features such as dependency management, build lifecycles, and conventions. A results matrix shows how well each tool supports desired build features such as compiling Java code, running tests, and property expansion. The evaluation notes that Ant, Ivy and Maven have been around longest but Gradle is promising. Buildr is considered very flexible but has potential platform issues being built on Ruby.
Maven is a build tool that focuses on project structure, dependencies, and conventions. It allows for easy creation of multi-module projects and provides excellent dependency management. Key features include a consistent project structure, dependency management that handles transitive dependencies, and a lifecycle of goals like compile and test. Maven uses a POM file to describe a project's structure, dependencies, and plugins.
The document provides an overview of new features in Java EE 7, including WebSocket support, JSON processing, batch applications, concurrency utilities, simplified JMS API, and enhancements to other Java EE technologies. It discusses 10 top features in more depth and includes code examples. The goal is to help developers get started with Java EE 7.
Apache maven and its impact on java 9 (Java One 2017)Robert Scholte
Maven is a build tool that manages projects and dependencies. It aims to make the build process easy and provide a uniform system. With Java 9, Maven faces challenges due to the module system's differences from the classpath. Specifically, the modulepath does not support all file types like the classpath. This causes issues for Maven which relies on dependencies being on the classpath. Additionally, automatic modules generated from JAR files can cause problems for projects. Maven cannot directly generate module descriptors but tools like Jdeps can assist with initial descriptors. Overall, while challenges exist, Maven can still be used for most projects with Java 9.
JavaOne 2017 presentation about migration existing code to Java 9 modules.
Demos used during the presentation can be found on GitHub: https://github.com/java9-modularity/java9-migration-demos
The Play Framework is a web framework for Java and Scala that provides a lightweight and scalable architecture built on Akka. It allows for the creation of RESTful applications with non-blocking I/O and real-time capabilities. Play embraces modern web technologies and includes features for persistence, security, internationalization and more.
The document discusses various aspects of developing modular applications using J2EE, OSGi, and RCP frameworks. It covers:
1. The structure and organization of modules, projects, and dependencies when using different frameworks like J2EE, Spring, Maven, and OSGi.
2. How modules, plugins, and bundles can be developed and packaged for each framework. This includes module/plugin sources, views, packaging, and dependencies.
3. Integration aspects like how to integrate databases, connection pools, templating engines, and more through extension bundles/plugins across frameworks.
Vignesh Ramesh gives an overview of Java modules in Java 9. Modules allow for strong encapsulation by only exporting certain packages. This addresses issues in Java 8 where all packages were effectively public. The module system solves problems like weak encapsulation and jar hell. Key aspects include module descriptors, exports, requires, and the new jlink tool for creating custom runtime images.
Modules in Java? Finally! (OpenJDK 9 Jigsaw, JSR376)Mihail Stoynov
This talk is for a very important new feature in Java SE 9. Code named Jigsaw, this feature modularizes the Java SE platform.
The coolest thing we do here is to create a custom JRE
Code: https://bitbucket.org/stybz/jigsaw.sty/
PPT: https://www.slideshare.net/mihailstoynov/modules-in-java-finally-openjdk-jigsaw
Video: https://www.youtube.com/watch?v=W5LeNPtPrqw
What we can expect from Java 9 by Ivan KrylovJ On The Beach
Java 9 is currently scheduled to become generally available in less then 1 year. Perhaps now is a good time to have a closer look at language proposals and API changes in Java 9. There are over 70 proposals targeted to Java 9, we will have a looks at some key ones, starting with java modularity. We will look at some breaking changes and ways to develop both short and long term solutions for adoption of new upcoming version of Java.
Java 9 introduced several new features including JShell, modules, and services. JShell allows developers to test Java code interactively from the command line. Modules allow Java code to be modularized by defining explicit dependencies and encapsulating packages. Services allow modules to discover implementations of an interface at runtime through a service loader. The modularization of Java aims to improve maintainability, security, and performance of Java applications.
Huge JRE images were a huge problem for packaging and deploying small and lightweight tools based on Java. Have you tried to reduce Java runtime images? You will be surprised how well that works. From JDK 9 a minimal image targeting desktops can be as small as 18MB!This is a huge improvement but how does this black-magic work? I will be wowing you with an overview of Java’s custom runtime image tooling and present a interactive demo on how to create a mini Java runtime image file. We bust the myths around Java cloud computing and show you how to embraced Cloud Orientated development with Java. See how the new Java module system works with general patterns for developing a modular Java Cloud application.
Java 9 and the impact on Maven Projects (ApacheCon Europe 2016)Robert Scholte
The document discusses the impact of Java 9 on Maven projects and provides strategies for Maven and plugins to support Java 9. It outlines changes in Java 9 like the module system and new JAR format that Maven must accommodate. It recommends verifying that plugins work with Java 9 and do not use internal APIs or have duplicate packages. Maven plugins may need to select the module path for compilation in some cases.
Here are the steps to filter the resource properties in the example:
1. Define the my.filter.value property in a filter file (e.g. src/main/filters/filter.properties):
my.filter.value=hello
2. Define the command.line.prop property in the pom.xml:
<properties>
<command.line.prop>hello</command.line.prop>
</properties>
3. The settings.offline property will be filtered from the <offline>true</offline> value defined in settings.xml
4. Add filtering configuration to the pom.xml:
<build>
<filters>
<filter>src
This document discusses JBoss Modules, which provides a module system for loading and running modules in Application Server 7. It describes modules as collections of code and resources that implement specific domain requirements. JBoss Modules defines each module as having its own classloader, allowing isolation and preventing conflicts between modules. It manages module dependencies by only loading required imports and exporting specified APIs. The presentation demonstrates how JBoss Modules loads and executes modules quickly and efficiently to serve as the core of Application Server 7.
This document provides an agenda and information for a Java 9/Jigsaw hack day event hosted by the Atlanta Java Users Group. The agenda includes sessions on Java 9 modularization, JLink, migrating non-modular apps to Java 9, and feedback. Presenters will discuss what modularization means in Java 9, including splitting the JDK into named modules that declare dependencies. Attendees will have hands-on exercises and are encouraged to provide live feedback.
Here are the key differences:
Reserved words: These are words that have special meaning in Java like class, public, etc. They cannot be used as regular identifiers.
Modifiers: Modifiers like public, private, static etc. specify attributes of classes, methods and variables.
Package: A package is a namespace that organizes related classes and interfaces. It provides access protection.
Libraries: Libraries are pre-compiled classes that provide useful functionality that can be included in programs using import statements.
JVM version: The Java Virtual Machine version specifies the Java runtime environment. Programs need to be compatible with the JVM version.
JVM: The Java Virtual Machine is an abstract computing machine that
This document summarizes changes to the Java programming language from JDK 9 to JDK 16, including new features and modules. Some key points:
- Java has moved to a six-month release cycle, delivering more features faster than before.
- Modules were introduced in JDK 9 to improve modularity. Modules group related code and dependencies.
- Incubator modules and preview features allow testing of non-final APIs before inclusion in the Java SE platform.
- Local variable type inference using 'var' was added in JDK 10 for simpler declaration of local variables when types can be inferred.
- Modules, the module system, and tools like jlink and jdeps help manage dependencies
An overview of Scalable Web Application Front-endSaeid Zebardast
Problem Definition:
Building large web applications with dozens of developers is a difficult task. Organizing the engineers around a common goal is one thing, but organizing your code so that people can work efficiently is another. Many large applications suffer from growing pains after just a few months in production due to poorly designed JavaScript with unclear upgrade and extension paths.
Scalable JavaScript Application Framework:
Yahoo! home page engineer Nicholas Zakas, author of Professional JavaScript for Web Developers, introduced front-end architecture for complex, modular web applications with significant JavaScript elements.
Apache Maven supports all Java (JokerConf 2018)Robert Scholte
With the release train we can expect a new version of Java every 6 months. This means that tools like Maven should try to keep with this pace. Especially Java 9 came with some new features, and Maven managed to support these features. Maven found an elegant solution to work with modulepaths and classpaths without any need for developers to specify which jars belongs where.
This session will highlight the most important features developers should know to work with Java 9 and 10, combined with some practical tips and warnings.
Covers the common issues seen when migrating from Java 8 to Java 9. This deck shows simplified examples of the issues and code snippets of how to address them.
Java Core | Java 8 and OSGi Modularisation | Tim Ellison & Neil BartlettJAX London
The talk will cover a bit of background first to set things up: what is a module, why do we need a module system, summary of Java's existing support for modularity. Then it will move on to give a comparison of OSGi's and Jigsaw's dependency models. Pros and cons of each model in different environments will be discussed. Finally, opportunities and challenges for interoperability: from the perspective of both application developers (who may need to integrate modules from both kinds) and from library module developers (who may need to target both module systems)
The document discusses modularization in Java 8 and OSGi. It describes what modules are and why they are needed, including for managing dependencies and versioning. It outlines the characteristics of a good module system and compares how Java 8's Project Jigsaw and OSGi handle modularization. Key points include how both aim to address issues like class loading performance and dependency management, but OSGi has existing tools and does not require language changes.
This is the material for Tampere workshop on 14th May 2018.
How to combine modern technologies such as Java 10, Spring Boot 2, Docker, to create more lightweight and modern microservices - or any services you like.
Similar to Preparing for java 9 modules upload (20)
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.
Java script nirvana in netbeans [con5679]Ryan Cuprak
This document discusses using NetBeans as an IDE for JavaScript development. It provides an overview of NetBeans' features for JavaScript including syntax highlighting, code completion, debugging, support for frameworks like Angular and Node.js, and mobile development with Apache Cordova. It also demonstrates how to set up and configure NetBeans for common JavaScript tasks like adding libraries, using build tools like Grunt and Gulp, and setting up unit testing with Karma and Jasmine.
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.
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.
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.
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.
Hybrid Mobile Development with Apache Cordova and Ryan Cuprak
Apache Cordova is used to wrap HTML5 applications into native mobile applications that can access device capabilities. A demo application was shown that used Cordova for the mobile portion and Java EE 7 on the server side. Key technologies discussed included Cordova plugins, RESTful web services, Java API for JSON, and Java API for WebSockets for bidirectional communication between the mobile app and server. jQuery Mobile was also mentioned as a potential UI framework.
This document provides an overview comparison of JavaFX and HTML5 for building mobile applications. It includes a demo of a sailboat racing application built with both JavaFX and HTML5. The technical comparison section analyzes the architectures, controls, data binding, tables, multimedia support and other features of JavaFX and HTML5. It finds that while HTML5 has broader deployment options, JavaFX provides more robust and integrated core features out of the box. The document also discusses the perspectives and limitations of both JavaFX and HTML5.
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.
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.
JavaOne 2013: Organizing Your Local CommunityRyan Cuprak
The document provides background information on user groups and describes the history of the CT Java User Group, which the author helped restart in 2002. It discusses how the group was initially dormant but grew over time through regular meetings, connecting with speakers, and acquiring a website and domain names. Lessons learned include that user groups require dedication, investment of time and money, and don't require the leader to be a "Java rockstar." The document provides tips for starting a new user group, including legal and financial considerations, logos, websites, recruitment, scheduling meetings, and selecting meeting topics and venues.
Software development... for all? (keynote at ICSOFT'2024)miso_uam
Our world runs on software. It governs all major aspects of our life. It is an enabler for research and innovation, and is critical for business competitivity. Traditional software engineering techniques have achieved high effectiveness, but still may fall short on delivering software at the accelerated pace and with the increasing quality that future scenarios will require.
To attack this issue, some software paradigms raise the automation of software development via higher levels of abstraction through domain-specific languages (e.g., in model-driven engineering) and empowering non-professional developers with the possibility to build their own software (e.g., in low-code development approaches). In a software-demanding world, this is an attractive possibility, and perhaps -- paraphrasing Andy Warhol -- "in the future, everyone will be a developer for 15 minutes". However, to make this possible, methods are required to tweak languages to their context of use (crucial given the diversity of backgrounds and purposes), and the assistance to developers throughout the development process (especially critical for non-professionals).
In this keynote talk at ICSOFT'2024 I presented enabling techniques for this vision, supporting the creation of families of domain-specific languages, their adaptation to the usage context; and the augmentation of low-code environments with assistants and recommender systems to guide developers (professional or not) in the development process.
Sami provided a beginner-friendly introduction to Amazon Web Services (AWS), covering essential terms, products, and services for cloud deployment. Participants explored AWS' latest Gen AI offerings, making it accessible for those starting their cloud journey or integrating AI into coding practices.
Seamless PostgreSQL to Snowflake Data Transfer in 8 Simple StepsEstuary Flow
Unlock the full potential of your data by effortlessly migrating from PostgreSQL to Snowflake, the leading cloud data warehouse. This comprehensive guide presents an easy-to-follow 8-step process using Estuary Flow, an open-source data operations platform designed to simplify data pipelines.
Discover how to seamlessly transfer your PostgreSQL data to Snowflake, leveraging Estuary Flow's intuitive interface and powerful real-time replication capabilities. Harness the power of both platforms to create a robust data ecosystem that drives business intelligence, analytics, and data-driven decision-making.
Key Takeaways:
1. Effortless Migration: Learn how to migrate your PostgreSQL data to Snowflake in 8 simple steps, even with limited technical expertise.
2. Real-Time Insights: Achieve near-instantaneous data syncing for up-to-the-minute analytics and reporting.
3. Cost-Effective Solution: Lower your total cost of ownership (TCO) with Estuary Flow's efficient and scalable architecture.
4. Seamless Integration: Combine the strengths of PostgreSQL's transactional power with Snowflake's cloud-native scalability and data warehousing features.
Don't miss out on this opportunity to unlock the full potential of your data. Read & Download this comprehensive guide now and embark on a seamless data journey from PostgreSQL to Snowflake with Estuary Flow!
Try it Free: https://dashboard.estuary.dev/register
AI Chatbot Development – A Comprehensive Guide .pdfayushiqss
Discover how generative AI is transforming IT development in this blog. Learn how using AI software development, artificial intelligence tools, and generative AI tools can lead to smarter, faster, and more efficient software creation. Explore real-world applications and see how these technologies are driving innovation and cutting costs in IT development.
WhatsApp Tracker - Tracking WhatsApp to Boost Online Safety.pdfonemonitarsoftware
WhatsApp Tracker Software is an effective tool for remotely tracking the target’s WhatsApp activities. It allows users to monitor their loved one’s online behavior to ensure appropriate interactions for responsive device use.
Download this PPTX file and share this information to others.
Ansys Mechanical enables you to solve complex structural engineering problems and make better, faster design decisions. With the finite element analysis (FEA) solvers available in the suite, you can customize and automate solutions for your structural mechanics problems and parameterize them to analyze multiple design scenarios. Ansys Mechanical is a dynamic tool that has a complete range of analysis tools.
Explore the rapid development journey of TryBoxLang, completed in just 48 hours. This session delves into the innovative process behind creating TryBoxLang, a platform designed to showcase the capabilities of BoxLang by Ortus Solutions. Discover the challenges, strategies, and outcomes of this accelerated development effort, highlighting how TryBoxLang provides a practical introduction to BoxLang's features and benefits.
COMPSAC 2024 D&I Panel: Charting a Course for Equity: Strategies for Overcomi...Hironori Washizaki
Hironori Washizaki, "Charting a Course for Equity: Strategies for Overcoming Challenges and Promoting Inclusion in the Metaverse", IEEE COMPSAC 2024 D&I Panel, 2024.
3. Project Jigsaw Goals
• Make the Java platform scalable for small computing
devices.
• Improve platform security and maintainability
• Enable improved application performance
• Simplify library creation and application development
Reliable configuration
Strong Encapsulation
4. Why Modules?
• Java currently suffers from JAR ”hell”
• Maven tracks dependencies but no runtime enforcement
• No guarantee an application can start:
NoClassDefFoundError
• Possible to mix library versions on classpath:
• commons-io-2.5 and commons-io-1.6 – what happens?
• Existing module frameworks (OSGi) can’t be used to
modularize the Java platform.
7. Comparing Jigsaw / OSGi / Java EE
Feature Jigsaw OSGi Java EE
Allows cycles between packages in different modules ❌ ✅ ✅
Isolated package namespaces ❌ ✅ ✅
Allows lazy loading ❌ ✅ ✅
Allows dynamic package addition ❌ ✅ ✅
Unrestricted naming ❌ ❌ ✅
Allows multiple versions of an artifact* ❌ ✅ ✅
Allows split packages ❌ ✅ ✅
Allows textual descriptor ❌ ✅ ✅
Source: https://goo.gl/7RKqQx
8. Class Loading & Module System
Bootstrap Loader Platform Loader Application Loader
Java Platform Module System
Java Virtual Machine
java.base java.logging java.sql java.corba jdk.compiler log4j
9. Common Questions
• Do I have to modularize my application to run on Java 9?
• Will my Java 6/7/8 application compile on Java 9?
• Will my Java 6/7/8 application run un-modified on Java 9?
• How do I identify problems today?
- NO -
- Depends – using private APIs? -
- Depends – using private APIs? -
- jdeps -
10. Common Questions…
• Can I partially leverage modules?
• Is tooling ready? (Maven/Gradle/IntelliJ/NetBeans/etc.)
• Do application containers work on 9 today?
• Can I try out Java 9 today?
- YES -
- Absolutely NOT -
- Maybe -
- YES -
12. jdeps
• Command line tool included with Java 8
• Static class dependency checker
• Key parameters
• -jdkinternals – flags internal API usage that will break in Java 9
• -dotoutput <dir> - dot output files
• -cp – classpath to analyze
• -verbose:class/package – package/class level dependencies
• Use jdeps on all generated output and dependencies
13. jdeps – Example
jdeps -jdkinternals jide-common.jar
jide-common.jar -> /Library/Java/JavaVirtualMachines/jdk1.8.0_121.jdk/Contents/Home/jre/lib/rt.jar
com.jidesoft.plaf.aqua.AquaJidePopupMenuUI (jide-common.jar)
-> com.apple.laf.AquaPopupMenuUI JDK internal API (rt.jar)
com.jidesoft.plaf.aqua.AquaRangeSliderUI (jide-common.jar)
-> apple.laf.JRSUIConstants JDK internal API (rt.jar)
-> apple.laf.JRSUIConstants$Orientation JDK internal API (rt.jar)
-> apple.laf.JRSUIConstants$State JDK internal API (rt.jar)
-> com.apple.laf.AquaSliderUI JDK internal API (rt.jar)
com.jidesoft.plaf.basic.BasicFolderChooserUI (jide-common.jar)
-> sun.awt.shell.ShellFolder JDK internal API (rt.jar)
com.jidesoft.plaf.basic.BasicPainter (jide-common.jar)
-> sun.swing.plaf.synth.SynthIcon JDK internal API (rt.jar)
com.jidesoft.plaf.metal.MetalUtils$GradientPainter (jide-common.jar)
-> sun.swing.CachedPainter JDK internal API (rt.jar)
com.jidesoft.plaf.windows.AnimationController (jide-common.jar)
-> sun.awt.AppContext JDK internal API (rt.jar)
-> sun.security.action.GetBooleanAction JDK internal API (rt.jar)
…
JIDE: Widely used
Swing component
library (jidesoft.com)
18. Java Accessibility
JDK 1-8 JDK 9+
public public
protected public to specific modules
<package> public only within a module
private protected
<package>
private
19. Module Definition
• module-info.java defines a module
• Contents define the following:
• Unique name of the module
• Dependencies of the module
• Packages to be exported for use by other modules
• Placed at root of the namespace
Module Name
exports
requires
21. Module Basics
• Module names must be unique
• Names should follow reverse domain name pattern
• Modules are eagerly loaded
• Dependency graph is built and checked on startup
• Application won’t start if modules are missing
• No support for versioning
• Only one version of a module may be loaded
• Layers maybe used to load different versions of a module
22. About Versioning…
• Two modules with the same package names in them are
considered to be different versions of the same module.
• Two modules with the same name are considered to be
two versions of the same module.
• Concealed package conflicts:
• When two modules have the same package name in them, but the
package is private in both modules, the module system cannot load
both modules into the same layer
23. Introducing the Module Path
• Module path augments / extends the classpath
• All command line tools now include both
--module-path
--upgrade-module-path
--add-modules
--describe-module
--dry-run
--validate-modules
• Use java –list-modules to see all available modules
Parameters on java command
24. JDK Modules
• jdk.base is included by default.
• java.se and java.se.ee are aggregator modules
• java.se.ee contains the following modules:
• java.corba
• java.transaction
• java.xml.ws.annotation
• javax.xml.ws
• java.xml.bind
• java.activation
• java runs with java.se modules – not java.se.ee
27. Simple Module Example
javac -d out src/org/ctjava/services/MeetingService.java
src/org/ctjava/services/impl/MeetingServiceImpl.java src/module-info.java
Cannot use reflection to find
MeetingServiceImpl
35. Qualified Exports…
Exception in thread "main" java.lang.reflect.InvocationTargetException
at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.base/java.lang.reflect.Method.invoke(Method.java:564)
at java.base/sun.launcher.LauncherHelper$FXHelper.main(LauncherHelper.java:946)
Caused by: java.lang.RuntimeException: Unable to construct Application instance: class org.ctjava.admin.AdminConsole
at javafx.graphics/com.sun.javafx.application.LauncherImpl.launchApplication1(LauncherImpl.java:963)
at javafx.graphics/com.sun.javafx.application.LauncherImpl.lambda$launchApplication$2(LauncherImpl.java:198)
at java.base/java.lang.Thread.run(Thread.java:844)
Caused by: java.lang.IllegalAccessException:
class com.sun.javafx.application.LauncherImpl (in module javafx.graphics) cannot access class
org.ctjava.admin.AdminConsole (in module org.ctjava.admin) because module org.ctjava.admin does not export
org.ctjava.admin to module javafx.graphics
• JavaFX LauncherImpl cannot access AdminConsole
• Class in javafx.graphics tried to instantiate AdminConsole in
org.ctjava.admin
37. jlink
• Generates a runtime-image including
the JVM.
• Only required modules are included
• Basic invocation:
jlink --module-path <modulepath>
--add-modules <modules>
--limit-modules <modules>
--output <path>
Demo used
JavaFX: 95 mb
Full JDK: 454 mb
40. Deprecated Modules…
java -jar WebEndpointTest.jar
Worked on Java 8 – what happened?
Fix:
java --add-modules java.xml.ws -jar WebEndpointTest.jar
41. Module Types
Automatic Modules • Mechanism for using JARs which do not
include a module-info.java configuration
• Export all of the JAR packages
• Reads all other modules
• Module name is dynamically generated
Unamed Module • Alls JARs and classes on the classpath will
be contained un the Unamed Module.
• Similar to Automatic Modules
• Does not possess a name
Platform Modules • JDK modules
42. JARs & Module System
--module-path -classpath
Modular JAR Application Module Unnamed Module
Non-modular JAR Automatic Module Unnamed Module
Unnamed module name: ALL-UNNAMED
43. Readability
Module Type Origin Export
Packages
Read Modules
Named Platform Provided by platform Explicitly
Named Application All JARS containing
module-info on the
module path
Explicitly • Platform
• Application
• Automatic
Automatic All JARs without module-
info but on module path
All • Platform
• Application
• Automatic
• Unnamed
Unnamed Classpath All • Platform
• Automatic
• Application
46. Automatic Modules…
java.lang.IllegalAccessException: class org.ctjava.util.InstantiateUtility (in module MyInvocationLibrary) cannot
access class org.ctjava.admin.AdminCallback (in module org.ctjava.admin) because module org.ctjava.admin
does not export org.ctjava.admin to module MyInvocationLibrary
47. Escape & Encapsulation Kill Switch
Important javac command line options:
--add-opens – opens a package
--permit-illegal-access - All code in the unnamed module
can access other types regardless of any limitations.
Will result in a WARNING: to be removed
in Java 10.
55. Tooling Support
• Early access JDK 9 builds:
http://jdk.java.net/9/
• Use jenv to swich between Java 8 & 9
http://www.jenv.io/
Examples:
jenv local 9-ea (locally switch to Java 9)
jevn global 1.8 (globally use Java 8)
Note: rt.jar and tools.jar were removed.
56. Tooling Support
Tool Status
NetBeans 9 🔶 Developer Preview
IntelliJ 2017.1 ✅
Eclipse 🔶
Maven ❌
Gradle ❌
• Maven & Gradle do not generate module-info.java.
• Gradle 3.4 doesn’t work on Java 9
• Maven 3.5 doesn’t completely work (not all plugins compatible)
• Eclipse Neon won’t start with Java 9 edit ini file.
58. Maven
• Maven Shade Plugin and Jigsaw don’t mix (uber jar)
• Example project with Maven and Java 9/Jigsaw:
• https://goo.gl/rmzKBa
59. NetBeans & Java 9
• NetBeans Developer Preview required for Java 9.
• New project template for modular projects.
• Creates Ant build files
60. NetBeans & Java 9
• Module structure not compatible with javac:
• <module>/classes/<source code>
• Detects imports where the module is not imported.
• Does not auto-import yet.
61. IntelliJ
• Support added in 2017.1 (release March 2017)
• For multi-module project:
1. Start with Empty Project
2. Add new module for each Jigsaw module
• IntelliJ detects when an import requires a module
definition
64. Java 9 Preparation
• Analyze dependencies using jdeps
• Immediately fix code using internal APIs
• Check transitive dependencies for internal JDK APIs
• Integrate jdeps into continuous integration
• Use Maven JDeps Plugin
• Analyze reflection code: setAccessible(true)
• Refactor code to remove duplicate packages across JARs
• common.jar: com.foo.utilities
• Server.jar com.foo.utilitie
65. Legacy Code
• If using internal JDK API, fix or use flag:
--add-exports, --add-opens, --permit-illegal-access
• If using removed JDK module: (ex. Activation):
--add-modules <module>
67. Java EE & Spring
• Support for Jigsaw unknown
• Major effort required for containers to support Jigsaw
• Concerns raised in JCP voting over Jigsaw and EE
• Regardless: Dependencies on JDK internal APIs must be
immediately resolved.
68. Desktop App Impact
• Impacts of JDK internal dependencies maybe felt more on
Java desktop applications
• Many hacks were required to work around
limitations/bugs in Swing
• Older applications may need to be ported to JavaFX
Technical Debt Bill is NOW DUE.
69. Best Practice
• Don’t depend upon java.se
• Avoid using qualified exports
• Don’t remove exports from a module in future releases
• Keep modules-info clean:
• requires javafx.controls
• requires javafx.base; -- controls already includes base
70. Resources
• Books
• The Java 9 Module System (https://goo.gl/QM1LS1)
• Java 9 Modularity (https://goo.gl/zJeYsd)
• Links
• Issues: https://goo.gl/xK4ymJ
• Oracle Talks: http://openjdk.java.net/projects/jigsaw/talks/
• Tutorial: https://goo.gl/ET9Hn1
• Tutorial: https://goo.gl/GzPXTw
• Jigsaw vote explanation: https://goo.gl/sWUZvX
Focus on newer Jigsaw material (2016 or later)