Abstracts

Title: Minecraft Modding – Powerful and Simple Way to Teach Java Programming to Kids (MakerFaire)
Abstract:

Kids are addicted to Minecraft. This presentation will show how to leverage their passion and convert 8+ year old kids to Java programmers using Minecraft Modding. This session has been successful at different schools, libraries, events to kids with no prior programming knowledge.

Kids are addicted to Minecraft. This presentation will show how to leverage their passion and convert 8+ year old kids to Java programmers using Minecraft Modding. Parents will learn all the resources, books, and videos required to get their kids started on this rewarding journey to learn STEM concepts in a fun way.  This session has been delivered multiple times around the world at different schools, libraries, events to kids with no prior programming knowledge. All this is done using Java programming language in a very easy-to-understand way. 8+ year old kids instantly become Java programmers, and do so with lot of excitement and pride.


Title: How to code like a marathoner? (GIDS)
Abstract: Running a marathon requires discipline in different aspects of life – physical, mental, social, eating, and others. Getting up every morning to build your mileage and long runs on the weekend means sleeping early the night before. Strength training and getting mentally ready requires to get out of comfort zone. Hill training, intervals, fartleks,


Title: N1QL: SQL for JSON (GIDS)
Abstract: N1QL is a declarative query language to manipulate JSON data. The goal of N1QL is to give developers and enterprises an expressive, powerful, and complete language for querying, transforming, and manipulating JSON data. N1QL is to JSON what SQL is for relational model. SELECT, INSERT, UPDATE, DELETE, MERGE — you can do it all on JSON using N1QL. In each of the statement, in additional to select, join, project operations, N1QL supports nest and unnest operations, extensive scalar and aggregate functions to support manipulating and creating hierarchical and flexible data model in JSON.

Couchbase implements N1QL to support sophisticated query processing on its distributed database with flexible data model. Couchbase also has indexes to aid query performance. The applications, interactive shell and APIs use N1QL over REST apis, Couchbase APIs, JDBC and ODBC.

This session will introduce N1QL in a code-intensive session. Live demo will show writing and optimizing N1QL queries. Attendees will be able to use their SQL skills and start querying NoSQL in no time!


Title: Full-stack document database
Abstract: Couchbase Server is an open source, document-oriented NoSQL database. It can be installed in your data center or mobile platform. The database is designed for ease of development and low latency at scale. As a mobile database, it has everything you need to build always-available apps that work online & offline.

This session will provide an introduction to Couchbase Server. Attendees will learn how they can easily store and access data in Couchbase using N1QL – SQL for JSON. The data can also be persisted using APIs from different languages. They’ll learn how a Couchbase cluster can be easily created and scaled. Integration with multiple frameworks such as Spring Data, Spark, and Kafka will be discussed. Managing database using CLI, admin console and REST will be explained. Deployment options in Cloud and Containers will be discussed and shown.

The second part of the session will provide an introduction to Couchbase Mobile. It will explain the key features of fully functional, embedded, mobile NoSQL database. Attendees will learn how write apps faster using less code by taking advantage of database change events from Couchbase Lite. See how just a few lines of code enables app developers to synchronize data between multiple devices using Sync Gateway.


Title: Thanks Managers! (Ignite)
Abstract: Managers – our overlords at workplace! I’m here because of the feedback and guidance they’ve provided through out my corporate career. In some cases, they served as “that’s not the kind of manager how I’d like to be”. This Ignite talk will share stories and incidents of the feedback provided by my managers and how it helped me become a better person. You’ll learn the design patterns and anti-patterns of a good manager. Attendees will have a different level of appreciation for your manager after this talk.

Title: Kubernetes for Java Developers (KubeCon)
Abstract: Kubernetes is an open source orchestration system for Docker containers. So you are a Java developer but how comfortable are you and your team taking Docker containers from development to production? How do you scale these containers? Load balance them? How can such a deployment scale on multiple clouds? How do you monitor such applications?

This workshop/session explains how to package, deploy, and scale Java applications using Kubernetes.

