Machine Learning Workshop

Machine Learning is all the rage, but many developers have no idea what it is, what they can expect from it or how to start to get into this huge and rapidly-changing field. The ideas draw from the fields of Artificial Intelligence, Numerical Analysis, Statistics and more. These days, you'll generally have to be a CUDA-wielding Python developer to boot. This workshop will gently introduce you to the ideas and tools, show you several working examples and help you build a plan to for diving deeper into this exciting new field.

We will cover:

• The differences between data science, AI and machine learning
• The Five Tribes of Machine Learning (as defined by Pedro Domingos)
• Walkthroughs of some of the main algorithms
• Examples in Java, R and Python
• Tools such as Tensorflow and Pytorch
• The impact of GPUs on machine learning
• Stories about how companies are being successful with machine learning
• A discussion about the likely impacts of machine learning on the job market and society

Kubernetes for Developers - 3 Day Deep Dive

At the end of this workshop, you will be comfortable with designing, deploying, managing, monitoring and updating a coordinated set of applications running on Kubernetes.

Distributed application architectures are hard. Building containers and designing microservices to work and coordinate together across a network is complex. Given limitations on resources, failing networks, defective software, and fluctuating traffic you need an orchestrator to handle these variants. Kubernetes is designed to handle these complexities, so you do not have to. It's essentially a distributed operating system across your data center. You give Kubernetes containers and it will ensure they remain available.
 
Kubernetes continues to gain momentum and is quickly becoming the preferred way to deploy applications.
 
In this workshop, we’ll grasp the essence of Kubernetes as an application container manager, learning the concepts of deploying, pods, services, ingression, volumes, secrets, and monitoring. We’ll look at how simple containers are quickly started using a declarative syntax. We'll build on this with a coordinated cluster of containers to make an application. Next, we will learn how Helm is used for managing more complex collections of containers. See how your application containers can find and communicate directly or use a message broker for exchanging data. We will play chaos monkey and mess with some vital services and observe how Kubernetes self-heals back to the expected state. Finally, we will observe performance metrics and see how nodes and containers are scaled.
 
Come to this workshop the learn how to deploy and manage your containerized application. On the way, you will see how Kubernetes effectively schedules your application across its resources.

Optionally, for more daring and independent attendees, you can also replicate many of the exercises on your local laptop with Minikube or Minishift. There are other Kubernetes flavors as well. However, if during the workshop you are having troubles please understand we cannot deviate too far to meet your local needs. If you do want to try some of the material locally this stack is recommended:

• Linux, Windows 10 or MacOS laptop with 4 core processor (I7 equivalent) 16 gig memory. Ensure your CPU virtualization BIOS switch is turned on. Some company issued laptops may lock this access.
• Preinstall the latest versions of Minikube, KubeCtl, and Helm.
• Minikube works best with a recent version of VirtualBox.

Some of the topics we will explore:

• Using Minikube, KubeCtl and Helm
• Kubernetes Architecture and terminology
• Resilience with declarative states and the reconciliation loop
• Kubernetes REST API
• Components: Etcd, Scheduler, Controller, Kubelet
• Namespaces
• Kinds: Pod, Service, Deployment, ReplicaSet, Ingress
• Labels and selectors
• Etcd, ConfigMaps, Secrets
• Volumes and mounts
• Ingress
• Helm and charts
• Container patterns
• Probes, Logging, monitoring, and troubleshooting
• Scaling
• Standard and custom resources
• Operators
• Istio
• Kubernetes ecosystem for software engineers

These concepts are presented and reinforced with hands-on exercises:

• Advantages of distributed computing
• History and rise of Kubernetes
• Cloud native computing foundation
• Architecture and terms and how it works
• Deploying and running applications
• Kubernetes objects - Deployment, Pods, ConfigMaps, Jobs, Secrets, Ingress, Volumes and many more
• Container patterns
• Serverless
• Istio Meshing
• Monitoring

