WebSphere Application Server & Liberty

 View Only

Open Liberty, open runtimes and cloud-native Java innovations at CASCON x EVOKE 2021 (Nov 22-25) conference - You're invited to join!

By Kathryn Kodama posted Mon November 15, 2021 02:17 PM


is a free industrial and academic conference for advanced studies in computer science and software engineering sponsored by IBM Advanced Studies and EVOKE Foundation taking place virtually from November 22-25 that is open to everyone to attendWith speakers from IBM, industry, government and academia, the 4-day program presents 4 thought-provoking keynotes, 66 industry talks with 212 industry speakers, dozens of workshops and technical booths, research papers, a technology exhibit, and valuable networking opportunities.

Then, with so many sessions it can be difficult to choose which to attend. We've put together a summary of the workshops, industry talks and exhibit expo booths related to cloud-native Java, open runtimes, Open Liberty, MicroProfile, Jakarta EE, WebSphere and more!


Monday November 22nd:
  • Mono2Micro: An AI Powered Java Monolith to Microservices Transformer for WebSphere Liberty
    • In this workshop, Anu Ramamoorthy, Len Theivendra and Tiaoyu Wang from the WebSphere Liberty team will walk users through refactoring a small but typical Java EE into deployable microservices with Mono2Micro. This tool semi-automates the refactoring process using AI and can provide a huge acceleration to and significantly economize the task of moving Java monoliths to containers in the cloud running WebSphere Liberty.
  • Cloud-Native Java Made Easy with MicroProfile and Jakarta EE
    • In this workshop hosted by Grace Jansen, Jamie Coleman, Mary Grygleski and Yee-Kang Chang from the Open Liberty team, come experience first-hand how you can build cloud-native solutions quickly and efficiently with the open, enterprise-grade, cloud-native Java programming APIs optimized for microservices and cloud using MicroProfile and Jakarta EE. A range of topics will be covered in a hands-on manner: Easily develop RESTful and reactive services; automating true-to-production testing using containers; and application considerations for cloud deployments with containers.

Wednesday November 24th:
  • 5th Workshop on Advances in Open Runtimes and Cloud Performance Technologies
    • Broken down into 3 different sessions, this workshop brings together research, industry, and developers from runtimes and cloud communities to share and discuss innovations, challenges, and research across a broad set of open-source technologies (such as Eclipse OMR, LLVM, Eclipse OpenJ9, Node.js, OpenLiberty) to improve performance in cloud environments.
    • This workshop, headed by IBM's Daryl Maier and Vijay Sundaresan, is packed with a wide range of topics.
      • In session one:
        • Krishna Nandivada (IIT Madras) will present Practical Field Privatisation by Splitting the Live Ranges of Objects
        • Lan Xia (IBM Canada) will present Open Test Strategy for IBM Runtimes
        • Hassan Arafat (University of New Brunswick) will present Static Analysis Guided Copying GC Traversal
      • In session two:
        • Pratik Fegade (Carnegie Mellon University) will present End-to-end Compiler Optimizations for Microservice-based Applications
        • Alexey Khrabrov (University of Toronto) will present Caching and reusing dynamically compiled code in OpenJ9 JITServer
        • Nahid Hasan Khan (Ontario Tech University) will present A Clustering Approach to Classify Contention Fault Types Using Run-time Performance
      • In session three:
        • Tobi Ajila (IBM Canada) will present Fast JVM startup with Checkpoint and Restore
        • Scott Young (University of New Brunswick) will present Optimizing Warmup with MicroJIT: A lightweight Just-in-Time Compiler
        • Alexandra Tsvetkova (University of Toronto) will presentJava Heap Compression for Memory Footprint Reduction

Industry Talks

