Software Architecture Fundamentals

The job Software Architect places in the top ten of most annual surveys of best jobs, yet no clear path exists from Developer to Architect. Why aren’t there more books and training materials to fill this demand? First, software architecture is a massive multidisciplinary subject, covering many roles and responsibilities, making it difficult to teach because so much context is required for the interesting subjects. Second, it’s a fast moving discipline, where entire suites of best practices become obsolete overnight. This workshop provides the fundamentals to transition from developer to architect, or to help “accidental” architects.

Part 1 of this workshop focuses on the many elements required to make the journey from developer to architect, covering process topics like the impact of Continuous Delivery on architecture, technical subjects like application, integration, and enterprise architecture, and soft skills. While we can’t make you an architect overnight, we can start you on the journey with a map and a good compass.
Part 1, From Developer to Architect, covers:

• Soft skills
• Continuous Delivery
• Understanding large codebases
• Architecture patterns
• Architecture anti-patterns
• Integration architecture overview
• Introduction to enterprise architecture

Part two of this workshop takes a deeper dive in application, integration, and enterprise architecture topics, including evaluating architectures via Agile ATAM, the impacts of continuous delivery on architecture, comparing architectures, SOA, SOAP, and REST, integration hubs, and enterprise architecture approaches and strategies.

Part 2, Deeper Dive, covers:

• Continuous Delivery for architects
• Applying abstraction
• Comparing architectures
• SOAP vs REST/ WS vs Messaging
• Integration hubs
• Enterprise architecture approaches and strategies
• Comparing service-based architectures

To fully leverage knowledge, you need application. The last part of this workshop uses the public domain Architectural Katas exercise to apply learnings from the first two parts.

Java Upgrade

Learn to use the new features of Java 8, 9, and beyond, including lambda expressions, method references, and the streaming API.

Exercises will include using lambdas and streams, refactoring existing code, working with map/filter/reduce, and sampling the new java.time package.

Knowledge of earlier versions of Java is assumed. The exercises will be independent of IDE, but IntelliJ IDEA is recommended.

Application development with Docker, Kubernetes, and OpenShift

This workshop prepares web and application developers to build applications with Docker, Kubernetes, and OpenShift. We’ll start with a short introduction to Platform-as-a-Service, Docker, and Kubernetes, which are some of the foundational pieces of OpenShift.

Using hands-on exercises, I will walk you through several use cases for using Docker containers to deploy simple, complicated, stateful, stateless, and microservice applications. You will bring your laptop and I will bring a working platform in a VM and we will spend most of the time getting stuff done.

Building Reactive Applications

Reactive Programming is receiving quite a bit of attention and for good reasons. It’s a nice logic next step from functional programming. It takes the concept of function composition and lazy evaluations to the next level. It streamlines handling of many critical issues that are architectural in nature: resilience, scale, responsiveness, and messaging.

In this workshop, we will start with a quick introduction to reactive programming. We will then dive into code examples and learn how to create reactive applications. We’ll learn to implement observables, to deal with errors in a graceful manner, learn both synchronous and asynchronous solutions, hot vs. cold observables, and dealing with backpressures.

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.

Enterprise Messaging Foundations

This two session workshop covers messaging concepts, standards (JMS, EIP), and technologies including hands-on exercises with ActiveMQ, Spring, and Camel.

Topics

• Fundamentals: JMS, EIP

• Technologies and Architectures: ActiveMQ

• Enterprise Integrations: Spring Framework & Apache Camel

• Demos and Hands-on Exercises

Apache Cassandra, Spark and Spark Streaming for Real Time Big Data Analytics

Apache Cassandra is one of the best solutions for storing and
retrieving data. We will explore data analytics cluster computing
framework with real-world examples. It is 100x faster than Hadoop!
We will start with an introduction to Apache Cassandra. We will explore challenges encountered when attempting to scale
with relational databases, and how NoSQL databases like Cassandra address those problems. It reviews the Cassandra architecture, benefits, and how to use the Cassandra read and write paths.

Later, you will learn how to effectively and efficiently solve analytical problems using Apache Spark, Apache Cassandra, and DataStax. You will learn about Spark API, Spark-Cassandra Connector, Spark SQL, Spark Streaming, and fundamental performance optimization techniques.
Big Data applications nowadays require a faster speed of data
processing and analysis.