You will leave with a solid understanding of how Kubernetes actually works and a set of hands-on exercises your can share with your peers. Bring a simple laptop with a standard browser for a full hands-on experience.

Agility Through Modular Architectures - From Modular Monoliths to Microservices

No single architectural style solves all needs. Though microservices have taken the developer community by storm recently, they are not always the optimal solution. In some cases, a more monolithic architecture may be more suitable short term. Or perhaps a more traditional system of web services that allow you to leverage existing infrastructure investment is preferable. Fortunately, proven architectural practices allow you to build software that transcends specific architectural alternatives and develop a software system that gives the development team the agility to shift between different architectural styles without undergoing a time-consuming, costly, and resource intensive refactoring effort. Modularity is the cornerstone of these alternatives.

In this workshop, we will examine the benefits and drawbacks of several different modular architecture alternatives and we’ll explore the infrastructure, skills, and practices necessary to build software with each of these alternatives. There will be straightforward exercises and demonstrations that show the alternatives and how to create software that provides the architectural agility to easily shift between architectural alternatives.

Topics discussed include:

• Defining architectural agility
• Dissecting the monolith
• Exploring microservices
• Other architectural alternatives, including traditional web services
• Development infrastructure requirements
• Measuring architectural integrity

Building Serverless Applications in AWS Workshop

Tired of trying to manage and maintain servers? Never have a large enough operations team? Don’t have a budget for running lots of server? Don’t want to pay for servers siting idle? Afraid you might become so popular that you won’t be able to scale fast enough? Don’t worry, it is possible to alleviate these issues by moving to a serverless architecture that utilizes microservices hosted in the cloud. This type of architecture can support all different types of clients including web, mobile and IoT.

During this hands-on workshop, you will build a serverless application utilizing AWS services such as Lambda, API Gateway, S3 and a datastore.

During this session you will build a simple web application utilizing AWS services and Angular.

Domain-Driven Design Workshop

New architectural paradigms like microservices and evolutionary architecture, as well as the challenges associated with managing data and transactional contexts in distributed systems, have generated a renewed interest in disciplined software design and modular decomposition strategies. We know that the secret to obtaining the benefits of these architectures is getting the boundaries right, both at the team and the component/service level! Fortunately, there is a mature, battle-tested approach to system decomposition that is perfect for these architectures: Domain-Driven Design.

In this workshop, we'll cover the following topics:

• Why DDD?
• The Importance of the Ubiquitous Language
• Strategic Design: Bounded Contexts, Subdomains, and Context Mapping.
• Tactical Design: Aggregates, Entities, and Domain Events.
• A powerful team modeling technique: Event Storming
• Using DDD in the context of Agile software methodologies
• DDD combined with technical architectures: Hexagonal, Microservices, REST, Event-Driven, Event Sourcing/CQRS, etc.

You'll leave the workshop with a solid understanding of DDD and how it can help you best decompose your domain and business capabilities so that you can be more effective with modern architectures.

Angular (with TypeScript) Workshop

Angular brings together some of the most promising new technologies in the web space like Components, Observables, Window.fetch all the while bundling together a set of “best” practices like dependency injection in one development stack. If you are looking to build powerful single page applications then Angular is your friend. In this workshop we will start from the ground up, and build our way through a simple application that will let us explore the various constructs, and the familiarize ourselves with some of the new terminology in Angular.

This session will focus on Angular 12

In this workshop we will get down and dirty with Angular. In this workshop we will start with the very basics of how to bootstrap our Angular application, and work slowly towards making REST-ful AJAX requests to a backend. List of topics include

• Creating Angular components
• The nuts and bolts of NgModule
• Creating component hierarchies
• Using the Angular style guide for naming and project layout
• Directives like *ngFor
• @Inputs and @Outputs
• Services
• Dependency Injection
• The component lifecycle
• Ajax using Http and Observables
• Smart vs. Dumb components
• Routes, routing, and the router-outlet