Outline:

  • Getting started with Kubernetes for Java developers
  • Package first Java application with Kubernetes
  • Package your multi-container applications using Kubernetes
  • Scale your application based upon metrics
  • Deploy your Java applications to Kubernetes using Maven
  • Monitoring Java applications
  • CI/CD of Java applications using Kubernetes

Key Takeaways:

  • How to package, deploy, and scale Java applications using Kubernetes
  • Testing, debugging, and monitoring Java applications deployed using Kubernetes

Title: Docker for Java Developers (DockerCon)
Abstract: Docker is the developer-friendly container technology that enables creation of your application stack: OS, JVM, app server, app, database and all your custom configuration. So you are a Java developer but how comfortable are you and your team taking Docker from development to production? Are you hearing developers say, “But it works on my machine!” when code breaks in production? And if you are, how many hours are then spent standing up an accurate test environment to research and fix the bug that caused the problem?

Docker provides PODA (Package Once Deploy Anywhere) and complements WORA (Write Once Run Anywhere) provided by Java. It also helps you reduce the impedance mismatch between dev, test, and production environment and simplifies Java application deployment.

This workshop/session explains how to package, deploy, and scale Java applications using Docker.

Outline:

  • Getting started with Docker
  • Running first Java application with Docker
  • Package your Java application with Docker
  • Sharing your Java application using Docker Hub
  • Package your Java EE application as Docker multi-container applications
  • Scale your database and application using Docker Compose
  • Deploy your Java application using Maven
  • Docker tooling in Eclipse
  • Monitoring applications running on multiple containers
  • CI/CD of Java applications using Docker Containers

Key Takeaways:

  • How to package, deploy, and scale Java applications using Docker
  • Docker tooling for Java developers
  • Testing/Debugging Java applications deployed using Docker

Title: How to use Compose, Machine and Swarm to simplify your complex deployments (DockerCon)
Abstract: Couchbase is an open source NoSQL database. It has the capability to replicate data from one cluster to another cluster primarily for disaster recovery. Setting up this feature is general very intensive and time consuming because of multiple steps involved and special deployment needs. Docker helped us simplify showcasing this powerful and complex feature.

This talk will explain how we used Docker Machine to create a Swarm cluster with overlay network. Couchbase cluster was installed on this Swarm cluster using Compose scripts. The cluster was dynamically scaled based upon QoS attributes. Affinities and filters were used to ensure the deployment needs of Couchbase server are met. Multiple Couchbase clusters on Swarm clusters were then created, each with its own overlay network. Each of these Couchbase clusters were then configured for cross-data center replication. The same use case could be easily reproduced across multiple clouds because of the portability provided by Docker. The clusters were then monitored using Docker Universal Control Plane.

The entire setup really stretched Machine, Compose, Swarm and Networking to its limit. Attendees will learn tips of how to setup complex deployments using Docker. Design patterns, anti-patterns and recipes of such deployments will be discussed.

Outline:

  • A quick introduction of deployment setup
  • Show how a “data center” can be emulated using Docker Swarm/Machine (local laptop )
  • How Compose script was used to start/scale Couchbase server with an overlay network on Swarm cluster
  • How multiple such clusters were easily created
  • Setup Couchbase cross-data center replication across two “data centers”
  • Migrate the entire use case to cloud
  • Monitor the cluster using DUCP

Key takeaways:

  • How to setup complex deployments using Docker
  • Design patterns and anti-patterns of complex deployments
  • Compose scripts and Swarm/Machine recipes

Title: Full-stack Reactive Java Application using Docker (JavaOne)
Abstract: This code-driven session will explain how to build a full-stack reactive Java application.

What are the key components for this stack?

  • Java EE or Spring for application development
  • RxJava for asynchronous and event-based applications
  • Docker for packaging, scaling, and monitoring Java applications in the cloud
  • Couchbase for document database
  • JavaFX for desktop application
  • Deployed to multiple mobile platforms using Gluon

Attendees will be able walk away with a fully working application that shows how these different pieces fit together. Design patterns, anti-patterns and recipes of such deployments will be discussed.