Apache Cassandra is one of the best solutions for storing and
retrieving data. We will explore data analytics cluster computing
framework with real-world examples. It is 100x faster than Hadoop!
We will start with an introduction to Apache Cassandra. We will explore challenges encountered when attempting to scale
with relational databases, and how NoSQL databases like Cassandra address those problems. It reviews the Cassandra architecture, benefits, and how to use the Cassandra read and write paths.

Later, you will learn how to effectively and efficiently solve analytical problems using Apache Spark, Apache Cassandra, and DataStax. You will learn about Spark API, Spark-Cassandra Connector, Spark SQL, Spark Streaming, and fundamental performance optimization techniques.
Big Data applications nowadays require a faster speed of data
processing and analysis.

An Introduction to Video Game Development

With many AAA video games in its portfolio, Unity has become a powerhouse within the game development and simulation industry. But Unity is more than a game engine — it's a complete ecosystem of tools, workflows, and integrations. Very small development teams and even individual hobby developers can create great games with Unity, for any platform, 3D or 2D.

In this workshop, I'll give an overview of tools and techniques for building games for desktop and mobile using the Unity. We will break down a real game for iOS, from asset creation, to building scenes, to scripting in C# (on Windows and Mac), to animation, to testing and finally publishing a game. You will leave this workshop with an understanding of the power of Unity, and the knowledge necessary to start building games. Game development is a thrill, and all developers can benefit from a knowledge of the cutting edge tools.

Angular Workshop

Angular is a new JavaScript framework from Google. If you are looking into developing rich web applications, Angular is your friend. Angular embraces HTML and CSS, allowing you to extend HTML towards your application, and uses plain JavaScript which makes your code easy to reuse, and test. 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.

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

• Bootstrapping an AngularJS application using ng-app
• ng-init and the evaluation {{ }} directive
• A brief look at $rootScope
• ng-model
• Controllers, Dependency Injection, and the View-Model (controller as syntax)
• Looping using ng-repeat
• Forms using ng-form, form validation and submission in AngularJS
• Angular provided filters and how to write our own
• Factories
• Making AJAX requests using $http
• Routing and route params using $routeProvider and $routeParams

If time permits we will discuss a few good practices when working with AngularJS applications.

This is a hands on tutorial so bring your laptops!

React.js Workshop

React.js is a view library from Facecbook for building performant user-interfaces in JavaScript. In this session, we'll explore React.js and understand why it's a great step forward for building complex UI's that run fast. We'll code up an example web application using React.js and step through the basics of using the library while discussing concepts like the virtual DOM and components.

This is a HAND-ON WORKSHOP, INTRODUCTORY LEVEL. Please come with a laptop, and if possible, with the software needed pre-installed (Instructions below). We'll cover these topics - both in code and in discussion format, and do as many as we can in the time alloted:

• React components
• Lifecycle
• Properties
• State
• Using React-Bootstrap components
• Signaling & Messaging between Component
• Handling Events
• All coding done in ES6 style
• Modern React application structure, setup, and build
• Writing tests
• React Router
• Discussion of Flux architecture
• REST/Network ops within React
• React architecture
• Component composition
• Discussion of Redux and Functional Web Architecture (time permitting!)

3/4 Day Learn to use Gradle (and understand it) Workshop

Join me for this 3/4 day Gradle introduction workshop. We'll cover all of the basic things you need to know about using Gradle. Not only will you understand what Gradle is and why and how it works the way it does, but you'll get extensive hands-on practice so you'll be ready to use Gradle successfully in your own projects immediately after the workshop.

Participants should bring either a Windows or Mac laptop to work through the workshop exercises.

We're looking forward to having you in the Gradle Fundamentals workshop. To maximize the learning and value of our time together, we ask that you prepare your laptop that you're bringing to this very hands on workshop.

1) Choose a Windows or Mac laptop that you'll be bringing to the workshop (we have some downloads and installs that are better to do before the event). Ensure you have admin or sudo privileges on the machine.

2) Please have a recent Java JDK installed.

Topics we will cover include:

• About Gradle
• Tasks
• Build Scripts
• Build Lifecycle and Phases
• Properties and Plugins
• Dealing with Dependencies
• Gradle Wrapper and Daemon
• Dependency Management
• Testing with Gradle
• Sourcesets
• Multiproject builds
• Using Gradle with Jenkins