Along the way we we prescribe to some established practices like directory structure, naming, and some tricks to make our development life easier.

Practical Refactoring - Tiny Steps to Better Code

The goal: Clean Code That Works, and getting there is half the fun. Working with a legacy mess can be frustrating, boring, dangerous, and time-consuming. When FIBS occur (FIBs = Fixes that Introduce Bugs) you often enter an endless Test and Fix cycle that can quickly escalate into a nightmare. I've been there, you've been there. How do we return to pleasant dreams?

In this code-centric workshop we'll look at ways to introduce sanity and calmness into the process of maintaining and improving buggy, poorly written, poorly designed code. Few slides, mostly code. Learn how to turn any project around and have fun doing it.

Getting up to Speed With Java 9

Java 9 is by far the most significant update of the Java language. We can view Java 9 changes in three parts: improvements, additions, and advances. Quite a few things we could do in Java 8 or earlier have been improved, there are a few new additions, and of course the most noted change the module system or Jigsaw.

In this hands-on workshop we will give into all these three areas, discuss the significance, look at code examples, and most important practice the concepts using concrete exercises. At the end of this workshop you will be able to gauge the efforts necessary for your project to successfully adopt and make use of Java 9.

VueJS [1]: The last front-end framework you will ever need

VueJS is the new contender for 'best front end framework' and is running a very close second place to React in popularity amongst knowledgable developers. It is gaining mindshare and has incredible momentum, all for very good reasons!

Join us for this introductory, full day workshop in which we fully explore everything that makes VueJS the last framework you will ever learn … because you won't ever want to use anything else again!

Upon completion, you will be armed with the skills and knowledge to create sophisticated VueJS components that:

• Define and use dynamic data constructs
• Dynamically update data views, content and styling based on realtime changes to data
• Animate transitions between views as well as when elements are added and removed from the view
• Define and dynamically invoke event handlers generated by UI elements
• Use Vuetify: amazing, mature and visually appealing UI widget library based on Material Design
• Install, configure and use the Vue Router.
• Install, configure and use Vuex to provide centralized application data management a la Redux

We will also explore deployment options and productionization of your application.

I look forward to sharing this amazing new contender in the front-end SPA framework space!

Streaming Data with Apache Kafka

The toolset for building scalable data systems is maturing, having adapted well to our decades-old paradigm of update-in-place databases. We ingest events, we store them in high-volume OLTP databases, and we have new OLAP systems to analyze them at scale—even if the size of our operation requires us to grow to dozens or hundreds of servers in the distributed system. But something feels a little dated about the store-and-analyze paradigm, as if we are missing a new architectural insight that might more efficiently distribute the work of storing and computing the events that happen to our software. That new paradigm is stream processing.

In this workshop, we’ll learn the basics of Kafka as a messaging system, learning the core concepts of topic, producer, consumer, and broker. We’ll look at how topics are partitioned among brokers and see the simple Java APIs for getting data in and out. But more than that, we’ll look at how we can extend this scalable messaging system into a streaming data processing system—one that offers significant advantages in scalability and deployment agility, while locating computation in your data pipeline in precisely the places it belongs: in your microservices and applications, and out of costly, high-density systems.

Come to this workshop to learn how to do streaming data computation with Apache Kafka!

Building Evolutionary Architectures Workshop

This workshop highlights the ideas from the forthcoming Building Evolutionary Architectures, showing how to build architectures that evolve gracefully over time.

An evolutionary architecture supports incremental, guided change across multiple dimensions.

For many years, software architecture was described as the “parts that are hard to change later”. But then microservices showed that if architects build evolvability into the architecture, change becomes easier. This workshop, based on my upcoming book, investigates the family of software architectures that support evolutionary change, along with how to build evolvable systems. Understanding how to evolve architecture requires understanding how different parts of architecture interact; I describe how to achieve appropriate coupling between components and services. Incremental change is critical for the mechanics of evolution; I cover how to build engineering and DevOps practices to support continuous change. Uncontrolled evolution leads to undesirable side effects; I cover how fitness functions build protective, testable scaffolding around critical parts to guide the architecture as it evolves.