Title: Getting Started with NoSQL using JBoss EAP 7 and OpenShift 3
Abstract: Today, enterprises are adopting NoSQL for a growing number of use cases, a choice that is driven by four interrelated trends: Big Users, Big Data, the Internet of Things, and Cloud Computing. JBoss EAP 7 allows a relational database to be easily invoked using the standard Java Persistence API.

This talk will provide a brief overview of different types of NoSQL databases. Majority of the talk will be spent on how to use a document database with JBoss EAP 7. Attendees will learn Java EE programming model can be evolved to perform simple CRUD operations to transactions using NoSQL database. Seamless integration using CDI extensions will show multiple NoSQL database can be easily integrated. Pros and cons of using Hibernate OGM for NoSQL persistence will be discussed. Migration of the app from local development environment to OpenShift 3 will be explained by deploying JBoss EAP and a NoSQL database. Best practices for packaging your NoSQL applications for OpenShift will be explained as well.


Title: Event Sourcing and CQRS
Abstract: TBD


Title: How to Sell Open Source
Abstract: Open Source has changed the way we build, package, and sell software. It improves the speed of innovation that allows to iterate and innovate faster than proprietary counterparts. Communities that arise around open source projects are inherently helpful, easy and free to engage. Open source is often dramatically less expensive than proprietary software. Everything in Open Source is done transparently – source code, builds, discussions, issues, features, etc. But if the build is out available publicly then why do I care about paying for this software? More importantly, how do enterprises run business on this “freely” available software. Open Source breaks the traditional sales cycle that is still prominent in closed-source and proprietary software. This talk will compare and contrast how to sell open source software as opposed to proprietary. Attendees will learn why developer adoption is a key part of open source selling, and how it leads to enterprise adoption and that leads to enterprise sales. Different methodologies for developer and enterprise adoption will be explained. A significant shift in sales person approach is required, and will be explained. Attendees will learn how to explain the benefit of a commercially supported open source software.


Title: Minecraft Modding – Powerful and Simple Way to Teach Java Programming to Kids
Abstract: Kids are addicted to Minecraft. Some of them play several hours every week. This lesson will leverage their domain knowledge and teach them fundamental programming concepts and Java language. After the initial installation, they move on to creating mods like creating an alert when a creeper is spawned, spawn an Ender Dragon when dragon egg is placed, make the skeletons armored and fight with each other, and many others. All this is done using Java programming language in a very easy-to-understand way. This session has been delivered multiple times around the world at different schools, libraries, events to kids with no prior programming knowledge. 8+ year old kids instantly become Java programmers, and do so with lot of excitement and pride. We hope Ted-Ed will help with the global scalability and visibility of this workshop.


Title: The Good, The Bad, The Ugly parts of Developer Advocacy
Abstract: Developer Advocacy means how to make developers know all the cool features of a technology and help them use it effectively. The importance of developers is becoming more prominent in the recent years and so the role is quite critical in adoption of your technology. The job is a lot of fun but also has some pain points. This fun talk will share experience, stories, anecdotes of this role highlighting the good, the bad, and the ugly part of the job.


Title: Docker and Kubernetes Workshop
Abstract: Containers are enabling developers to package their applications (and underlying dependencies) in new ways that are portable and work consistently everywhere? On your machine, in production, in your data center, and in the cloud. And Docker has become the de facto standard for those portable containers in the cloud.

Docker is the developer-friendly Linux container technology that enables creation of your stack: OS, JVM, app server, app, and all your custom configuration. So with all it offers, how comfortable are you and your team taking Docker from development to production? Are you hearing developers say, “But it works on my machine!” when code breaks in production? And if you are, how many hours are then spent standing up an accurate test environment to research and fix the bug that caused the problem?

This workshop offers developers a hands-on session with Docker and Kubernetes. The two part workshop will cover:

Part 1:

– Getting started with Docker
– Creating Docker Hosts
– Running Docker images
– Creating your own Docker images
– Deploying your Docker images to Docker Hub
– Creating multi-container applications using Docker Compose
– Deploying applications to a Docker Swarm cluster
– Using Docker Maven Plugin
– Docker tooling in IDEs
– Monitoring applications running on multiple containers
– CI/CD using Docker Containers

Part 2:

– Getting started with Kubernetes
– Deploying your containers in Kubernetes
– Service, Pods, Replication Controller
– Dynamic Scaling of Clusters
– Health Check


Title: DevOps with Java EE
Duration/Format: 1 hr, slide + code + live demos
Abstract (1): Automated builds/testing, deployment pipelines, CI/CD, single binary are some of the principles of DevOps. Together they allow each commit to be translated into a release candidate. It allows the ability to rapidly, reliably and repeatedly push out enhancements and bug fixes to customers at low risk and with minimal manual overhead. This talk will explain the key concepts of DevOps and Deployment Pipelines. It will show how to setup a deployment pipeline for a Java EE application using PaaS. This will include setting up Jenkins, Nexus, and Sonar. Manual UAT testing and automated functional/integration testing will be part of it. Attendees will learn how to take an application from push-to-production and achieve almost 100% automation.

Abstract (2):  Techniques such as automated builds and testing, continuous integration and continuous deployment allow software to be developed to a high standard and easily packaged and deployed to test environments, resulting in the ability to rapidly, reliably and repeatedly push out enhancements and bug fixes to customers at low risk and with minimal manual overhead. What container-agnostic tools are available for testing, continuous integration and deployment of a Java EE application ?

This talk will start with how to package Java EE application “operating environment” such as Operating System, JVM, Database, dependencies, and other configuration in a reusable format, such as Docker. It explains how to replicate the environment for development, testing, staging, and production minimizing the impedance mismatch between them. A quick overview of Arquillian and how it helps in a automated testing across multiple Java EE containers is shown. How functional testing, code coverage, performance and other aspects for going in to production will be discussed. Using Arquillian against Docker containers will be explained as well. Finally, configuring Jenkins for Continuous Integration and setting up deployment pipelines will show how to take an application from push-to-production and achieve almost 100% automation.


Title: Refactor your Java EE application using Microservices and Containers
Abstract (1): Docker gives PODA or Package Once Deploy Anywhere. It simplifies software delivery by making it easy to build and share images that contain your application code and infrastructure together, managed as onecomponent. Each Docker container is a self-contained microservice that provides isolation, resilience, decoupling, and other benefits. This talk will provide a quick introduction to Docker. It shows how to package an existingJava EE monolith in a Docker image. The application will then be refactored into multiple microservices and assembled together using orchestration. Testing of such applications will be discussed and shown. Design patterns and anti-patterns to create cluster of such applications will be demonstrated and discussed.

Abstract(2): Docker gives PODA or Package Once Deploy Anywhere. It simplifies software delivery by making it easy to build and share images that contain your application’s operating system, i.e. application code and infrastructure together, managed as one component. These images are then used to create runtime containers, provided by Docker. These images can be distributed using Docker Registry.  Each Docker container is a self-contained microservice that provides isolation, resilience, decoupling, and many other benefits.

This talk will provide a quick introduction to Docker images (build time), containers (run time), and registry (distribution). It shows how to take an existing Java EE application and package it as a monolithic application as a single Docker image. The application will then be refactored in to multiple microservices and assembled together using orchestration. Unit and integration testing of such applications will be discussed and shown as well. Design patterns and anti-patterns that show how to create cluster of such applications will be demonstrated and discussed.


Title: Microservices design patterns for Java Applications
Abstract
: Microservices allow to decompose a monolithic application into cohesive and multiple decoupled services. Each service is running in its own process and communicate using lightweight mechanisms, such as HTTP API. These services are built around business capabilities or functional decomposition. Microservice also enables true polyglot architecture – both in terms of language and data. It truly allows you to employ the right tool for the right job. Each service is independently deployable and lends very well to fully automated deployment machinery.