Monday November 22nd:
  • Cloud Anatomy 101: Breaking down Cloud-native
    • Getting to grips with cloud-native is as vital to your application evolution as breathing is to the body. However, with this term encompassing so many technologies, products and architectural styles, how do you decide which will be best for your own application? Grace Jansen will detail how diving into the anatomy and evolution of the human body can give us great insights into the journey you’ll need to make for your own application evolution. Join this session to find out why and discover what is critical for a healthy cloud-native system.
  • Simple tweaks to get the most out of your JVM
    • Many developers don’t think about the JVM level when creating applications. It is something that just simply works. Now more applications are becoming cloud-native and we have JVM’s running in every microservice container, each performance gain can have massive benefits when scaled up. Some tweaks are very easy to implement and can have huge impacts on start-up time and performance of your applications. In this session, Jamie Coleman will go through all the different JVM options and give you some easy and simple advice on how to get the most out of your JVM to save not only money but also energy on the cloud.
  • Challenges on auto-tuning cloud applications
    • Join IBM's Daryl Maier, Don Bourne and Vijay Sundaresan, accompanied by Adalberto Junior and Ivan Beschastnikh from the Unviersity of British Columbia as they discuss challenges that arise when we try to deliver auto-tune to live general-purpose cloud applications. To manage all these challenges, they propose SmartTuning, a Kubernetes controller for auto-tuning cloud applications. It uses statistical analysis to sample configurations most likely to improve the application efficiency and safely installs these updates on the application with no downtime. In the team's experiments, Smart Tuning doubled the efficiency of our benchmark deployed application, increasing the number of requests served by resources allocated.
  • Best practices for deploying applications in containers
    • Open Liberty's Leo Christy Jesuraj will discuss how to containerize and run your applications consistently and efficiently. This session will cover the essentials about containers, how you can build enterprise-grade application images using official runtime images, and some best practices to follow when creating your own application images. Open Liberty and WebSphere Liberty runtimes from IBM will be used as examples. Join this session for a presentation and demo and learn from the experts that created and continue to enhance these official Liberty images.

Tuesday November 23rd:
  • Thriving in the cloud: Going beyond the 12 factors
    • Enabling applications to really thrive (and not just survive) in cloud environments can be challenging. The original 12 factor app methodology helped to lay out some of the key characteristics needed for cloud-native applications... but... as our cloud infrastructure and tooling has progressed, so too have these factors. In this session Grace Jansen will dive into the extended and updated 15 factors needed to build cloud native applications that are able to thrive in this environment, and we'll take a look at open source technologies and tools that can help us achieve this.
  • How to save the world without leaving your desk!
    • The human race is using computers more than ever before. Billions of applications on millions of computers. Soon almost 1/5th of the global electricity supply will be used up by corporate data centres alone. What can we do to help reduce this trend? Can you as a single developer make a difference? In this talk Jamie Coleman will explore the reality of mega data centres, what their owners are doing to make them greener and generally gasp at the scale of the challenges ahead. We’ll look at what runs in these environments and explore where the power goes. From there it gets a little easier to see how you can make a difference. We’ll visit the basics of making your application greener and talk about what’s happening in the Java arena to help you reduce the impact. Whether it is new thoughts about JVM directions, new frameworks or even new architectures, things are happening that can help you make a difference. Being greener can start with just one line of code.
  • Equipping the Next Generation of Open-Source Developers
    • Open Source has become the de facto way to build software. So, how and what are we doing in enabling the next-generation of up-and-coming developers to participate in open-source software development? Join Open Liberty’s Yee-Kang Chang and Kathryn Kodama, with Karim Ali and Jeff Cho from the University of Alberta, as they take a look at the Canada Open-Source Projects (CANOSP) program. They will explore the program’s experience and successes, and what they have learned from advocating for open source and equipping university and college students to participate in open-source software development
  • Microservices architecture explained for everyone
    • In this session, Monica Tamboli will talk about legacy monolithic applications, their shortcomings, and how microservices architecture solves these problems. This is an important concept to understand for anyone who is involved in the design, development, deployment or testing of any computer software system. This session will use human relationship analogies to explain how the same principles apply to microservices architecture to make the concepts easier and fun to understand.
  • Developer Advocacy Direct: Helping Teachers and students... and also your organization
    • In this session, hear from Paul Austin how IBMers have worked with the State University of New York at Oswego and in Ulster County to partner with teachers in semester-long products. Through direct engagement and participation in the class, you can help the teachers deliver cutting edge technology, the students get real exposure to your products, development methodologies, and culture - and you can help drive recruitment and adoption of your products.