Building a Continuous Delivery Pipeline With Jenkins (and Gradle, Git, Gerrit, Artifactory, Sonar, Jacoco, and Docker)

Create your own model Continuous Deliver pipeline in a VM using Jenkins, Gradle, Git, Gerrit, Artifactory, Sonar, Jacoco, and Docker. Learn about each of these technologies in brief and see how to integrate them into Jenkins through plugins or scripting. See how to generate and access reports for running testcases, pass/fail for code metrics, coverage info, etc. Learn how to deploy a webapp with a database backend in multiple Docker containers for functional or UAT tests. Learn Jenkins techniques to pass information, environments, and artifacts between jobs in the pipeline.

Important setup required before the workshop:

You will need a laptop for this workshop with the applications as discussed below.

In this workshop, we use a preconfigured VM which requires Virtualbox to be running on your system. Please see https://github.com/brentlaster/conf/blob/master/rwx2016/JDP-Setup.pdf and follow the directions there. (Note: You do not need to do the part about changing the timezone on the VM since RWX 2016 will be in the EST timezone.)

As noted in the PDF, the VM can be downloaded from: https://s3-us-west-2.amazonaws.com/bclconf/CDPipeline/RWX_2016.ova

Please be aware that this VM is ~6G in size and will require significant time to download. Free space of 20G (prior to the download to allow for the download, running the VM, etc.) is recommended on your system for best performance.

In this hands-on workshop, we create a Continuous Delivery pipeline with Jenkins and 7 other technologies. We assemble the Review stage with automated verification builds and code-review via Git and Gerrit. Then we move on to the Commit stage with compiles and unit tests, integration testing via Gradle, code analysis with Sonar and Jacoco, packaging, and publishing of our artifact into Artifactory. Next we handle the acceptance stage of retrieving our artifact and deploying them automatically to a functional test environment in Docker containers. In the final stage, we show how to deploy to a production web engine.

Throughout this workshop, we briefly survey each of these technologies and provide working examples of integrating each of them within Jenkins. Everything is contained within a Linux VM that each participant will have. After the labs, each participant will have their own working Continuous Delivery pipeline.

Users will need a modern laptop with VirtualBox installed and the ability to run images as well as about 20Gig of free disk space.

Clojure Workshop

In an increasingly crowded field of languages, Clojure stands alone. It is a dynamic, functional, high performance dialect of Lisp that runs on both the JVM and CLR. The creator cast aside assumptions from both the Lisp and Java communities to create a remarkable language implementation.

This workshop introduces Clojure to Java developers who might not have seen a Lisp and don’t yet understand why that’s such an advantage. I introduce the language syntax (what little there is of it), cover interoperability with Java, macros, mutlti-methods, and more. I also cover the functional aspects of Clojure, showing its powerful immutable data structures, working with threads and concurrency, and sequences. Beyond just showing syntax, I also show how to build real applications in Clojure, and give you a chance to do the same. Attending this workshop shows enough to pique your interest and show why many of the people who were interested in Java in 1996 are interested in Clojure now.

Continuous Delivery for Architects Workshop

Architecture doesn't exist in a vacuum, a painful lesson developers who built logically sound but operationally cumbersome architectures learned. Continuous Delivery is a process for automating the production readiness of your application every time a change occurs–to code, infrastructure, or configuration. Some architectures and practices yield code that works better in this environment. This session takes a deep dive into the intersection of the architect role and the engineering practices in Continuous Delivery.

Yesterday's best practice is tomorrow's anti-pattern. Architecture doesn't exist in a vacuum, a painful lesson developers who built logically sound but operationally cumbersome architectures learned. Continuous Delivery is a process for automating the production readiness of your application every time a change occurs–to code, infrastructure, or configuration. Some architectures and practices yield code that works better in this environment. This session takes a deep dive into the intersection of the architect role and the engineering practices in Continuous Delivery. I first set context for the information you must master before delving into the nuances of modern architectural concerns. I discuss the role of metrics to understand code, how Domain Driven Design's Bounded Context reifies in architecture, how to reduce intra-component/service coupling, the tension between coupling and cohesion, microservices architectures, and other engineering techniques.

This workshop allows you to apply techniques either against a sample codebase…or bring one of your own. Suggested exercises include using metrics to learn more about the structure of your class, how to determine how to partition a mono-lithic architecture into a service-based ond, and Architectural Katas with Devops added.