Can you take an existing Java EE application and decompose it into microservices? What tools are required to enable CI/CD? What are different design patterns for microservices? What tools do you need to manage such services? Is the complexity being pushed around from service implementation to orchestration?

This talk will explain some of these concerns and provide guidance on how to leverage microservices in your Java applications.


Title (1): Package your Java EE Application using Docker and Kubernetes
Title (2): Container-ize your Java EE Application
Duration/Format: 1 hr, slide + code + live demos
Abstract: Docker simplifies software delivery by making it easy to build and share images that contain your application’s operating system. It packages your application and infrastructure together, managed as one component. These images are then used to create Docker containers which run on the container virtualization platform, provided by Docker. These images can be distributed using Docker Registry. Kubernetes provides an open source orchestration of Docker containers.

This talk will provide an introduction to Docker images (build time), containers (run time), and registry (distribution). Java EE application require operating system, JDK, database, application server, tuning of different parts of the stack, WAR file, and much more. The talk will explain how to create and publish Docker images that package these components and talk to each other. Design patterns and anti-patterns that show how to create cluster of such applications will be shown. Replicating your development, test, and production environments using Docker images will be shown. Basic terminology of Kubernetes will be introduced. Attendees will learn how Kubernetes’s self-healing mechanism can be used to create cluster of these containers.

The talk will also discuss how to setup an internal registry to share private Docker images.


Title: Docker for Java Developers
Duration/Format: 3 hr, Hands-on Lab
Abstract: Containers are enabling developers to package their applications (and underlying dependencies) in new ways that are portable and work consistently everywhere? On your machine, in production, in your data center, and in the cloud. And Docker has become the de facto standard for those portable containers in the cloud, whether you’re working with Red Hat OpenShift, Amazon Web Services, Google Cloud Platform, or Microsoft Azure.

Docker is the developer-friendly Linux container technology that enables creation of your stack: OS, JVM, app server, app, and all your custom configuration. So with all it offers, how comfortable are you and your team taking Docker from development to production? Are you hearing developers say, “But it works on my machine!” when code breaks in production? And if you are, how many hours are then spent standing up an accurate test environment to research and fix the bug that caused the problem?

This lab offers developers an intro-level, hands-on session with Docker, from installation (including Docker Toolbox on Windows/Mac), to exploring Docker Hub, to crafting their own images, to adding Java apps and running custom containers. It will also explain how to use Kubernetes to orchestrate these containers together. This is a BYOL (bring your own laptop) session, so bring your Windows or OSX laptop and be ready to dig into a tool that promises to be at the forefront of our industry for some time to come.


Title: Docker and Kubernetes Recipes for Java Developers
Duration/Format: 3-hr, slide + code + live demos
Abstract: Containers are enabling developers to package their applications in new ways that are portable and work consistently everywhere. Docker has become the de facto standard for those portable containers in the cloud. Kubernetes provides an open source orchestration of Docker containers. This tutorial will provide an introduction to Docker and Kubernetes. The talk will explain several recipes on how to create and publish Docker images that package Java EE applications. Design patterns and anti-patterns that show how to create cluster of such applications will be shown. Replicating your environments using Docker images will be shown. Attendees will learn how Kubernetes’s self-healing mechanism can be used to create cluster of these containers.


Title: STEMing Kids: One workshop at a time
Abstract: Science, Technology, Engineering and Mathematics, STEM, are vital to the future of our children. The parents and students in our educational systems need to understand and embrace the technology that affects them every day of their lives. Devoxx4Kids is on a global mission to complement the classical schooling system by offering workshops to kids in a fun way. and teaching them computing concepts using Scratch, Greenfoot, Minecraft, Raspberry Pi, Arduino, NAO, Tynker. We will share a path that can be followed by adults to keep kids in their vicinity engaged and build, instead of just play, games. You will learn best practices to organize similar workshops in your local setting and hear tips on opening a local chapter.


Title: Nuts and Bolts of WebSocket
Duration/Format: 3-hr, slide + code + live demos
Abstract:  WebSocket provides a rich and powerful communication channel where client and server can communicate with each other in a standard way. JavaScript API in Web browsers is also quite prevalent making it easier to support it.