Wednesday November 24th:
  • Automate your operations for security, resiliency & performance
    • Have you struggled with the stream of CVEs to understand which security patches are applicable to your servers? Do you want systems that will automatically detect anomalies and provide you with early warnings of potential issues? What about deployments that can smartly tune themselves for optimal performance? In this session, Leo Christy Jesuraj will introduce the new WebSphere Automation solution, take a look at common pain points you have with securing, managing and optimizing your enterprise Java application infrastructure and show how WebSphere Automation can give you a better night’s rest!

Exhibit Expo Booths

Monday November 22nd:
  • Classifying Lock Contention Performance for Java Intrinsic Locks
    • Md Nahid Ebna Hasan Khan, Joseph Robertson, Ramiro Liscano and Akramul Azim from Ontario Tech University will be joined by Vijay Sundaresan and Yee-Kang Chang from IBM to discuss how improper management of locks and threads can lead to lock contention and performance bottlenecks. In this paper an unsupervised learning algorithm is presented to help identify the type of lock contention fault with the goal of automating and facilitating the procedure that performance engineers follow. The classifier is based on the premise that if lock contention exists it is reflected as either a) threads spend too much time inside the critical section and/or b) threads' frequent access to the locked resource. Preliminary results appear to show that a classifier can be effectively trained to detect lock contention and the two types of locks.
  • Engineering Adaptive Software Systems Using Open-source Runtime Technologies
    • Ryan Liu, Mingyang Xu, Ladan Tahvildari from the University of Waterloo and Mark Stoodley from IBM discuss developing and designing a graduate-level course focused on engineering self-adaptive systems using open-source runtime technologies. To carry out this project, we plan on incorporating various advanced technologies, such as Open Liberty, OpenShift Container Platform, as well as technologies from the Eclipse Foundation on the IBM Cloud platform to construct a high-performance, scalable, and state-of-the-art environment for students to interact and comprehensively learn the ins and outs of self-adaptive systems.

Tuesday November 23rd:
  • Enabling rapid development of cloud-native Java applications for enterprises
    • In this expo booth, Eric Lau, Kathryn Kodama and Yee-Kang Chang from the Open Liberty team will showcase how you can use Maven to configure your multi-module cloud-native Java projects and iteratively develop them using tools like Open Liberty's dev mode.  With one command to start dev mode on a multi-module Maven project, changes in any module will be detected and automatically hot deployed. Using the Maven build logic, any dependent modules will also be recompiled and hot deployed. You can run tests on demand or attach a debugger and debug individual modules or the application as a whole. Dev mode also supports running in a container, so that you can run your application in a true to production environment. 
  • Trade-off Analysis Tool for Microservice Decompositions
    • Join Evelien Boerstra, John Ahn and Julia Rubin from the University of British Columbia and Cindy High, Debasish Banerjee, Len Theivendra and Yee-Kang Chang from IBM in this expo exhibit as they discuss their work with the trade-off analysis tool for microservice decompositions. The team proposes and compares a number of approaches that allow developers to inspect and customize decomposition while simultaneously considering multiple relationship types: (1) individual views, (2) a merged view, which automatically highlights differences between decompositions produced with multiple relationship types, and (3) a weighted-relationship view, which encapsulates a decomposition produced by simultaneously considering multiple relationship types. The team reports on the results of comparing and evaluating these views on a case study application and provide suggestions for possible future work.
  • Optimized arrayCopy Implementation in Eclipse OMR-OpenJ9 for Improved Runtime Performance on AArch64
    • Eclipse OMR is used to build robust language runtimes, on which Eclipse OpenJ9 is built, that support various hardware and operating system platforms. The AArch64 platform is widely used in electronic devices because of its reasonable price and resource efficiency. Adding optimizations to arrayCopy implementation on AArch64 provides better runtime performance. Siri Sahithi Ponangi, Gerhard Dueck and Kenneth Kent from the University of New Brunswick accompanied by Daryl Maier and Kazuhiro Konno from IBM present an approach taken to efficiently copy data taking advantage of the architecture of AArch64.
  • Reducing JIT compilation overheads to improve JVM performance in the cloud
    • Alexey Khrabrov and Eyal De Lara from the University of Toronto and Marius Pirvu and Vijay Sundaresan from IBM provide an overview of their work (complete, current, and future) on solving JVM performance issues associated with JIT compilation. The team presents two approaches for solving these performance issues. Their first approach is disaggregated JIT compilation: decoupling the JIT compiler from the rest of the JVM and moving it to a separate remote process. This solution is implemented in the JITServer technology in the OpenJ9 JVM. The second approach that the team is currently exploring is to reduce the memory overhead of JIT compilation using unified memory management in the JVM.