The software development ecosystem exists in a state of dynamic equilibrium, where any new tool, framework, or technique leads to disruption and the establishment of a new equilibrium. Predictability is impossible when the foundation architects plan against changes constantly in unexpected ways. Instead, prefer evolvability over predictability. This hands-on workshop provides a high-level overview of a different way to think about software architecture.

Outline:

• Architecture Dimensions
• Engineering Incremental change
• Architectural Characteristics
• Exercise: determine appropriate characteristics
• Identifying Architectural Patterns
• Exercise: components and patterns
• Identifying Fitness Functions
• Exercise: determining fitness functions
• Retrofitting Existing Architectures
• Building Evolvable Architectures

Threat Intelligence Fundamentals

This course will cover the foundations of threat intelligence. It will consist of a combination of lecture and lab where we will work through the concepts of detecting indicators of attack and compromise, and building automation to process and eliminate it. This is a fully immersive, hands on workshop that will include a number of techniques, tools, and code.

It will cover the following topics:

• Threat Identification
• Threat Containment and Control
• Bot Detection and Search Engine Verification
• Indicators of Attack vs Indicators of Compromise
• Fingerprinting
• Production Deployment of Threat Intelligence Systems

Attendees will leave with a fully functional threat intelligence proof of concept system. This PoC can be used to design further capabilities or to evaluate larger commercial systems. Be prepared for an exciting day of code, modeling, and automation.

"Alexa, Make Me Rich!": Smart speaker and BOT development workshop.

Engaging your users has never been more important than it is today. Competition for user attention is fierce and ruthless. There are new players on the field, however, that are changing the competitive landsacpe: Smart Speakers and Internet Robots BOTs provide channels to engage and interact with your users in amazing new ways that we never before thought possible. Join us for this deep dive into the technologies, architectural and design patterns you will need to be successful in this new space. This is a hands-on workshop in which we will develop, deploy and secure test a number of fully functional applications and experiment engaging with them using Alexa, Google Home, Facebook Messenger and other user engagement channels.

Amazon Echo, Google Home and Apple HomePod … The Home Smart Speaker revolution has begun! Join us for an exciting workshop in which we will develop skills that can be used on each of these platforms!Learn how to design, author and publish BOT-style applications for use with chat clients, Amazon Echo, Google Home and other BOT-ready platforms. Learn why these technologies represent the future of how users will interact with merchants and services on the web. Don't be left behind! Get a head start on the next wave and add this amazing set of skills to your resume with this comprehensive, fun and exciting workshop!

In the 60s and 70s, we used heavy iron, client server applications running on mainframes, accessed through terminals. In the mid-80s, we switched to heavy-weight applications which you purchased and installed on your PC. Next, in the mid-90s, we collectively bought-in to web-based applications. The turn of the century brought us into the world of mobile apps running on hand-held devices in the mid 00s. A decade later, we are due for the next evolution in delivering knowledge and services to our end users. Enter the BOT!

Join me in this workshop as we explore this new and exciting world of internet robots (or BOTs, for short). We will cover the history of this new kid on the tech block, the tools available to assist you in building and deploying BOTs and we will design, build and deploy a number of BOTs and have them interact with you live via the Facebook messenger app, Amazon Alexa and Google Home devices.

Don't wait. Future-proof your skill set today and learn how to attract, engage, retain and amaze your users!

12 (15) Factor App Workshop

Learn how to use Heroku's 12 (15) Factor App methodologies to make your applications more portable, scalable, reliable and deployable.

Do you want to improve your application’s portability, scalability, reliability and deploy ability? Now you can, with Heroku’s 12 Factor App methodologies. Learn from their experience hosting and supporting thousands of apps in the cloud. During this hands-on workshop, you will learn how to incorporate factors like configuration, disposability, dev/prod parity and much more into an existing application whether it is an on premise or cloud native app. But wait, there’s more! Act now, and get an additional 3 factors absolutely free! API first, Telemetry and even Authentication and authorization will be included at no additional cost.

