Brian Sletten

Modern Software : Fearless Concurrency With Rust

Wednesday, 3:00 PM EST

Rust is known for many things including being a safe, fast, popular programming language with a steep learning curve designed for systems programming, but finding its way into more and more areas.

Rust deserves all of its reputations, but one of the things that doesn't get as much attention in discussions about the language's strengths is its support for “Fearless Concurrency”. Language design, the safety-oriented memory model and the borrow-checking engine all combine to make writing concurrent applications in Rust a joy in comparison to some other popular languages.

In this talk, we'll show several examples of what developers love about building concurrent applications in Rust. This is includes:

• The Rust Memory Model
• Lifetimes
• Various Concurrency Programming Styles
• Mutex
• Message-based
• Channels

WebAssembly System Interface (WASI)

Wednesday, 5:00 PM EST

WebAssembly is one of the most disruptive technologies hitting our industry in quite some time. It gives us the capacity to write portable code that can truly run everywhere.

Applications themselves are still tied to the APIs that they use, however. WASI extends the value proposition of the WebAssembly ecosystem to include application-level portability as well a vision for sandboxing that could materially help both our software portability and malware concerns.

The combination of benefits provides a vision of the future that might not require Docker in the mix.

This talk will explain:

• What WebAssembly brings to the table as far as code portability
• What WASI brings to the table as far as application portability
• Functional Sandboxing to increase security profiles
• The WASI Package Manager (WAPM)
• Various WASI Runtimes targetting different architectural use cases
• What Intel, Red Hat, Mozilla and more are doing with the
  Bytecode Alliance focusing on how WebAssembly and WASI can
  bring around secure programming platforms meeting the needs of
  developers and service providers

Modern Software : Porting Apps to WebAssembly

Wednesday, 7:00 PM EST

WebAssembly demonstrations are invariably eye-popping and world-shaking. An amazing array of functionality has already been ported to this new ubiquitous runtime environment, but it isn't always clear how to go about it.

There is a difference between code portability and application portability. We will cover both aspects of what WebAssembly does for us in both of these situations.

In this talk we will look at the process of porting libraries and applications to WebAssembly.

Topics will include:

• Porting existing libraries and applications via the Emscripten and LLVM toolchains
• Integrating Rust libraries with Web applications
• Strategies for using WebAssembly in existing Web applications
• Integrating Web APIs with other languages

Modern Software : Security of Machine Learning Systems

Thursday, 11:00 AM EST

When we productionalize machine learning systems, we are taking our models and injecting them squarely into our production systems. It is astonishing how rarely the topic of security crosses anyone's mind with respect to these models, the training process and what it means for often inexplicable systems that have an increasing bearing on our lives.

In this talk we will highlight and contextualize a handful of security attacks or issues that could exist in machine learning systems based on some of the most current research on the topic.

• Architectural Risk Models of ML Systems
• Threat Modeling
• Taxonomies of Attacks
• Practical Response Strategies

Knowledge Graphs and Linked Data

Thursday, 1:00 PM EST

There are many attempts to build data-driven learning and reasoning capabilities these days in the worlds of machine learning and AI. Deep learning systems have had remarkable results, but even its thought leaders and strongest advocates acknowledge the need for “common sense” in the learning process. That means different things to different people, but Linked Data and Knowledge Graphs represent one approach to capture what we know about a domain. They are increasingly being used to present domain views that grow over time and aren't
domain-specific using network-friendly standards.

We will discuss the emergence of Knowledge Graphs as an emerging solution to a missing capability in most organization's IT strategies. We will discuss how some of the biggest organizations in the world are heading in this direction, it's impact on API design and more. We will focus on specific tools, platforms and standards that are making Knowledge Graphs a crucial part of your overall solutions.

Reactive Spring : Modernizing Code and Architecture in the Spring Ecosystem

Thursday, 3:00 PM EST

Spring has always been defined by its lightweight core. While there has been an overwhelming explosion in the external projects and protocols it integrates seamlessly with, it has also evolved internally to meet the needs of modern development requirements.

One of the biggest changes in the last several years has been the emergence of Reactive Spring, an attempt to embrace the idea of Reactive Systems in the Spring ecosystem. This is a vision of responsive, resilient, elastic systems. Unfortunately, code alone cannot solve the problems so this is a case where software and architecture meet.

You will learn about:

- The Reactive System vision
- How Spring absorbed these ideas without complicating or
  eliminating the more conventional styles
- How to build, test and consume Reactive Spring applications
- How to architect entire Reactive chains of interacting systems

Reactive Spring : Modernizing Code and Architecture in the Spring Ecosystem

Thursday, 5:00 PM EST

Spring has always been defined by its lightweight core. While there has been an overwhelming explosion in the external projects and protocols it integrates seamlessly with, it has also evolved internally to meet the needs of modern development requirements.

One of the biggest changes in the last several years has been the emergence of Reactive Spring, an attempt to embrace the idea of Reactive Systems in the Spring ecosystem. This is a vision of responsive, resilient, elastic systems. Unfortunately, code alone cannot solve the problems so this is a case where software and architecture meet.

You will learn about:

- The Reactive System vision
- How Spring absorbed these ideas without complicating or
  eliminating the more conventional styles
- How to build, test and consume Reactive Spring applications
- How to architect entire Reactive chains of interacting systems