Continuous Delivery Workshop, part 1 of 3: Deployment Pipelines

The first part of the Continuous Delivery workshop covers the differences between continuous integration, continuous deployment, and continuous delivery). It also introduces the deployment pipeline_, along with usage, patterns, and anti-patterns. This part concludes with some applied engineering principles.

Releasing software to actual users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers and operations, delivery teams can get changes released in a matter of hours—sometimes even minutes—no matter what the size of a project or the complexity of its code base. The workshop materials are derived from the best selling book Continuous Delivery and creating in collaboration with the authors and other of my ThoughtWorks colleagues. Continuous Delivery details how to get fast feedback on the production readiness of your application every time there is a change—to code, infrastructure, or configuration.

The first part of the workshop describes the technical differences between related topics such as continuous integration, continuous deployment, and continuous delivery. At the heart of the workshop is a pattern called the deployment pipeline, which involves the creation of a living system that models your organization's value stream for delivering software. I discuss the various stages, how triggering works, patterns and anti-patterns, and how to pragmatically determine what “production ready” means. This session also covers some agile principles espoused by the Continuous Delivery book, including new perspectives on things like developer workstations and configuration management.

Continuous Delivery Workshop, part 2 of 3: Testing, Synergistic Practices, and Deployment

Continuous Delivery relies on a variety of interlocking engineering practices to work efficiently; this session covers three related topics. First, I cover the role of testing and the testing quadrant. Second, I specifically cover version control usage and offer alternatives to feature branching like toggle and branch by abstraction. Third, I describe some incremental release strategies, along with their impact on other stages of project lifecycle.

Releasing software to actual users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers and operations, delivery teams can get changes released in a matter of hours—sometimes even minutes—no matter what the size of a project or the complexity of its code base. The workshop materials are derived from the best selling book Continuous Delivery and creating in collaboration with the authors and other of my ThoughtWorks colleagues. Continuous Delivery details how to get fast feedback on the production readiness of your application every time there is a change—to code, infrastructure, or configuration.

Continuous Delivery relies on a variety of interlocking engineering practices to work efficiently; this session covers three related topics. First, I cover the role of testing and the testing quadrant, including the audience and engineering practices around different types of tests. I also cover some best practices around testing, including testing ratios, code coverage, and other topics. Second, I specifically cover version control usage and offer alternatives to feature branching like toggle and branch by abstraction. Generally, I talk about building synergistic engineering practices that complement rather than conflict one another. In particular, I discuss why feature branching harms three other engineering practices and describe alternatives. Third, I describe some incremental release strategies, along with their impact on other stages of project lifecycle.

Continuous Delivery Workshop, part 3 of 3: Infrastructure and Data

Two big stumbling blocks for Continuous Delivery adaptation are interactions with operations and the keepers of data. First in this session, I cover operations, DevOps, and programmatic control of infrastructure. Second, I discuss how to incorporate databases and DBA's into the Continuous Integration and Continuous Delivery process.

Releasing software to actual users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers and operations, delivery teams can get changes released in a matter of hours—sometimes even minutes—no matter what the size of a project or the complexity of its code base. The workshop materials are derived from the best selling book Continuous Delivery and creating in collaboration with the authors and other of my ThoughtWorks colleagues. Continuous Delivery details how to get fast feedback on the production readiness of your application every time there is a change—to code, infrastructure, or configuration.

Two big stumbling blocks for Continuous Delivery adaptation are interactions with operations and the keepers of data. First in this session, I cover operations, DevOps, and programmatic control of infrastructure using tools like Puppet and Chef. I also discuss the explosion of tool alternatives in this space, and cover some current-day best practices. Second, I discuss how to incorporate databases and DBA's into the Continuous Integration and Continuous Delivery process. This includes database migrations, strategies for enhancing collaboration between application development and data, and database refactoring techniques.

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

Foundational Front-End Architecture: Getting the Most out of Frameworks, Libraries, Events, and the Browser Platform (Without Losing Your Mind)

“There's a new JS framework every week! There's a new JavaScript feature every week! There's a new HTML5 feature every week! We are losing our minds OMG@#$HELPUS!”