Accelerated Gradle

The Gradle build tool has been adopted by the vast majority of open source projects and is growing rapidly in industry as well. Gradle provides a powerful DSL for customizing and managing your build, with flexible configuration features and sophisticated dependency management. Gradle is also actively supported by a commercial entity, and in partnership with companies like Netflix and LinkedIn is currently being optimized for performance.

Topics will include:

• Projects and tasks
• Initialization, configuration, and execution times
• File system capabilities
• Incremental builds
• Script and binary plugins
• Dependency management
• Multi-project builds
• Build scans
• The build cache
• Creating your own plugin

Build Modular, Standards-Based Progressive Web Apps

Web Components change the way you build web applications and think about front-end architecture. Finally, web developers have a sane way to scope and modularize not just their JavaScript, but also the HTML5 and styling. The approach is elegant, encourages compatibility between frameworks, and piggybacks on the web browser's success as an open and extensible runtime. The Polymer framework demonstrates how frameworks can and should evolve in a Web Components world.

In this session, I'll provide an overview of Polymer, and demonstrate the creation of Web Components using the framework. Data binding, true encapsulation of code and style, and dynamic HTML imports are all ready for your use. You will leave with a solid understanding of Polymer basics, and real-world examples of Polymer being used in production today. You will be able to guide your current development to better align with upcoming web standards, and to understand how they will change the way we build and deploy web applications. I'll also show you examples of a large personal project using Web Components to build an entire iOS application.

If the web browser is growing up, then Web Components are the browser leaving home. Finally.

Build Your Own JavaScript Framework (Or At Least Learn How)

With new frameworks every day, what's one more? In this workshop we will code a simple, lightweight JavaScript framework. More importantly, we will examine the features that most frameworks address, patterns to use along the way, and reasons why you may or may not need a framework at all. This workshop will teach the keys to becoming a skilled front-end developer, and show you what bits of HTML5, CSS3, and JavaScript you'll need to build great applications.

There's no better way to learn JavaScript than to write a simple framework! Some of the features we will create include:

• Templating
• Data binding
• Routing
• Networking
• Data synchronization

You will find a great many use cases that don't need a framework at all, especially if you're using modern browsers. We will discuss those use cases, features in HTML5, CSS3 and ES6+ which help, and a whole bunch of JavaScript patterns to make developing rich web applications easy and maintainable.

Creating an Environment for Successful Team

Some teams seem to have some mysterious chemistry from the beginning. Other teams wallow, bicker, and slog their way to uncertain results. What makes one team soar, and another stumble? It's not just chance.

In this session, we'll explore the essential ingredients that result in that mysterious “chemistry.” For example, we’ll examine the prerequisites for cohesion, and factors that pull teams apart. We'll look at myths and realities of software teams.
You'll gain tools to assess your agile team, and insights on how to adapt the environment for growing great teams.

Learning Outcomes:
Identify the essential elements for great teams.
Strategies to adapt the environment to improve the chance of team success.
Identify common pitfalls for agile teams.

Through table activities and facilitated conversation, we'll explore experiences in teams, talk about what works, and what doesn't. I'll present research about teams, and related it to concrete steps that managers, team leads, and team members can apply to their own situations.

Docker for Devs Workshop

Docker and containers are getting a lot of attention these days but what do they mean for devs? How do they fit into DevOps and continuous delivery movements? Where do these tools fit into cloud computing? During this hands-on session we will learn how to install and configure Docker, build images and run containers in a local development environment. But we will also explore using them in a continuous deployment environment by deploying them to on premise as well as cloud services such as AWS.

• Setting Up Docker
• Creating Docker Machines
• Docker Lifecycle
• Finding & Running Containers
• Creating Images
• Linking Containers
• Sharing Images
• Composing
• Using the Docker API
• Private Repositories
• Swarm
• Kubernetes
• Cloud (Digital Ocean, AWS)
• Summary
• Resources