Would you like to learn how to build WebSocket applications in Java ? How and where do you deploy these applications ? How do you debug message exchanges ? What to do if WebSocket is not supported in the browser or app server ? What are the concerns around firewall, DNS and routers ? Debugging and Production tips ?

This session is for you! Here is what we’ll cover:

  • Introduction to WebSocket
  • WebSocket using Node.JS
  • WebSocket using Java
  • Embedded WebSocket
  • Securing WebSocket
  • Load Balance WebSocket
  • Pub/Sub over WebSocket (STOMP and MQTT)
  • Surviving Firewall and Proxy
  • WebSocket Debugging
  • WebSocket Production Tips

Title: Lessons learned from real-world Java EE 7 deployments
Duration/Format: 1 hr, slide + code
Abstract: Java EE 7, released over a year ago, introduced several new technologies such as WebSocket, Batch, and JSON. There are already three compliant application servers: WildFly, GlassFish, and Tmaxsoft. NetBeans, Eclipse, and IntelliJ provide extensive tooling support for the APIs. What are the best practices for building and deploying Java EE 7 applications? What to do and not to do? This session takes three Java EE 7 applications running in production and shares lessons learned from each one. It attempts to answer questions such as Is WebSocket ready for production? How do we migrate from Spring Batch to JSR 352 batch? Any change in DevOps? Are additional libraries still needed? Which is more prominent, EJB/JSF or REST/JavaScript?


Title: Code-driven introduction to Java EE 7
Duration/Format: 1-3 hr, slide + code + live demos
Abstract: The Java EE 7 platform is the latest release of the Java EE platform. WebSocket attempts to solve the issues and limitations of HTTP for real-time communication. A new API is added to the platform build WebSocket driven applications. Processing JSON structures is inherent in any HTML5 applications and a new API to parse and generate JSON is being added to the platform. Long awaited Batch Processing API and Concurrency are now added to build applications using capabilities of the platform itself. In addition, JAX-RS 2 adds a new Client API to invoke the RESTful endpoints, allows asynchronous client/server, and server-side content negotiation. JMS 2 is undergoing a complete overhaul to align with improvements in the Java language. This code-driven talk will provide an introduction to the Java EE 7 platform. Don’t miss out on this session to learn all about how to leverage the new and exciting standards in building your next enterprise application.


Title: Fifty features of Java EE 7 in Fifty Minutes
Duration/Format: 1 hr, slide + code
Abstract: The Java EE 7 platform has four new components (WebSocket, JSON-P, batch, and concurrency), three that are significantly updated (JAX-RS, JMS, and EL), and several others that bring significant changes to the platform. As you can imagine, a lot of new functionality has been introduced in the platform. In this fast-paced session, you will learn about 50 new features introduced in the Java EE 7 platform. @ClientEndpoint, chunk-style batch processing, @FlowScoped, @AroundConstruct, @JMSDestinationDefinition, and @Transactional are some of features the presentation covers. It explains each feature with a code snippet and provides details on where and how you can use it in your applications.


Title: Getting your kids interested in programming, robotics, engineering ?
Duration/Format: 1-3 hr, slide + live demos
Abstract: Devoxx4Kids is a worldwide initiative that introduces programming, robotics, and engineering to kids at an early age. This is achieved by organizing events where children can develop computer games, program robots and also have an introduction to electronics. This effort won Duke’s Choice Awards at JavaOne 2013.

This session will share how Devoxx4Kids is engaging kids at an early age and teaching them computing concepts using Scratch, Greenfoot, Minecraft, Raspberry Pi, Arduino, NAO, Tynker. The session will show a path that can be followed by parents to keep their kids engaged and build, instead of just play games. The attendees will learn best practices to organize similar workshops in their local setting. Tips on opening a local US chapter and how to build attendee base will be shared.


 

Be Sociable, Share!

Leave a Reply

Your email address will not be published. Required fields are marked *


6 × = thirty