Settle down everybody. Shiny new frameworks distract you from the stability offered by the web platform: ES6 is the first major update to JavaScript since 2009, and HTML5 was 18 years in the making! More importantly, few of these innovations significantly change the architecture of web applications — we owe browser innovation and frameworks for that. But since the browser evolved in to a full-blown application runtime, we now need solid front-end architecture, and front-end architects. It's not just about JavaScript, it's about the entire browser platform. And you can't pick frameworks to simplify that platform until you understand its underpinnings.

In this workshop, we will dissect the components of a modern web client into three buckets:

1. Networking: How does data get to and from the client? We will discuss the various underlying APIs and libraries for client-server communication.
2. Rendering: How does the user interface get created and painted? We'll look at the HTML5 APIs for manipulating the DOM, and explain how various frameworks including AngularJS, React, and Polymer regard and manipulate the DOM.
3. Distribution & Maintenance: How does the resulting app get distributed and updated, either on the web or to app stores?

I'll lay the foundations to simplify the complex world of front-end tools, frameworks, and architecture. I'll share patterns to help you manage the complexity of front-end development and back-end integration for modern web clients. And I'll convince you to never again complain about how fast the world of front-end technologies is moving.

Full Stack JavaScript with HTML5, Node.js and MongoDB

You don't need Node.js or MongoDB to build “full-stack” solutions, but they sure help! This stack is popular for its scalability, its promise of developer productivity, and the capability to develop all components with a single programming language. Not all use cases are a great fit for JavaScript on the server. But love it or hate it, there are valuable lessons and use cases here for all developers.

We'll examine a complete multiuser end-to-end app using HTML5, CSS, and JavaScript. We'll connect it to a simple Node.js instance using WebSocket. We'll wire up a simple document-oriented persistence layer with MongoDB. And we'll do it all using mostly-vanilla JavaScript to illustrate concepts that don't depend on particular frameworks.

You'll leave this session convinced that full-stack JavaScript has “teeth”, and that it's not all just hype. And whether you intend to use JavaScript, Java, Ruby, or a mix of various frameworks on the server, the architecture of a dynamic HTML5 app will be made transparent and straightforward.

Graph Database Fundamentals

This half-day workshop will cover the fundamentals of Graph Databases with hands-on exercises using Neo4J.

Environment Setup

• Hello World Graph!
• Web Console
  Introduction
• What are Graphs?
• NoSQL Landscape
• Relational vs. Graph
  Fundamentals
• Constructs
• Modeling
• Languages
• Development
• Testing
  Architecture
• Graph Database
• Deployment Topologies
• High Availability (HA)
• Operations and Security
  Advanced Concepts
• Bulk Loads
• Traversals
• Indexes
• Visualization

Groovy for Java Developers

Learn Groovy from a Java developer's perspective. Use Groovy features like native collections, operator overloading, and the Groovy JDK. Additional topics will include closures, builders, AST transformations, and basic metaprogramming.

Tests using both JUnit and Spock will be provided, as well as a Gradle build file. All code will be made available through a git repository.

Introduction to Hadoop Workshop

As an industry we are collecting more and more data. At some point we have to be able to make sense of the data. Unfortunately many of the tools we have historically used can not scale up to the terabytes and petabytes we have captured. Hadoop is one of those relatively new technologies that is taking the industry by storm since it has proven to scale by taking advantage of the MapReduce pattern and distributed computing.

During this hands-on tutorial you will provision a Hadoop cluster, write MapReduce jobs and learn how to store and access data via Hadoop Distributed File System (HDFS). You will also learn how cloud providers such as Amazon Web Services’ Elastic MapReduce (EMR) and Microsoft’s Azure HDInsight provide Hadoop as a service.

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.

Migrating to ES2015 workshop, part I

In this fun 2 part workshop, we'll do a series of exercises to convert “old school” JavaScript code to ES2015, or ECMAScript 2015 code. ES2015 just got finalized, but you don't have to wait to use it. Using transpilation as part of your build process, you can quickly start using it TODAY. See the details below to get a flavour for what we'll be hacking in this fast-paced workshop.

We'll do exercises to convert legacy JavaScript code to ES2015 to help you understand how to migrate existing code and write new code in the new version of the language:
arrows
classes
enhanced object literals
template strings
destructuring
default + rest + spread
let + const
iterators + for..of
generators
unicode
modules
module loaders
map + set + weakmap + weakset
proxies
symbols
subclassable built-ins
promises
math + number + string + array + object APIs
binary and octal literals
reflect api
tail calls

Migrating to ES2015 workshop, part II