Functional Programming Katas in Java (3 hours)

Refactoring imperative code to functional style is a really good way to learn. What's even better, take a series of unit tests that pass, refactor the imperative code, and verify that the tests still pass after you make the code change. In this workshop we will take on a series of problems, already solved using imperative style, refactor that to functional style, and discuss the approach, techniques, pros, and cons.

Come prepared with your Java IDE. Be ready to pair up with other attendees. Dive into functional thinking.

Hacking & Hardening Java Web Applications Workshop

It seems like everyday there is a new headline about a security breach in a major company’s web application. These breaches cause companies to lose their credibility, cost them large sums of money, and those accountable undoubtedly lose their jobs. Security requires you to be proactive. Keep your employer out of the headlines by learning some key security best practices.

This hands-on workshop is designed to teach you how to identify and fix vulnerabilities in Java web applications. Using an existing web application, you will learn ways to scan and test for common vulnerabilities such as hijacking, injection, cross-site scripting, cross-site forgery and more. You will learn best practices around logging, error handling, intrusion detection, authentication and authorization. You will also learn how to improve security in your applications using existing libraries, frameworks and techniques to patch and prevent vulnerabilities.

Kotlin: Safe, Pragmatic Interoperability on the JVM

Kotlin is a practical language designed for the JVM. It focuses on pragmatism and safety, with an emphasis on interoperability and tool support. Kotlin is statically typed and includes null checks in the type system itself. The language runs anywhere Java does, from microservices to Android apps. This workshop will show how to use Kotlin to simplify anything you originally planned to do in Java.

Kotlin combines object-oriented programming with functional features like lambda expressions, functional types, and data classes. Since it comes from JetBrains, the company that produces the IntelliJ IDEA development environment, its tool support is excellent. IntelliJ even provides a Java-to-Kotlin converter to help you get started.

This presentation will cover the basic types, defining and calling functions, programming with lambdas, higher order functions, and DSLs. The goal is to give you enough background to be productive while you continue to learn and grow with the language.

Measuring Quality of design (1/2 day workshop)

Before spending substantial effort in refactoring or altering design, it would be prudent to evaluate the current quality of design. This can help us decide if we should proceed with refactoring effort or a particular alteration of design. Furthermore, after evolving a design, using some design metrics would help us to evaluate if we have improved on the design front.

In this workshop we will learn about some critical qualities of design and how to measure those. We will learn about these by working through some example code, refactoring it, and evaluating the design again at each stage of refactoring.

Reactive Architectures: Implementation Strategies for Enterprise Applications Workshop

The end has come. REST is finally dead. The world of reactive data sources has killed it, and your users will be forever grateful. Gone from your applications are 'Refresh' buttons. Gone from your sever code are the polling routines, pinging remote services for changes. Customers dashboards update seamlessly and in real time. Your users have never been happier.

If this sounds like a world that you want to live in, join us for this awesome workshop exploring the various options available to the enterprise architect when designing and implementing the reactive software layers and constructs necessary to make this dream a reality today!

Users are demanding applications which keep them informed of new events as soon as they happen. They are no longer willing to accept “Just hit the refresh button” or “It will update in a few minutes by itself” when demanding satisfaction of this new basic requirement. They are collaborating in real time, co-editing, co-authoring, 'co-laborating' with colleagues across the country and around the world, chatting over the phone or VOIP while working together via your app. They want their updates to travel from their laptop to their co-workers screens as fast as their voice reaches them through the phone. This is a tough requirement to meet, especially when trying to put a modern face on a legacy app or integrating a shiny, new, reactive app with a legacy, REST-based datasource.

And it is not just your end-users that are clamoring for reactive data sources. No, the requirements for server-to-server communication of changes to data or state have forever changed. REST no longer is King in the world of web services. REST just doesn't cut the mustard any longer. Corporate users of your data services are demanding more flexible, reactive options when consuming your endpoints.

