Abstracts

Current

  1. Compute options for Microservices on AWS
    Amazon Web Services offers a wide range of compute options for developers interested in deploying microservices-based applications. Developers interested in full control and responsibility of the stack can use EC2 and deploy all components from scratch. If you are interested in leveraging containers then you can deploy your applications using Amazon EC2 Container Service or a Kubernetes cluster on AWS. Serverless applications can be deployed using AWS Lambda. The amount of effort, time and resources involved to address Ops concerns such as creating, managing, scaling and updating a cluster differ for each compute option. Similarly, Developer concerns such as application packaging, tooling, service discovery, monitoring, logging, and CI/CD also differ for each compute option. This session will walk you through what it takes to build, deploy and manage a simple microservices based application using these different compute options. You’ll learn when a particular option is well suited, or not for your application. Pros and cons of each option will be discussed as well. Attendees will take home a working code sample for each compute option.
  2. Kubernetes on AWS Workshop
    Kubernetes is a popular cloud-native open-source orchestration platform for container management, scaling and automated deployment. It includes a rich set of features such as service discovery, multi-tenancy, stateful containers, resource usage monitoring, and rolling updates. Some of the questions we will go over are: How do we deploy using infrastructure technologies like CloudFormation and Terraform? How can CLI clients such as kops, kubeadm, juju-charms and minikube be used to interact with Kubernetes? What does a clean CI/CD pipeline look like using AWS? How do we integrate with tools such as Maven? In this code-driven workshop you will learn how to package, deploy, scale, and monitor your Java application using Kubernetes and the AWS cloud.
  3. Serverless for Java Developers
    Serverless computing allows you to build and run applications without the need for provisioning or managing servers. AWS Lambda has changed how developers build and run their applications or services. In this session, you’ll learn how to get started with serverless computing with AWS Lambda, which lets you run code without provisioning or managing servers. We’ll introduce you to the basics of building with Lambda and Java, and how you can benefit from features such as continuous scaling, built-in high availability, integrations with AWS and third-party apps, and subsecond metering pricing. Serverless Application Model and integration with Maven will be explained with live samples. We’ll also introduce you to the broader portfolio of AWS services that help you build serverless applications with Lambda, including Amazon API Gateway, Amazon DynamoDB, AWS Step Functions, Alexa integration and more.
  4. Serverless Architecture Patterns and Best Practices
    Serverless computing allows you to build and run applications without the need for provisioning or managing servers. AWS Lambda has changed how developers build and run their applications or services. But what are the best practices for tasks such as deployment, monitoring, and debugging in a serverless world? In this session, we’ll dive into best practices that serverless developers can use for application lifecycle management, CI/CD, monitoring, and diagnostics. We’ll talk about how you can build CI/CD pipelines that automatically build, test, and deploy your serverless applications using AWS CodePipeline, AWS CodeBuild, and AWS CloudFormation. We’ll also cover the built-in capabilities of Lambda and API Gateway for creating multiple versions, stages, and environments of your functions and APIs. Finally, we’ll cover monitoring and diagnostics of your Lambda functions with Amazon CloudWatch and AWS X-Ray.
  5. 10 ways to run a Kubernetes cluster on AWS
    There are multiple ways to create, start, and scale a Kubernetes cluster on Amazon Web Services. There are pre-built CloudFormation templates and Terraform modules. You can use graphical installers like Tectonic or pre-built Amazon Machine Images like the one from Weaveworks. CLIs such as kops, kubeadm and juju-charms can be used for those that feel more powerful on the command-line. This session will provide a quick overview of 10 different ways to run a Kubernetes cluster on AWS. In each case, create, scale and shutdown of the cluster will be shown. Pros and cons of each approach will be explained in an unopinionated way. A simple application will be deployed to each Kubernetes cluster as well. Attendees will get an overview of different ways to start a Kubernetes cluster on AWS.
  6. Build, Debug and Deploy your first Chatbot
    Chatbots are computer programs that interact via auditory or textual methods. They can be integrated in any chat service like Slack or Facebook Messenger. You can talk to them using SMS. You can even converse with them using Alexa. This talk will explain how I built first chatbot for our Star Wars-struck family. Attendees will learn the key components required for a chatbot. A fully functional chatbot built using Java Serverless backend and multiple frontends such as Alexa, SMS and Slack will be explained. Attendees will learn how to publish their first Alexa skill set. Choice of technologies, development tools and debugging techniques will be explained. Attendees will be able to ask their Star Wars question live during the session.
  7. Package your Java applications using Docker, Kubernetes and EC2 Container Service
    So you are a Java developer but do you understand how to containerize your existing application? Docker nicely complements Java programming model by allowing to package all your libraries, dependencies and configuration as an image. But how do you run multiple containers across multiple hosts? This tutorial explains how to package, deploy, and scale Java applications using different orchestration frameworks. Attendees will learn how to deploy the same application to Docker Swarm, Kubernetes and EC2 Container Service.
  8. Build, Deploy, Debug and Tune Serverless Microservices
    Traditional development and debugging methods don’t work as well for serverless environments and microservice-based applications. Multiple independent components built using different languages and running on different environments are a real-life story. In this talk we’ll build, deploy, and debug (in that order) a serverless microservice-based application. An end-to-end view of requests as they travel through your application will be shown. The attendees will learn how to easily construct an intelligent continuous integration and deployment pipeline. We will encourage the audience to participate in breaking and fixing our application. Attendees will learn how to troubleshoot the root cause of performance issues and errors.
  9. Efficient Java Container Deployments using AWS EC2 Container Service and Registry
    Amazon EC2 Container Service (ECS) is a highly scalable, high performance container management service that supports Docker containers. Together with EC2 Container Registry, it allows you to easily run applications on a managed cluster of Amazon EC2 instances. This session will cover how to build, deploy and scale Java applications container using ECS, without a need to install, operate, and scale your own cluster management infrastructure. You’ll learn different deployment strategies and autoscaling to efficiently and cost effectively run your Java applications in the AWS cloud. Integration with AWS features like IAM roles for security, and the new Application Load Balancer for service discovery will be discussed for Java applications.
  10. Docker for Java Developers: Design Patterns and Anti-Patterns
    There are plenty of newbie tutorials available for Java developers to package their applications using Docker. This session will dig deeper into the topics that matter to Java developers. In this talk, Fabiane Nardon and Arun Gupta, two Java Champions, will explain how to build, package, deploy, run, scale, test, debug, and monitor their Java applications packaged using Docker.Design patterns and anti-patterns for the following topics will be covered, with examples from real-life:- Which Java base image to use?
    – Deploy your Java application using Maven or Gradle
    – Multi-container application and service discovery
    – Scale your application using Docker for AWS
    – Memory management
    – Debugging
    – Build a deployment pipeline
    – Integration testing
  11. Service Discovery in Container Orchestration Frameworks
    Service registration, discovery and horizontal scalability are key operational requirements of a microservice architecture.Each service needs to replicate. A standard mechanism by which services can easily scale up and down based upon metadata is important. The exact address of a service may not be known until the service is deployed and ready to be used. The dynamic nature of a service’s endpoint address is handled by service registration, discovery and a load balancer. This is all the more important in a containerized world where each container is like a cattle.Docker, Kubernetes, DC/OS and ECS are commonly used container orchestration platforms. They all have built-in support for service discovery and scalability. This talk will explain how this requirement of microservices are met in these orchestration frameworks. Specifically, configuration files for three microservices talking to each other will be shown and explained for the different frameworks.
  12. Container Orchestration Platforms on Amazon
    Amazon Web Services provides a wide range of services and features for building, deploying and managing applications on the cloud. Docker is the developer-friendly image format and runtime that simplifies package and deployment of your application stack. A typical application is defined with multiple containers and deployed across multiple hosts.This session will show how a simple multi-container multi-host application can be deployed using different different container orchestration platforms on AWS. Attendees will learn the recipes, design patterns and anti-patterns in this code-intensive session of different container platforms. Specifically, the following platforms that will be covered:* Docker Swarm
    * Amazon EC2 Container Service
    * Kubernetes
    * DC/OSThe session will start with a brief introduction to an orchestration platform. It will then explain how each platform can be easily started on Amazon Web Services. A simple multi-container multi-host application will then be deployed to each platform. Pros and Cons of each orchestration platform will be shared.
  13. Deploy your microservice using Amazon Web Services S3, API Gateway, Lambda and Couchbase
    Serverless applications, aka Function-as-a-Service or FaaS, relies upon services to manage server-side logic and state. These applications run in stateless compute containers that are event-triggered, ephemeral (may only last for one invocation), and fully managed by a 3rd party. These functions can be triggered by a REST API call, scheduled timer, or another function. Static website hosting on Amazon Web Services S3, API Gateway for RESTful APIs, AWS Lambda for functions and Couchbase for persistence provide an ideal combination for deploying, managing and scaling your microservice. This talk will provide a quick introduction to each part of the stack. Then it will explain how a Serverless Application Model can be used to deploy different components of microservice. A path from your favorite IDE to a fully deployed and functional microservice will be shown with live coding.
  14. Serverless Architecture Patterns and Best Practices (AWS specific)
    Serverless computing allows you to build and run applications without the need for provisioning or managing servers. AWS Lambda has changed how developers build and run their applications or services. But what are the best practices for tasks such as deployment, monitoring, and debugging in a serverless world? In this session, we’ll dive into best practices that serverless developers can use for application lifecycle management, CI/CD, monitoring, and diagnostics. We’ll talk about how you can build CI/CD pipelines that automatically build, test, and deploy your serverless applications using AWS CodePipeline, AWS CodeBuild, and AWS CloudFormation. We’ll also cover the built-in capabilities of Lambda and API Gateway for creating multiple versions, stages, and environments of your functions and APIs. Finally, we’ll cover monitoring and diagnostics of your Lambda functions with Amazon CloudWatch and AWS X-Ray.
  15. Serverless Architecture Patterns and Best Practices
    Serverless applications, aka Function-as-a-Service or FaaS, relies upon services to manage server-side logic and state. These applications run in stateless compute containers that are event-triggered, ephemeral (may only last for one invocation), and fully managed by a 3rd party. Serverless applications have significant differences to how we typically think about technical architecture. This session will provide an overview of the key characteristics of a serverless application. It will compare and contrast FaaS with PaaS, CaaS and SaaS. Best practices and deployment architectures for typical applications such as microservices-based application, batch processing, edge computing and mobile applications will be discussed. Cross-cutting application concerns such as security, transactions, and logging will be explained as well. Attendees will learn how serverless applications are different from their server-based counterpart.
  16. Docker Swarm or Kubernetes - Pick your framework! (DevoxxUS)
    Docker and Kubernetes are two very competent, and one of the most heavily used, container orchestration frameworks. This code-driven session will compare and contrast Docker Swarm and Kubernetes on the following aspects:
    • Local development
    • Deployment options
    • Multi-container applications
    • Service discovery
    • Scaling service
    • Run-once jobs
    • Maven integration
    • Rolling updates
    • Creating a Couchbase cluster

    Attendees will have a clear understanding of what each orchestration framework has to offer. They will also learn techniques for using these platforms effectively.

  17. Docker for Java Developers (Docker Meetup)
    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:
    • Docker 101
    • 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
    • Deploy your Java application using Maven
    • Deploy your application using Docker for AWS
    • Scaling Java services with Docker Engine swarm mode
    • Develop/deploy your application using NetBeans, Eclipse and IntelliJ
  18. Kubernetes for Java developers (DevoxxUS?)
    Kubernetes is an open-source opinionated container orchestration frameworks. It provides features like service discovery, manual and metrics-driven scalability, rolling updates, multi-tenancy, and stateful containers. This is all achieved by simply Create, Read, Update and Delete (CRUD) of resources defined in Kubernetes cluster.How do you package your Java application using Kubernetes? What are your development and deployment options? How does it integrate with Maven? How do you create volumes that outlive container restarts? How do you easily create a CI/CD pipeline for Java applications deployed to Kubernetes?This code-driven session shows how to package, deploy, scale and manage your Java application using Kubernetes.
  19. Service Discovery and Scalability using Docker Engine and Kubernetes (NGINX Meetup)
    Service registration, discovery and horizontal scalability are key operational requirements of a microservice architecture.Each service needs to replicate. A standard mechanism by which services can easily scale up and down based upon metadata is important. The exact address of a service may not be known until the service is deployed and ready to be used. The dynamic nature of a service’s endpoint address is handled by service registration, discovery and a load balancer. This is all the more important in a containerized world where each container is like a cattle.Docker Engine and Kubernetes are two primary container orchestration platforms. They both have built-in support for service discovery and scalability. This  talk will explain how Swarm mode in Docker Engine and Kubernetes support these requirements of microservices.
  20. Docker Container Orchestration Platform on Amazon EC2 (AWS Re-Invent?)
    Amazon EC2 is the de facto IaaS platform for running distributed applications across multiple hosts. 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. A typical application is defined with multiple containers and deployed across multiple hosts. This session will show a simple multi-container multi-host application can be deployed using different container orchestration platforms on EC2.Attendees will learn the recipes, design patterns and anti-patterns in this code-intensive session of different container platforms. Specifically, the following platforms that will be covered:
    • Amazon EC2 Container Service
    • Docker Swarm
    • Kubernetes
    • DC/OS

    The session will start with a brief introduction to an orchestration platform. It will then explain how each platform can be easily started on Amazon EC2. A simple multi-container multi-host application will then be deployed to each platform.

    The session will conclude with a compare and contrast of different container orchestration platforms on EC2.

  21. 10 Technologies Changing Developer's Landscape (GIDS)
    Technology landscape is changing faster than ever. New technologies have been introduced in the recent years that have caused a complete disruption in application development lifecycle. It is very imperative for companies to adopt these technologies to stay competitive in the current market. They allow the projects to be delivered in a faster, cheaper and more efficient manner. Technologies that were only seen in sci-fi movies until now have have started becoming a reality as well. They will pave the way for a new immersive experience that will change the way we’ll interact with life around us. This keynote will provide an overview of top 10 technologies that are impacting the application development landscape of today and tomorrow.
    • Digital Economy
    • Containers (Docker, Kubernetes, Mesos)
    • Microservices
    • DevOps
    • CI/CD
    • Machine Learning
    • Drones
    • IoT
    • Virtual Reality
    • Automobiles