Wednesday November 24th:
  • Enabling developers to easily and openly learn cloud-native technologies
    • Join Gilbert Kwan, Priyanshi Patel, Rutav Shah, Ryan Storey from Open Liberty's developer content squad as they introduce and review what the open source cloud-native Java project, Open Liberty, has done to enable developers to learn and master cloud-native technologies for Java applications and microservices easily and openly with its guides and interactive tutorials. See what is involved to produce high-quality hands-on collateral for practitioners and even experience how you can practically grasp a cloud-native Java topic in 20 minutes or less!
  • Failure prediction of test suites in continuous integration environments using ML algorithms
    • In this expo exhibit, Akramul Azim, Md Asif Kahn, Ramiro Liscano from the Ontario Tech University and Gkerta Seferi, Kevin Smith, Qasim Tauseef and Yee-Kang Chang from IBM present that random forest and decision tree ML algorithms predict failed test suites better than the other classifiers utilizing two large-scale data sets from the Continuous Integration (CI) environment. They compare a novel CI dataset extracted from IBM’s CI pipeline for WebSphere Liberty with GSDTSR, with a rigorous amount of training data in the CI environment, to evaluate the effectiveness of various machine learning algorithms for failure prediction of test suites in CI environments.
  • Extending OMR with Explicit and Automatic Runtime SIMD/GPU Parallelization
    • In this expo exhibit, Akihiro Hayashi (Georgia Institute of Technology), Tong Zhou (Georgia Institute of Technology), Gita Koblents (IBM), Kazuaki Ishizaki (IBM) and Vivek Sarkar (Georgia Institute of Technology) present their implementation of supporting Java's high-level Vector API in OpenJ9. The JIT compiler recognizes user-written high-level Vector API in Java programs, then automatically generates platform-independent SIMD/Vector IR (intermediate representation), and finally generates platform-dependent vector instructions for a target platform. Such a high-level model allows the user to stick with Java and hides the complexity of utilizing low-level instructions on different platforms, thereby increasing software productivity and portability.
  • Adding SIMD Support to Improve Performance of Eclipse OpenJ9 on the AArch64 Platform
    • Daryl Maier (IBM), Md. Alvee Noor (University of New Brunswick), Kazuhiro Konno (University of New Brunswick), and Kenneth Kent (University of New Brunswick) discuss the steps taken to add Single Instruction Multiple Data (SIMD) support to OMR for AArch64, and relevant tests to confirm the vector operations. The implementation of several advanced SIMD and floating-point instructions are also discussed.

You can find the full schedule on the conference website. Looking forward to seeing you virtually at CASCON x EVOKE 2021!