Join us for this thought provoking and exploratory workshop and learn the what, why and how of dealing with these new architectural challenges as we explore how you can architect your new or existing stack to satisfy the ever-increasing demand for 'real-time' applications and data services fed by reactive data sources regardless of your current technology choices.

Scala for Java Developers (1/2) (Laptops Optional)

Scala for Java Developers is a full live code and fast paced presentation and workshop (laptops optional), and this is all about the Scala language.

Scala is a wonderful functional/hybrid language. It will become one of the 5 languages that you will need to know to be a highly successful JVM developer in the very near future (others being Groovy, Clojure, Java 8, and JRuby). Scala, as opposed to some of the other languages, has quite a learning curve. This presentation was built for questions. We will start with some basics, how this presentation will flow and end will be up to you, the audience. Bring your intellect, curiosity, and your questions, and get ready for some Scala. Laptops optional so you can try stuff out on your machine and create questions of your own!

Scala for Java Developers (2/2) (Laptops Optional)

Scala for Java Developers is a full live code and fast-paced presentation and workshop (laptops optional), and this is all about the Scala language. This is Part 2, continuing where we left off from Part 1.

Scala is a wonderful functional/hybrid language. It will become one of the 5 languages that you will need to know to be a highly successful JVM developer in the very near future (others being Groovy, Clojure, Java 8, and JRuby). Scala, as opposed to some of the other languages, has quite a learning curve. This presentation was built for questions. We will start with some basics, how this presentation will flow and end will be up to you, the audience. Bring your intellect, curiosity, and your questions, and get ready for some Scala.

Secrets Management

We've all got secrets, but nobody seems to know where to put them. This long standing issue has plagued system design for ages and still has many broken implementations. While many consider this an application concern, the foundations rest in the design of the system. Join Aaron for an in-depth workshop that will cover the following secret management solutions:

• Locally encrypted secrets with Ansible Vault
• HSM backed local secrets with SOPS
• AWS Secrets Manager
• Hashicorp Vault

Additionally, this workshop will demonstrate tools for discovering sensitive information checked in to your project.

This is a two session workshop and is best received by attending both sessions.

The Elm Language Workshop

A wonderful workshop adventure with a wonderful language on the client side.
Entirely written in JavaScript it is meant as a wholesale replacement on the front end. Derived from Haskell, Elm is fast, elegant, and concise. Elm also hides much of the complexities away including side effect management, event management, and exception handling where the programmer, the happy programmer might I add just focuses on the core.

This workshop encompasses:

• Introduction
• Tools
• Packages and Semantic Versioning
• Language Basics
• Functions
• Module Manipulation
• Types
• Maybe
• Records
• The Elm Architecture
• Commands, Subscriptions, Tasks
• Embedding Elm

WebAssembly Workshop

What happens if Web applications become super fast?
What if the ability to write code once but run it on lots of different platforms was true again?
What if Desktops are no longer interesting because you can do everything in a browser?
What if JavaScript wasn't your only language choice?

These are all starting to happen now that this W3C Standard is supported widely across all major browser vendors, Node and more. It's never been a better time to dig into the future that is playing out now faster than most people realize.

WebAssembly is emerging as an exciting vision for web applications that run at native speeds by using a size and load-time efficient, compiled binary format. Anything from computationally intensive business applications to fully rendered 3D video games will benefit from the mix of speed with other Web-oriented technologies. We'll let you know what is coming and how you'll benefit from it.

We will cover:

• The History of WebAssembly
• The JavaScript API
• The Stack Machine
• Shared Memory
• Dynamic Libraries
• The Text Format
• Building Web Applications using C, C++, Go, Rust, Kotlin and more
• Converting existing code and libraries into WebAssembly
• Running WebAssembly in Node

This is a hands on workshop of a truly mind-blowing next step evolution of the Web. Don't get left behind.