Old

  1. Performance Monitoring Kubernetes in Production
    Kubernetes offers a production-grade container orchestration system. An application deployed in Kubernetes typically consists of multiple pods/containers spread across several hosts. Pods may terminate for several reasons and may be rescheduled on a different host. Pods belonging to a Service may scale up and down to meet scalability requirements of the application. Continuous monitoring of application is critical so that bottlenecks can be identified, and if needed, a corrective action can be taken. What does Kubernetes offer for application monitoring? What is the right granularity for monitoring – application, services, pods or containers? What other tools are available?This talk will provide an introduction to performance monitoring in Kubernetes. It will show how the in-built stack of Heapster, InfluxDB, Grafana can be used for monitoring applications. Common open source and commercial tools that provide extensive Kubernetes monitoring will be discussed. Pros and cons of each of the tools will be explained in detail. Application monitoring for a typical application with Java and a database will be shown. Attendees will be able to leverage the tools and recipes shown in their daily work life.
  2. Migrate your traditional VM-based clusters to Containers (Devoxx BE)
    Software-defined infrastructure is changing the way applications are deployed. There are multiple ways to create scalable architecture using containers. This action-packed and code-driven session will share learnings from running a scalable Couchbase cluster in different containers framework.Attendees will learn how classical cluster creation on VMs is mapped to each of the framework.  You’ll learn the recipes, design patterns and anti-patterns for deploying your own applications on the following frameworks:
    • Docker Cloud
    • Kubernetes on Google Cloud/Amazon
    • Red Hat OpenShift
    • Mesos + Marathon

    You will pick up nuggets of information that will make you productive by deploying your applications easily using containers.

  3. NoSQL Data Modeling for Relational Developers
    Common business requirements around data are data modeling, flexibility, storage, replication, querying and indexing. In a relational database world, these are captured using tables, rows, primary key, foreign key, integrity constraints , ACID, sharding and other techniques. NoSQL databases offer similar advantages but require a different way to think.
    In this talk we’ll look how best to plan, model and maintain your data using a NoSQL document database. By diving into real world case studies, we’ll look at the three main things you need to know about modeling your data in a document database: document design, key design and querying. Attendees will be ready to start taking their relational applications and migrate them over to NoSQL with real benefits.
  4. Nuts and Bolts of Docker (Devoxx BE)
    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 and related orchestration frameworks.Outline:
    • Docker 101
    • Running first application with Docker
    • Package application with Docker
    • Sharing application using Docker Hub
    • Package application as Docker multi-container applications
    • Deploy Java application using Maven/Docker
    • Deploy application on Linux/Docker and Windows Server 2016/Docker
    • Deploy application using Docker Cloud
    • Deploy application using Kubernetes
    • Deploy application using Mesos + Marathon
    • Deploy application using Rancher
    • Develop/deploy application using NetBeans, Eclipse and IntelliJ
  5. Create a NetBeans plugin in 60 minutes (JavaOne)
    NetBeans IDE is built on NetBeans platform. The platform contains APIs that allows to extend the functionality of IDE by creating plugins.This session will explain how to create a NetBeans plugin in 60 minutes. Entry point to the plugin, node hierarchy and API classes will be explained. Building, testing and releasing the plugin will be discussed.A pre-built plugin that shows how to configure a Minecraft server in NetBeans will be shown. Another plugin that shows how to add support for Couchbase database will be built during the talk. Clear handoff between the plugin the Couchbase API will be explained.Attendees will be ready to create a plugin of their choice after attending this session.
  6. Mobycraft: Manage Docker containers using Minecraft (JavaOne)
    Mobycraft is a Minecraft client-side mod to manage Docker containers using Minecraft. This mod can be installed in any standard Minecraft client and allow young kids to learn Java and Docker fundamentals in a fun way. It allowed a 13-year old boy to apply his Minecraft modding and Java skills to pick up Docker concepts.Each container can be started and stopped from Minecraft. Similar containers are grouped together using color coding. Several Docker commands are exposed as new Minecraft commands.Guice DI was used to allow injection of multiple Docker implementations such as Docker Remote API and Titus/Netflix.This project allowed a Java Champion and a Docker Captain father to have a bonding experience with his Minecraft loving son.
  7. Docker for Java Developers (JavaOne)
    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 do you understand how to containerize your existing application?Docker nicely complements Java programming model by allowing to package all your libraries, dependencies and configuration as an image. Are Java containers on Linux the same on Windows containers?This tutorial explains how to get started, package, deploy, and scale Java applications using Docker. Attendees will learn how Docker can be integrated in your toolchain. Different orchestration frameworks will be compared by deploying the same application to each one of them.
  8. Docker for Java Developers (DockerCon)
    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:
    • Docker 101
    • 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
    • Deploy your Java application using Maven
    • Deploy your Java application on Linux and Windows Server 2016
    • Deploy your application using Docker Cloud
    • Deploy your application using Kubernetes
    • Deploy your application using Mesos + Marathon
    • Develop/deploy your application using NetBeans, Eclipse and IntelliJ
  9. Docker support in NetBeans, Eclipse and IntelliJ
    A typical tool chain of Java developer consists of an Integrated Development Environment (IDE) such as NetBeans, Eclipse, or IntelliJ. These IDEs assist in easily writing and debugging the Java application. They also provide features like syntax highlighting and code completion, which makes the developer more effective.All three IDEs provide support for building, pulling and pushing Docker images and running containers. This allows you to run your application or database server as Docker container from within the IDE itself.This live coding session will show the current state of Docker support in the three IDEs.
  10. Mobycraft - Docker in 8-bit (Docker meetup)
    Mobycraft is a Minecraft client-side mod to manage and visualize Docker containers in Minecraft. This mod can be installed in any standard Minecraft client and allow young kids to learn Docker fundamentals in a fun way. It allowed a 13-year old boy to apply his Minecraft modding skills to pick up Docker concepts such as Engine, Machine, Swarm, and Remote API.A new custom Minecraft block and structure was created to show multiple containers running in a multi-host and multi-cloud environment. Each container can be started and stopped from Minecraft. Similar containers are grouped together using color coding and displayed in a Minecraft world. Several Docker commands are exposed as new Minecraft commands.As the mod evolved, more advanced Docker concepts such as Docker monitoring and a heat map of Docker containers was created. A new Minecraft dimension, with custom look and feel, was created for containers.This project became a great bonding experience between a father and a son. It allowed them to engage in fun and geeky conversations, such as code reviews and tooling discussion, and thereby building memories for a lifetime.Key Learnings:
    • Docker is simple to understand for a 13-year old kid
    • How Minecraft modding can be applied to visualize Docker containers
    • How they can encourage kids to contribute code to this effort and introduce them to Docker concepts
  11. Minecraft Modding – Powerful and Simple Way to Teach Java Programming to Kids (MakerFaire)
    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.
  12. N1QL: SQL for JSON (GIDS)
    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!
  13. Full-stack document database
    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.
  14. Thanks Managers! (Ignite)
    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.
  15. Kubernetes for Java Developers (KubeCon)
    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
  16. Docker for Java Developers (DockerCon)
    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
  17. How to use Compose, Machine and Swarm to simplify your complex deployments (DockerCon)
    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
  18. Full-stack Reactive Java Application using Docker (JavaOne)
    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.

  19. Getting Started with NoSQL using JBoss EAP 7 and OpenShift 3
    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.
  20. How to Sell Open Source
    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.
  21. Minecraft Modding - Powerful and Simple Way to Teach Java Programming to Kids (Ted Ed)
    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.
  22. The Good, The Bad, The Ugly parts of Developer Advocacy
    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.
  23. Docker and Kubernetes Workshop
    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 ContainersPart 2:- Getting started with Kubernetes
    – Deploying your containers in Kubernetes
    – Service, Pods, Replication Controller
    – Dynamic Scaling of Clusters
    – Health Check
  24. Package your Java EE Application using Docker and Kubernetes
    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.
  25. Docker for Java Developers
    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.
  26. Docker and Kubernetes Recipes for Java Developers
    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.
  27. 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.

  28. ARCHIVE

    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 one component. 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: 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!
  • Tweet

Leave a Reply

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