The single best thing you can do for the long-term health, quality and maintainability of a non-trivial software system is to carefully manage and control the dependencies between its different elements and components by defining and enforcing an architectural blueprint over its lifetime. In the talk, we will introduce a domain specific language that was specifically developed for that purpose. You will be introduced to the key features of the language. Moreover, we will also have a look at some implementation details.

This meeting will cover two distinct topics:

Various Concurrency Topics, by Nermin Šerifovic

This talk will first cover some CPU and thread fundamentals, including thread pools and effects of blocking operations. It will then explore a few immutability concepts, such as mutable state and immutable data structures. We will discover how referential transparency lends itself to easy parallelization. Lastly, we will take a look at common impediments towards writing performant concurrent code.

Lagom - An Introduction, by Morgan Creighton

Lagom, an open source reactive microservice platform, is the subject of this presentation. We will review the (abbreviated) history of microservices, what "reactive" systems are, and how the Lagom platform brings those together to provide a powerful way to  build applications.

This talk covers several issues related to the new functional changes in Java 8 and above. Topics will include:

 

- Lazy Streams
- Concurrency and parallel streams
- Generics in the Java 8 API
- Effective uses of "reduce"
- Refactoring to Java 8

If time allows, proper use of Optional, grouping and partitioning streams, downstream collectors, and features of the new Date-Time API will also be discussed.

ANTLR (ANother Tool for Language Recognition) is a parser generator that is used in many tools and frameworks (Groovy, Hibernate, Clover, and more). Come learn about the the history of ANTLR, and how to start using ANTLR4 in your own Java projects.

Do you remember Lex & Yacc from the “good old” C days? Perhaps you cut your parser-generator-teeth on Bison – or Frown, or Lemon, or PLY – or one of many others. Whatever you've used before, this meeting is the time to come up to speed on ANTLR. If you're like me, it's been many years since you've taken a serious look at grammars and parsing. In fact, the current trend is to develop so-called “DSL” libraries that make a carrier language read like different language – but that is all smoke and mirrors. A full DSL needs a parser, and a parser needs a parser generator.

ANTLR is one of the more powerful generators available to the Java community. It's well grounded in theoretical computer science, is a mature tool with good IDE integration, and has a committed ecosystem. During this presentation, we will give a quick review of grammar specification, discuss lexical & parser technologies, and then go deeper into what differentiates ANTLR from the pack. Included in the presentation will be a review of working code and runtime demonstration of parsing in action – of an input source that you might find surprising, delightful, and (most importantly) useful in your day-to-day work.

This talk will start with some of the initial research that led to VoltDB, and walk through the past 8-9 years of engineering challenges and decisions. One of the earliest decisions was choosing to build most of the system in Java; I'll explain why and what the pros and cons have been. The first public release of VoltDB was really radical in a number of ways. I’ll cover which ways it’s become more conventional, and what’s still "different" about it. Specific topics covered will include maintaining a low latency profile in the face of garbage collection, leveraging JNI and native code where appropriate, and running user procedure code safely in our process.

This meeting is made up of five overview talks which work together to share a big-picture sense of the major development processes at Fitbit. First, we'll start with a bit of history, then continue with Mesos and Aurora, deployment, microservices, certificate management, and some Agile team design. Quite a lot of goodness for one evening!

 

Fitbit's architecture journey, by Kyle Smith

Over the last 9 years, Fitbit has grown from a two-person startup into a multi-billion-dollar company with 500+ developers. Along the way our small Java/Spring/MVC web app has grown into a large, monolithic application. As many other growing companies have found, such an application can make it difficult to rapidly innovate. In this presentation, we're going to talk about Fitbit's ongoing journey from monolith to microservices and how we plan to re-energize our developers with modern technologies and practices.

 

Mesos, Aurora and their role in the future of application deployments, by Kory Brown

In this talk, we’ll go through a brief history of how Operations has traditionally handled application deployments ending with the inclusion of Mesos. After we’ve gotten a feel for the landscape, we’ll go into how Mesos has changed this process, and what the future of datacenter-level computing looks like.

 

Deploying Microservices At Fitbit, by Sean Reque

At Fitbit we want smaller teams of developers to be able to easily deploy, monitor, and take ownership of their Java services without feeling burdened by the need to create and maintain their own operational infrastructure and tooling. In this talk, we discuss the efforts we have taken to make total service ownership as easy as possible.

 

Create your own certificate authority for development, by Kevin Jamieson

With the increasing calls for “SSL Everywhere!”, creating your own Certificate Authority is a great way to understand both the mechanisms of SSL/TLS and to allow for rapid application development. We’ll be going over basics of SSL/TLS, using OpenSSL to create a CA, creating server and client certificates, and some brief history of this entire burning dumpster of functionality.

 

The role of testing specialists on agile teams, by Steve Berczuk

Automated testing is an essential part of agile software development. While some knowledge of testing is required, testing is also a specialized skill. Most agile teams write good unit tests but integration tests and the build & deployment infrastructure that enable it often require help. This talk will discuss how a Software Test Engineering team can improve the quality of testing practices while still being consistent with the goals of a self-sufficient, cross-functional agile team.

This presentation uncovers the hidden power of Java’s Unicode support​ and highlights what programmers need to know about the edge cases of character and string support. Raise your level of understanding this too-often-ignored topic in order to write better code in a “flatter” world and allow your applications to be worldwide hits!

Slides and sample code can be found at https://github.com/sualeh/What-a-Character

Reactive Programming in gaining a lot of attention recently, but what is it? It is a culmination of a lot of good ideas developed over the years, but brought together by the forces of recent developments, both in terms of software and hardware (multicores, mobile devices). Developing an application fast is easy, but developing applications that are responsive and resilient is not. In this presentation,​ we will quickly go over what reactive programming is and what a reactive application is, and then dive into code level details of how to actually create them.

Test Automation has been getting easier and easier with each technological development.  Thanks to the WebDriver interface, a single test can be built to run against different browsers.  The Selenium project uses the WebDriver interface to allow coding tests in various languages.  However, developing and maintaining Selenium tests end up becoming a whole development effort unto itself.  Wouldn't it be nice to have a programming language that reads more like English?  Where tests all follow the same pattern?  Where the language aligns well with the requirements that are to be verified?
This talk will focus on bringing together a few technologies that take you to the next higher level of coding using Domain Specific Languages (DSL); Groovy, Geb, and Spock.  Groovy enables the authoring of DSLs.  Geb is a DSL that makes Selenium coding simpler and allows you to do more with less code.  And Spock is a more logical way of writing tests (actually, they are called Specifications) that read like the requirements being verified.

What does this mean to you, the developer, the test engineer, the stakeholder?  More efficient testing by having less test code to maintain, a coding interface that enables automating the creation of test stubs, and a closer alignment of the tests to the requirements.

We will also build a Selenium Grid of various Operating Systems and Browsers using Docker.
Finally, we will run our Geb+Spock tests against our Selenium Grid.

Reactive architecture is an architecture style utilizing events combined with message processing to react to various aspects of the system. Applications build in the reactive architecture style remain responsive under load, resilient in the face of failure, and elastic under varying load conditions. All of these aspects are achieved through an event-driven architecture style. In this presentation I will leverage both slides and live coding using only core Java and RabbitMQ to describe and demonstrate many of the patterns used to build reactive systems, including monitoring patterns, supervisor patterns, event routing patterns, eventual consistency patterns, and many more.