In this fun 2 part workshop, we'll do a series of exercises to convert “old school” JavaScript code to ES2015, or ECMAScript 2015 code. ES2015 just got finalized, but you don't have to wait to use it. Using transpilation as part of your build process, you can quickly start using it TODAY. See the details below to get a flavour for what we'll be hacking in this fast-paced workshop.

We'll do exercises to convert legacy JavaScript code to ES2015 to help you understand how to migrate existing code and write new code in the new version of the language:
arrows
classes
enhanced object literals
template strings
destructuring
default + rest + spread
let + const
iterators + for..of
generators
unicode
modules
module loaders
map + set + weakmap + weakset
proxies
symbols
subclassable built-ins
promises
math + number + string + array + object APIs
binary and octal literals
reflect api
tail calls

Modeling for Web Architects

In some organizations, architects are dismissed as people that draw box and arrow diagrams - the dreaded whiteboard architect. While we don't want to foster that stereotype, it is important for an architect to be able to construct basic architectural diagrams. An architect must also be able to separate the wheat from the chaff eliminating those models that don't help tell the story while fully leveraging those that do.

In this workshop, we'll discuss the various diagrams at our disposal. We'll walk through a case study and as we go, we'll construct a set of diagrams that will help us effectively communicate our design. We'll talk about stakeholders and who might benefit from each type of diagram. Additionally we'll discuss how to constructively review an architectural model.

Modularity, Microservices, and Modern Architectural Paradigms

New architectural paradigms are emerging that challenge traditional assumptions about the way that scalable and adaptable software is built. At the heart of these paradigms is a modular approach that breaks apart the monolithic application. But breaking apart the monolith has implications beyond software architecture and never before has architecture, infrastructure, and methodology been linked in a way that demands a new approach to software development.

In this workshop, we will explore modularity’s role in a large scale software technology agnostic architecture. We’ll compare and contrast different implementation technologies, including Dropwizard and OSGi, for building modular architectures. And we’ll discover the impact that modern architecture has on infrastructure and methodology. Throughout the discussion, we will examine how modern web and mobile apps fit into this overall architectural story. This session is a workshop and hands on labs are available, so bring your laptop if you’d like to perform the exercises.

Pattern Matching Makes You Powerful! (In All Languages!)

Regular Expressions are an undervalued, underutilized tool in the developer toolbox. Few programming technologies have stood a comparable test of time for their capacity to improve developer productivity, to shortcut complex tasks, to reduce dependency on various libraries, and to encourage code reuse. They also help to teach patterns and improve pattern recognition, not only for code, but for programmers themselves. Competency with regexes will make you a better programmer, regardless of your choice of language or platforms. And it will impress your peers, too!

This workshop will teach you the fundamentals of writing, debugging, and testing PCREs (Perl-compatible Regular Expressions) in multiple programming languages. With hands-on examples we will cover regex syntax, metacharacters, assertions, grouping, quantifiers, greed, capturing, balanced matches, and replacing. We'll compose regexes from scratch to parse some common string formats such as URLs, email addresses, and even JSON. Given enough time, we'll even learn look-around assertions, and examine some creating uses of regexes in the field of natural language processing.

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.

Spark Workshop

Apache Cassandra is a leading open-source distributed database capable of amazing feats of scale, but its data model requires a bit of planning for it to perform well. Of course, the nature of ad-hoc data exploration and analysis requires that we be able to ask questions we hadn’t planned on asking—and get an answer fast. Enter Apache Spark.

Spark is a distributed computation framework optimized to work in-memory, and heavily influenced by concepts from functional programming languages. In this workshop, we’ll explore Spark and see how it works together with the Cassandra database to deliver a powerful open-source big data analytic solution.

Web Security Workshop

If you're not terrified, you're not paying attention.

Publishing information on the Web does not require us to just give it away. We have a series of tools and techniques for managing identity, authentication, authorization and encryption so we only share content with those we trust.

Before we tackle Web Security, however, we need to figure out what we mean by Security. We will pull from the worlds of Security Engineering and Software Security to lay the foundation for technical approaches to protecting our web resources. We will also discuss the assault on encryption, web security features and emerging technologies that will hopefully help strengthen our ability to protect what we hold dear.

Topics include:

• Security Engineering
• Software Security
• Encryption
• Authentication and Authorization Mechanisms
• Emerging Web Security Technologies