The ancient Chinese warrior Sun Tzu taught his men to “know your enemy” before going into battle. For developers, the equivalent is knowing and understanding software development anti-patterns – things that we repeatedly do that produce negative results. Anti-patterns are used by developers, architects and managers every day, and are one of the main factors preventing progress and success. In this humorous and fast-paced session we will take a deep-dive look at some of the more common and significant software development anti-patterns. Through coding and design examples you will see how these anti-patterns emerge, how to recognize when an anti-pattern is being used, and most importantly, learn how to avoid them through effective software development techniques and practices. Although most of the coding examples are in Java, this is largely a technology-agnostic session.

Agenda:

• Introduction
• A look at 5 common software development anti-patterns

It seems like all we talk about these days is making our architectures more modular. Buy why? In this session I will discuss the drivers and reasons why it is essential to move towards a level of modularity in our architectures. I will discuss and show real-world use cases of distributed modular architectures (specifically microservices and service-based architecture), and then discuss in detail the core differences between microservices and service-based architecture and when you should consider each. I'll end the talk by discussing the most effective way of migrating to modular distributed architectures.

Agenda:

• Drivers for modularity
• Modular distributed architectures
• Microservices vs. service-based architecture
• The move towards modularity

Being a software architect is a tough job. Not only do you have to have significant technical depth and breadth, but you also need to understand the business domain you are working in. While these aspects are important, there is another perhaps more vital aspect of being an architect - the soft skills. Too many architects fail to realize the importance of soft skills, and as a result do not achieve success in their career as an architect. In this two-part session I will focus on the soft skills of architecture. In part one I will cover skills related to techniques such as architecture decisions, architecture refactoring, and communicating your software architecture through diagrams, documentation, and presentation.

Agenda:

• Architecture decisions
• Architecture refactoring techniques
• Communicating your architecture

Many of you may have an architect title, take on the role of an architect, or even aspire to be an architect, but are you thinking like an architect? Architectural thinking is learning to look at a problem or task from an architect's point of view. In this session we will look at many facets of architectural thinking, including how requirements shape the architecture, component-based thinking, how to make architecture decisions, and what feasibility and vitality means to an architect.

Agenda:

• expectations of an architect
• technical breadth vs. depth
• how requirements shape the architecture
• making architecture decisions
• component-based thinking

Just as developers use design patterns in software development, architects use well-defined architecture patterns to get a head start on defining the characteristics and shape of the architecture for a system. In this session we will explore some of the more common architecture patterns and use concrete real-world examples to demonstrate how the patterns work. I will also go over the pros and cons of each pattern and discuss how requirements and operational aspects can drive which patterns to use. Using the right architecture pattern for your system is critical, because as we all know, once in place the architecture is very hard to change.

Agenda:

• Why use architecture patterns?
• Layered Architecture Patten
• Event Driven Architecture Pattern
• Microkernel Architecture Pattern
• Space-based Architecture Pattern

With distributed and reactive architecture styles on the rise, it is more important than ever to understand the underlying technologies that are used to implement these styles. Messaging is one such typical and popular technology used to integrate components within a distributed architecture. In the first part of this two-part session I will start out with a short discussion of where we are in messaging today, then move on to a deep dive of request/reply messaging and publish and subscribe messaging. Through live coding using both JMS 1.1 and JMS 2.0 I will show you several techniques for sending a message to a consumer and waiting for the response, as well as the many types of pub/sub subscribers and why you would want to use each. This is a very code-intensive session, so if you want to follow along be sure and have ActiveMQ and OpenMQ (for JMS 2.0) installed on your laptop prior to the session.

Agenda:

• Messaging Introduction
• Request/Reply Messaging
• Publish and Subscribe Messaging

With distributed and reactive architecture styles on the rise, it is more important than ever to understand the underlying technologies that are used to implement these styles. Messaging is one such typical and popular technology used to integrate components within a distributed architecture. In the second part of this two-part session I will show you some useful messaging techniques that solve more advanced enterprise problems. I will start out by showing you how to use embedded messaging within your application and the reasons why you might want to use it. I will then demonstrate through live coding the various techniques for message streaming, which is useful for sending images, documents, and even video through messaging. Finally, I will discuss some design considerations when building out your messaging infrastructure. This is a very code-intensive session, so if you want to follow along be sure and have ActiveMQ and OpenMQ (for JMS 2.0) installed on your laptop prior to the session.

Agenda:

• Embedded Messaging
• Message Streaming
• Messaging Design Considerations

“Docker is an open-source engine that automates the deployment of any application as a lightweight, portable, self-sufficient container that will run virtually anywhere.” Docker creates containers that provide running process with:

• an equal slice of CPU
• a maximum memory quota
• its own process ID (PID) namespace
• its own network interface
• its own private root filesystem

It does this by leveraging low-level Linux kernel primitives like cgroups and namepaces. The end result is a portable application container that can run anywhere Docker can run, including on VMs, bare-metal servers, OpenStack clusters, public instances, or combinations of the above.

Containers are an excellent way to package your application such that it can run consistently everywhere you want to run it, a fantastic step toward Continuous Delivery. In this session we'll look at how to use Docker to package, deploy, and run Java applications and other services. We'll also compare Docker to another container solution, Warden, which is a key component of the Cloud Foundry PaaS.

Building and running container images isn’t enough. There are very real problems that we still have to solve:

• how do we schedule and run these containers on infrastructure?
• how do we create networks that can link these containers across multiple hosts?
• how do we handle data that needs to persist across container restarts?
• how do we handle concerns like service discovery and load balancing?

These concerns are the focus of much of the development work being done in the Docker ecosystem today.

We’ll examine the use of several projects and how they contribute to solutions to these problems, including:

• Kubernetes by Google
• Apache Mesos
• Cloud Foundry Diego
• Cloud Foundry BOSH
• Weave
• CoreOS
• The Hashicorp family of projects

Modern applications are changing as we embrace the engineering practices associated with Continuous Delivery and DevOps, migrate our applications to modern cloud platforms, elastically scale applications with the dynamics of customer demand, and embrace microservices architectures. The Twelve-Factor App is a collection of application development patterns developed by Heroku engineers that aim to support these types of architectural and cultural change.

The 12 Factors are:

1. One codebase tracked in revision control, many deploys
2. Explicitly declare and isolate dependencies
3. Store config in the environment
4. Treat backing services as attached resources
5. Strictly separate build and run stages
6. Execute the app as one or more stateless processes
7. Export services via port binding
8. Scale out via the process model
9. Maximize robustness with fast startup and graceful shutdown
10. Keep development, staging, and production as similar as possible
11. Treat logs as event streams
12. Run admin/management tasks as one-off processes

We’ll examine how to implement these factors using JVM “microframeworks” like Spring Boot and Dropwizard.

The new facilities in Java 8 is about the change the way we write code. Our code will become
more expressive and concise. But, exactly how?

In this presentation we will take several common Java code examples, discuss the core idea expressed in code, and transform that code to use the facilities in Java 8. Watch and interact as you see Java code go through a weight loss program right in front of your eyes.

Functional programming has gained the recognition it deserves and almost all mainstream languages now support functional style of programming. With the introduction of lambdas in Java 8, we have new tools on our hands. In this presentation, we explore this tool and how we can benefit from it.

We start with an introduction to lambda and learn about imperative vs. declarative style and learn how to solve some common problems with it.

We all have heard about lambda expressions in Java 8. The real unsung hero of Java 8 are the Streams.

In this presentation we will take an example driven approach to explore streams, their core capabilities form the application development point of view, and how to explore these capabilities for improve performance and efficiency.

Big data, smart phones, tablets, wearable devices, multicore processors,…—we're seeing rapid and drastic
evolution in both the computing environments and the application needs. Thankfully, a number of technologies have been evolving over the past several years to meet these demands. The reactive manifesto is an attempt to reenforce a set of technical practices needed to meet the emerging demands.

If you've heard and read about reactive programming, but are eager to realize that in code, then this presentation is for you. We will start with a rapid introduction and get into code to learn about reactive programming, not in theory but with practical examples.

Inspired by success stories from companies such as Amazon and Netflix, many organizations are moving towards microservice architectures at a brisk pace. This session provides a thorough overview of the pros and cons for microservice architectures, when it is applicable, and some nascent best practices.

Microservice architecture is important because it’s the first architecture to fully embrace the Continuous Delivery and DevOps revolutions. In this session, I cover the motivations for building a microservice architecture (including making the distinction between “regular SOA” and microservices), some considerations you must make before starting (such as transactions versus eventual consistency), how to determine service partition boundaries, and ten tips to dowse you towards success. I also discuss the role of polyglot development, enterprise governance, how data and databases fit into this new world, and tooling to help ensure consistency between core services like logging and monitoring. This session provides a thorough overview of the pros and cons for microservice architectures, when it is applicable, and some nascent best practices.

It was over 10 years ago that Spring hit the scene and made a big impact in the enterprise Java development ecosystem. Now that Spring 4.2 is available (and Spring 5 on the way), there's a lot of new features and a lot that you may not know about yet.

Whether you're already working with Spring 4 or are anxious to make a move up, there's plenty of new tricks Spring has in store for you. We'll explore them all in this overview of everything that's new in Spring.

You wouldn't write your entire application in a single main() method or servlet. Nor would you develop an entire production-ready application in a single class. It's even unlikely that you'd cram everything into a single package.

Modularity helps us gain order in our code, breaking it into easily digestible, refactorable, pluggable, and testable chunks. Classes and methods are a form of modularity that we're all familiar with. But once the code is built, modularity goes away and we're left deploying a single WAR file.

Aside from being buzzword-compliant, Microservices are a means of defining entire systems from composable, but distinct deployment units gaining all of the benefits of finer-grained modularity. As it turns out, Spring is well-equipped as the platform on which we can build and deploy microservices.

In this session, we'll examine the details of microservices and explore the features of Spring, Spring Boot, and Spring Cloud that enable you to achieve modularity via microservices.

How do you test a Spring application? The easy answer is that Spring encourages loose-coupling through interfaces and dependency injection, therefore it's easy to inject mock implementations at test time.

But, as I said, that's the easy answer.

There's more to testing an application than simple unit-testing. And the most challenging parts of an application to test are the external edges such as the web and database portions. It's difficult to inject a mock user into a web application; and injecting a mock database doesn't give any confidence that persistence code will work with a real database.

In this session, we'll look at various ways that Spring and Spring Boot help with testing the tough-to-test portions of an application.

The basics of developing for the Android platform will be explored, from setting up the SDK to using the Android Studio IDE and the generated Gradle build files. No previous experience is required, other than a basic knowledge of Java.

After discussing how Android fits into the marketplace, we'll look at creating applications, how to use activities, and working with layouts.

Building on the the previous talk, we'll add intents, customized layouts for alternative configurations, talk about the activity lifecycle, use logging, and more.

We'll deploy to both emulators and connected devices, and change input styles.

This session will move beyond the basics cover Android persistence mechanisms, accessing RESTful web services, and more. We'll look at shared preferences, basic file I/O, and the Sqlite database. We'll also show how to operate off of the UI thread to access data from remote servers.

The application will access JSON data on a remote server, parse the data, and update the user interface based on the response.

Groovy is unusual among programming languages in that it doesn't seek to replace its predecessor. You can freely mix Groovy with Java on a class-by-class, or even line-by-line, basis. If you are working with Java, there's no reason not to make your life easier by adding Groovy where it helps the most.

Groovy helps Java in many ways, especially when processing XML or JSON data, replacing anonymous inner classes, adding tons of library methods that Java has needed all along, vastly simplified file and database manipulation, and much more. This talk will demonstrate how you can add Groovy to Java applications and simplify your development job immediately.

The Gradle build tool is one of the most successful projects in the Groovy ecosystem because it addresses a difficult problem – every major build is a custom build. Gradle builds are written in Groovy, so the full power of the language is available if you need it. Gradle supports Maven project structure and repositories and uses Ivy dependency management without being bound by their normal constraints. With major systems like Grails, Hibernate, and the Spring Framework moving to Gradle, this is a technology worth taking the time to understand.

This talk will cover the basics of Gradle both through simple examples and by examining the build files for major open source projects.

Early releases of Java performed poorly, but those issues largely disappeared long ago with the introduction of HotSpot. However, much of the performance advice for Java persists through hearsay from those early days.

In this talk, we'll forget the hearsay and take an objective look using benchmarking and profiling tools to find out which optimizations matter today and just as importantly those that don't.

Today, we all benefit from the sophistication of modern compilers and hardware, but that extra complexity can also make it difficult to reason about performance.

In this talk, we'll examine some surprising performance cases and learn how to
use profiling and benchmarking tools to better understand our modern execution environments.

Go is a very interesting language, open-sourced by Google in late-2009, that takes a “less is more” (http://commandcenter.blogspot.de/2012/06/less-is-exponentially-more.html) approach to language design, but that also bakes in a powerful concurrency model.

This talk will introduce Go, delve into its distinctives, and contrast its approach with that of Java (where appropriate). We'll also write a fair amount of Go code along the way. This talk will be of particular interest to Java developers looking to add Go to their toolkits, but will also be of interest to anyone looking to learn a little bit more about Go.

Topics will include:

• Go Syntax Overview
• Why Go?
• Contrasts with Java:
• Small language features and Idioms
• Packaging and Modularity
• Object-Oriented Constructs
• Concurrency with Goroutines and Channels
• Your Go Toolchain:
• Workspace
• The “go” Build Tool
• Dependency Management
• Testing
• Editors/IDE Support

Visibility is one of the primary characteristics of applications that aren’t just coded well, but run well in production. We need visibility to understand:

• how our system performs
• how our system misbehaves
• how our system fails
• how our users interact with our system
• what’s providing value to users and what’s not
• and more!

In this talk we’ll look at the three disciplines of monitoring, metrics, and logging, and see how properly used, they can dramatically increase our system’s inherent visibility.

Topics will include:

• what metrics should we collect?
• how should we expose those metrics?
• can frameworks help?
• what should we monitor?
• monitoring components vs. systems
• building dashboards
• the art of logging
• log aggregation and analysis
• tools, tools, tools, tools!

Unlike earlier languages, Java had a well-defined threading and memory model from the beginning. And over the years, Java gained new packages to help solve concurrency problems.

Despite this, Java concurrency is sometimes subtle and fraught with peril.

In this talk, you'll learn these subtleties. And finally, you'll learn how to handle concurrency by exploring the concepts behind java.util.concurrent and other concurrency libraries.

HotSpot promises to do wonders for us by Just-in-Time (JIT) compiling the “right” code for us, but how does it makes those decisions? And, perhaps more importantly, what happens when it's wrong?

In this talk, you'll learn through real code examples just how the JVM decides to compile your code, deoptimize your code, and stop-the-world for a GC.

Most of us don't want to go back to the days of malloc and free, but the garbage collector isn't always our friend.

In this presentation, you'll learn about the different garbage collection strategies used in JVMs, how to monitor garbage collection, analyze memory dumps, and why you might want to use one collection strategy instead of another.

Back in the day, web developers had to rely on their wits and a plethora of alert statements - to say our toolkit was spartan would be an understatement. But with the increased importance of web front ends and the rise of JavaScript MVC frameworks, a modern web developer toolkit is finally emerging.

We've evolved from text editors to full fledged IDE's with code completion and refactoring tools but our toolchain doesn't end there. With multiple testing libraries, mocking frameworks, test drivers and even code coverage tools, today's web developer gets to walk downhill on a sunny day.

Take a look at your codebase. Go ahead, this abstract will wait. Notice anything? Perhaps a few more lines of JavaScript than years past? JavaScript is no longer an outlier, a language for the interns, something we can just mash together. Today, JavaScript is a first class citizen. As such, we need to treat it will all the care and feeding we extend our server side languages. This talk will introduce you to a set of tools that will help you write bulletproof JavaScript.

Step one, make sure we aren't making any basic mistakes like using == when we really mean ===. To remedy these types of bugs, we'll leverage JSHint to statically analyze our code. In addition to walking through the setup, we'll discuss how to ratchet up the rules as you improve your codebase. Just like Java or C#, we also need to test our JavaScript code. We'll introduce Jasmine, a BDD style testing tool as well as other tools that make help in the testing process. Last but not least, we'll take a tour of Plato, a JavaScript source code visualizer. Taken together, these tools can go a long way to improve your JavaScript code.

Didn't you hear the news? TDD is dead. Yet many developers rely on it for quality code. Come join the zombie apocalypse and learn and understand TDD, what sets it apart from unit testing after the fact, what to do when you need to update code, effective mocking, automatically generating test data and lots of it, leaving code alone and respecting your work, and more

This presentation will cover:

• What is TDD?
• Benefits of TDD
• How to TDD
• Mocking
• The Great TDD Debate
• Opinions of TDD from Industry Leaders
• JVM Testing Tools
• JVM Testing Languages
• Testing Static Calls
• Updating Code

The Semantic Web and its related technologies provide an incredibly powerful model for driving the cost of data integration down to nearly zero. So, how do we deal with developers who are overwhelmed, frightened or annoyed by its data models and formats?

We really do not have to devolve into Webs of Haves and Have nots when it comes to semantically rich, interoperable data and modern application tools, frameworks and user interfaces. There is a surprisingly simple mechanism by which “normal” developers can benefit from the power of the Semantic Web and the latter's developers can integrate with the panoply of tools and toys under constant development by the former.

The trick is JSON-LD. A simple, but deliberately designed extension to JSON that bridges both worlds and is finding its way into many other uses by the likes of Google and GitHub.

We will learn about:

• the JSON-LD format
• how to frame, sign and validate it
• how to convert it to/from RDF
• how to describe Hypermedia systems with Hydra and JSON-LD
• how to embed and consume JSON-LD in HTML documents
• how JSON-LD is being used in a variety of mass market ways

With the advent of microservice and cloud-native application architectures, building distributed systems is becoming increasingly common for the enterprise Java developer. Fortunately many of the innovators in the space, including Twitter, LinkedIn, and Netflix, have embraced the JVM as they’ve built increasingly complex systems, with Netflix open-sourcing much of its toolkit for constructing these systems at NetflixOSS.

Spring Cloud provides tools for developers to quickly build some of the common patterns in distributed systems. Many of these patterns are provided via wrapping the battle-tested components found at NetflixOSS.

Coordination of distributed systems leads to boiler plate patterns, and using Spring Cloud developers can quickly stand up services and applications that implement those patterns. They will work well in any distributed environment, including the developer's own laptop, bare metal data centres, and managed platforms such as Cloud Foundry.

Patterns and implementations we’ll examine include:

• configuration management
• service discovery
• circuit breakers
• intelligent routing
• micro-proxy
• control bus
• one-time tokens
• global locks
• leadership election
• distributed sessions
• cluster state

Have you looked into Scala? Scala is a new object-functional JVM language. It is statically typed and type inferred. It is multi-paradigm and supports both object oriented and functional programming. And it happens to be my favorite programming language.

If you are interested in Scala, how you are planning to learn Scala? You probably are going to pick up a book or two and follow through some examples. And hopefully some point down the line you will learn the language, its syntax and if you get excited enough maybe build large applications using it. But what if I tell you that there is a better path to enlightenment in order to learn Scala?

Scala Koans, a set of test cases that will teach you Scala language. The Scala koans will help the audience learn the language, syntax and the structure of the language through test cases. It will also teach the functional programming and object oriented features of the language. Since learning is guided by failing tests it allows developers to think and play with the language while they are learning.

Workshop Requirements

Namaste,

For those planning to attend the Scala Koans…

Welcome to Scala Koans!

Scala Koans is an interactive session that puts the programming and learning in your hands. Therefore, a laptop is required by all participants. If you do not have a laptop, then perhaps you have a friend with a laptop, is so, well, that would work too. In order to participate in the Scala Koan endeavor, a few things are required:

• A laptop
• A modern JDK installation. JDK 1.6+ will suffice. Remember that it should be a JDK and not a JRE!
• Your JDK should be mapped properly to JAVA_HOME and your PATH variables.
• An installation of your favorite IDE or editor.
• An inquisitive mind.

The process of actually running the koans will be covered during the session. Unfortunately, Internet connectivity is sometimes a dicey affair and at times it can rain on our parade. To avoid having to wait for the install at the conference you can prepare for the koans before the conference! If you don't have the opportunity to do this, we will have either memory sticks or private networks at the conference.

If you want to get started with the set up:

1. Download the koans by visiting https://bitbucket.org/dmarsh/scalakoansexercises and click on the download link on the right hand side of the page. (or you can clone the bitbucket project)
2. Unzip the koans: dmarsh-scalakoansexercises-#####.zip
3. cd into the dmarsh-scalakoansexercises-#### folder
4. If you are in Linux or MacOSX run: ./koans, on Windows ./koans.bat
5. After some initialization, you are now in the koans/sbt shell (you should see a > prompt)
6. In the shell run the following commands:
   a. test:compile
   b. eclipse (if you are planning to use Eclipse)
   c. gen-idea (if you are planning to IntelliJ Idea)
7. Exit the shell by typing exit

Before attending the koans session, you may want to take the opportunity to load some Scala Plugins onto your favorite IDE and Editor. Below is a list of resources that you can use to enhance your environment so that you can enjoy Scala syntax highlighting and other helpful tools like refactoring, debugging and analysis.

Eclipse - The Eclipse has an IDE plugin for Scala called aptly scala-ide. All the information about the plugin can be found at http://scala-ide.org including an easy to follow along video located at http://scala-ide.org/docs/current-user-doc/gettingstarted/index.html. Scala-IDE is also available at the Eclipse Marketplace!

IntelliJ - IntelliJ has a Scala plugin that can be found by going to Settings -> Plugins, clicking on 'Browse Repositories' button and searching for the 'Scala' plugin on the left. Right click on the 'Scala' and choose 'Install'. IntelliJ will prompt you to restart the IDE, do so, and enjoy.

NetBeans - Currently, Github user 'dcaoyuan' hosts a NetBeans Scala plugin at the address: https://github.com/dcaoyuan/nbscala. I have not tried this out since the number of NetBeans users has shrunk in recent years. If you are an avid NetBeans user, and wish to try it, you can let me know the results during the session. There is additional information at: http://wiki.netbeans.org/Scala

Emacs - Github user 'aemoncannon' has created 'ENSIME' (ENhanced Scala Interaction Mode for Emacs) at the address and has a great following. https://github.com/aemoncannon/ensime with some documentation at http://aemoncannon.github.io/ensime.

VIM - For VIM users you can use https://github.com/derekwyatt/vim-scala as a VIM plugin that offers Scala color highlighting

That is it. Hope to see you soon.

Have you looked into Scala? Scala is a new object-functional JVM language. It is statically typed and type inferred. It is multi-paradigm and supports both object oriented and functional programming. And it happens to be my favorite programming language.

If you are interested in Scala, how you are planning to learn Scala? You probably are going to pick up a book or two and follow through some examples. And hopefully some point down the line you will learn the language, its syntax and if you get excited enough maybe build large applications using it. But what if I tell you that there is a better path to enlightenment in order to learn Scala?

Scala Koans, a set of test cases that will teach you Scala language. The Scala koans will help the audience learn the language, syntax and the structure of the language through test cases. It will also teach the functional programming and object oriented features of the language. Since learning is guided by failing tests it allows developers to think and play with the language while they are learning.

Workshop Requirements

Namaste,

For those planning to attend the Scala Koans…

Welcome to Scala Koans!

Scala Koans is an interactive session that puts the programming and learning in your hands. Therefore, a laptop is required by all participants. If you do not have a laptop, then perhaps you have a friend with a laptop, is so, well, that would work too. In order to participate in the Scala Koan endeavor, a few things are required:

• A laptop
• A modern JDK installation. JDK 1.6+ will suffice. Remember that it should be a JDK and not a JRE!
• Your JDK should be mapped properly to JAVA_HOME and your PATH variables.
• An installation of your favorite IDE or editor.
• An inquisitive mind.

The process of actually running the koans will be covered during the session. Unfortunately, Internet connectivity is sometimes a dicey affair and at times it can rain on our parade. To avoid having to wait for the install at the conference you can prepare for the koans before the conference! If you don't have the opportunity to do this, we will have either memory sticks or private networks at the conference.

If you want to get started with the set up:

1. Download the koans by visiting https://bitbucket.org/dmarsh/scalakoansexercises and click on the download link on the right hand side of the page. (or you can clone the bitbucket project)
2. Unzip the koans: dmarsh-scalakoansexercises-#####.zip
3. cd into the dmarsh-scalakoansexercises-#### folder
4. If you are in Linux or MacOSX run: ./koans, on Windows ./koans.bat
5. After some initialization, you are now in the koans/sbt shell (you should see a > prompt)
6. In the shell run the following commands:
   a. test:compile
   b. eclipse (if you are planning to use Eclipse)
   c. gen-idea (if you are planning to IntelliJ Idea)
7. Exit the shell by typing exit

Before attending the koans session, you may want to take the opportunity to load some Scala Plugins onto your favorite IDE and Editor. Below is a list of resources that you can use to enhance your environment so that you can enjoy Scala syntax highlighting and other helpful tools like refactoring, debugging and analysis.

Eclipse - The Eclipse has an IDE plugin for Scala called aptly scala-ide. All the information about the plugin can be found at http://scala-ide.org including an easy to follow along video located at http://scala-ide.org/docs/current-user-doc/gettingstarted/index.html. Scala-IDE is also available at the Eclipse Marketplace!

IntelliJ - IntelliJ has a Scala plugin that can be found by going to Settings -> Plugins, clicking on 'Browse Repositories' button and searching for the 'Scala' plugin on the left. Right click on the 'Scala' and choose 'Install'. IntelliJ will prompt you to restart the IDE, do so, and enjoy.

NetBeans - Currently, Github user 'dcaoyuan' hosts a NetBeans Scala plugin at the address: https://github.com/dcaoyuan/nbscala. I have not tried this out since the number of NetBeans users has shrunk in recent years. If you are an avid NetBeans user, and wish to try it, you can let me know the results during the session. There is additional information at: http://wiki.netbeans.org/Scala

Emacs - Github user 'aemoncannon' has created 'ENSIME' (ENhanced Scala Interaction Mode for Emacs) at the address and has a great following. https://github.com/aemoncannon/ensime with some documentation at http://aemoncannon.github.io/ensime.

VIM - For VIM users you can use https://github.com/derekwyatt/vim-scala as a VIM plugin that offers Scala color highlighting

That is it. Hope to see you soon.

Big up front design is discouraged in agile development. However, we know that architecture plays a significant part in software systems. Evolving architecture during the development of an application seems to be a risky business.

In this presentation we will discuss the reasons to evolve the architecture, some of the core principles that can help us develop in such a manner, and the ways to minimize the risk and succeed in creating a practical and useful architecture.

Creating code is easy, creating good code takes a lot of time, effort, discipline, and commitment. The code we create are truly the manifestations of our designs. Creating a lightweight design can help make the code more extensible and reusable.

In this presentation we will take an example oriented approach to look at some core design principles that can help us create better design and more maintainable code.

Encryption is a powerful tool for privacy. At least that is what we're meant to think.

If you consider encryption to be a black box of magic, you should probably attend this talk.
If you think encryption will protect your secrets, you should probably attend this talk.
If you have (or haven't) been following the news, you should probably attend this talk.

The truth is, encryption can be an effective way of making it harder for people to steal your secrets. But it isn't magical, it isn't fool proof and, depending on how you are using it, may be completely useless. It is a hard topic that we'll only touch the surface on, but there are very few topics that are more crucial for our industry and profession to understand better than encryption. You don't have to understand the math (although that will help), but you do have to understand what it will and won't do for you*.

*and how implementations of it may have been intentionally compromised

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

Publishing information as webs of data 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.

The cost of integrating information isn't cheap. Well, at least it isn't if you do it wrong. Chances are, you're doing it wrong.

The single most difficult aspect of data integration is the effort to achieve consensus. It isn't just that we are disagreeable people. It's also that it is a fantasy that there is a “common model” or a “global truth”. Different groups and individuals see the world differently and have different needs from information systems. Language, and therefore what we call things, isn't simply reflective of reality. It plays a constructive and interpretive role.

The problem is that our technologies force us to make choices about world views and pretend that things aren't changing constantly. This yields fragile systems and high impedance to change that cascades through our organizations. This translates to expensive, rigid and difficult to extend failure to give the business what they want.

Our friend Tim Berners-Lee and his Happy W3C Merrymakers have given us a set of technologies to help us solve these problems though. We forget that the Web he designed was not the public Web, but one to solve integration needs for complex organizations like CERN. The HTML bit that we have gotten so excited about is but a small part of the vision. We will introduce RDF and SPARQL as enabling technologies. They do not necessarily replace what you already have, but they do make it possible to share information with people you've never talked to: Collaboration without Coordination.

Almost every example of an agile project involves a single team and while many successful projects are delivered that way, most enterprise software requires the interaction of several teams. But how do we scale agile beyond a single team? What practices translate and which ones don't? In this talk we'll discuss some of the issues you'll encounter as you move agile beyond a single group and how you can keep multiple stakeholders happy. While it isn't as simple as having a “scrum of scrums” it isn't as hard as replacing every line of COBOL.

Almost every example of an agile project involves a single team and while many successful projects are delivered that way, most enterprise software requires the interaction of several teams. But how do we scale agile beyond a single team? What practices translate and which ones don't? In this talk we'll discuss some of the issues you'll encounter as you move agile beyond a single group and how you can keep multiple stakeholders happy. While it isn't as simple as having a “scrum of scrums” it isn't as hard as replacing every line of COBOL.

To write efficient SQL, you need to understand SQL execution plans. And to write efficient Java, you need to understand the JVM's execution plan.

In this talk, you'll learn how the JVM's Just-in-Time compiler analyzes Java code. Then we'll go through an example in detail to see how code optimization really works.

The key to understanding Clojure is ideas, not language constructs.
In this talk, we will approach Clojure via 10 Big Ideas.

Each of these ideas is valuable and useful a la carte, not necessarily
only in a Clojure together. Taken together, they beging to fill in the
picture of why Clojure is changing the way many programmers think
about software development.

• edn
• Persistent Data Structures
• Atomic Success Model
• Seqs
• Protocols
• ClojureScript
• Reducers
• core.logic
• Datalog
• core.async

Architectural Briefings are interactive presentations by and for architects on specific technology topics. The purpose is to empower architects to make decisions about the choice and application of tech. Note that you don't have to have “Architect” in your title to participate, this is for anybody who makes architectural decisions.

Developers make decisions all the time, and can never have enough information and support. At Cognitect, we run a weekly Architectural Briefing as a resource for the team. Everybody participates, both attending and speaking. In this talk, we will cover

• a template for Architectural Briefings
• how to develop and present an Architectural Briefing
• how to run an Architectural Briefing program in your organization

We will finish with an example briefing, showing how these ideas come together.

We started with documents on the Web. Then we realized we could share data using the same technologies. And then services. Concepts were next to help us organize all of this information. And now, we want Things on the Internet and Web too. Fortunately, we already have much of the infrastructure to welcome all of these new physical information producers and consumers to the party.

This talk will be a high level overview of how the Internet of Everything scales to accept entire new classes of devices and how we make sense of it all. We will also look toward the future of where we are going next.

The software industry changes rapidly, but you can protect yourself
from these changes by creating code that is complicated enough that
only you can maintain it.

Of course you should not engage in obvious bad practices. The good
news is that you don't have to. You can follow idiomatic industry
practice and stay buzzword compliant with the latest trends, while
quietly spreading complexity throughout systems. Better yet, the
symptoms will show up not in your own code, but in other code that
uses your code, directly or indirectly. You will be a hero as you
lead larger and larger teams burning the midnight oil to keep systems
alive.

Practice these principles, and your code will have an
infectious complexity that guarantees you will always be needed to
maintain it.

• Use OO, and don't forget those setter methods!
• Prefer APIs over data.
• Start with DSLs.
• Always connect (and never enqueue).
• Create abstractions for information.
• Use static typing across subsystem boundaries.
• Put language semantics on the wire.
• Write lots of unit tests.
• Leverage context.
• Update information in place.

Apache Hadoop is a powerful and sometimes complex tool for dealing with Big Data as well as high data throughput applications which can enable some existing applications to finally run right as well as open doors for entirely new types of applications and analysis. So the question is how does one get started with Hadoop? This presentation explores the various introductory aspects of the Hadoop infrastructure, data sources and query strategies and planning so you can get started with Hadoop.

Through this introductory no non-sense presentation we will explore various environmental options to design your initial cluster; such as physical vs virtual environments. In addition, we will explore various data ingestion and modeling strategies so you can populate your new cluster with the data required for your analysis in an Agile way. Finally, we will review various strategies available to process and query your data so you can get value from the cluster.

More and more companies are relying on timely and accurate analytics from their “Big Data” systems. Unfortunately, testing toolsets and concepts common in other technical disciplines is lacking. A common and incorrect perception exists in “Big Data” that proper testing is impossible due to dataset size and tool complexity. This overview session will examine a sampling of Hadoop testing tools and processes available today which you can use on your projects today.

Testing “Big Data” can mean big time investment; several hours often spent just to realize you made a simple typo. You fix the typo and then wait another couple hours for your script to hopefully complete. Even if the Big Data script or program ran to completion are you sure your data analysis is functionally correct? Getting programs to run to completion and have comfort that your analytic output is functionally correct is one of the biggest hidden problems in “Big Data” today. We all know we need to test and verify our scripts and programs, but given the large dataset sizes we are all working with, each test run can take hours, making proper testing unreasonable to do with the demand for quick turn-arounds.

This overview presentation will focus on surveying two areas of the testing problem; (1) establishing efficient test datasets and (2) Hadoop centric testing tools such PigUnit, Junit for Pig and Hive UDF testing, BeeTest for Hive testing among other tools of interest.

Apache Pig Latin is a high powered and easy to learn data flow language available for the Hadoop ecosystem. With Pig it is possible to perform various ETL type data processing activities on traditional structured, hierarchal structured as well as unstructured data. In this presentation we will examine the some of the capabilities of Pig Latin so you can get started with your ETL activities in Hadoop.

Apache Pig is a high powered and easy to learn data flow language available for the Hadoop ecosystem. With Pig it is possible to perform various ETL type data processing activities on traditional structured, hierarchal structured as well as unstructured data. In this presentation we will examine the some of the capabilities of Pig Latin so you can get started with your ETL activities in Hadoop.

During the presentation we will illustrate many of the Pig Latin features with code examples. In addition, we will cover various Pig debugging and process log examination to help you make the most of your development time.

Being a professional software engineer, it's easy to fall into the belief that one's role in a company is to write code.
Another perspective might be that one's role is to solve problems for the business and that writing code is merely one of several tools available to help solve those problems.

There are numerous problem-solving “anti-patterns” that are rampant in the industry today. “Forewarned is forearmed” as they say. In addition to highlighting these “anti-patterns” with real-life examples and the (sometimes) disastrous consequences, Michael asks some of the difficult questions about our true motivations for our decisions and how our decisions can either positively or negatively affect our team and our organization.

We all have an innate sense of what's possible. Not only is this how magicians fool you, but it might also be what's holding you back.

In this session Michael Carducci shares how he applied lessons learned in his career as a professional magician to his “day-job” as a software engineer.

Magicians have a simple process for creating new material; think of the most impossible thing you can imagine, the engineer a way to make it possible. Michael has been engineering solutions to “impossible” problems for nearly 20 years and this has given him a unique perspective on dealing with challenges in all aspects of his life.

This talk combines illusion, anecdotes and real-world examples to help identify and overcome your mental obstacles.

Relational databases are the foundation to countless systems but are often abstracted away and ignored until queries start timing out. Learn the essentials of indexing, query tuning and database design; all explained with a deck of playing cards.

We start with the fundamentals: Normalization, the 7 types of joins (that's right, 7!) and internal data structures.

From there we dive deep into how indexes work, performance considerations of indexes and even why the database sometimes ignores your indexes.

Digging even deeper, learn the three ways the database will implement a join. Finally learn some miscellaneous tips to improve your SQL and security.

In this session, we'll see how to build real Spring applications using Spring Boot. We'll also look under the covers to see what makes Spring Boot tick.

Spring offers a number of configuration options: XML configuration, Java configuration, and Groovy configuration to name a few. To some degree, component-scanning and autowiring help eliminate some explicit configuration. But in general most Spring applications require some essential “bootstrap” configuration to enable key functionality. What's the right way to build Spring applications when there are so many choices?

What if I told you that configuration was optional?

Spring Boot is an exciting new programming model for Spring that makes it extremely easy to create stand-alone, production-ready Spring applications. Rather than writing lots of code to satisfy the needs of a framework, Spring Boot helps you focus your coding efforts on your application. Spring Boot takes an opinionated approach to configuring Spring, making it possible to create Spring applications with little or, in some cases, no Spring configuration at all!

This 2015 presentation covers the Guava library developed by Google. Guava provides collection extensions to the Java Collection API and, along with this, a cornucopia of time-saving utilities that bring Java as close as possible to some of the more functional
and/or dynamic language competitors like Scala, Ruby, and Clojure. Why a brand spanking new 2015 version of this presentation? Well, there more new stuff to learn and use!

This presentation covers briefly on the tried and true stuff like functions, predicates and how they interact with Java 8. It covers how to use new collection constructs that make life easier, including MultiMap, BiMaps, and MultiSets, immutable collections, handling Futures with callbacks and shutdowns, caches, and then we will dwell on tons of the newer features that came with Releases 16, 17, and 18.

Technology changes, it's a fact of life. And while many developers are attracted to the challenge of change, many organizations do a particularly poor job of adapting. We've all worked on projects with, ahem, less than new technologies even though newer approaches would better serve the business. But how do we convince those holding the purse strings to pony up the cash when things are “working” today? At a personal, how do we keep up with the change in our industry?

This talk will explore ways to stay sharp as a software professional. We'll talk about how a technology radar can help you stay marketable (and enjoying your career) and how we can use the same technique to help our companies keep abreast of important changes in the technology landscape. Of course it isn't enough to just be aware, we have to drive change - but how? This talk will consider ways we can influence others and lead change in our organizations.

Time is very precious and is often threatened by phone calls, emails, co-workers, bosses, and most of all, yourself. The Pomodoro Technique reigns in unfocused time and gives your work the urgency and the attention it needs, and it's done with a kitchen timer.

In this presentation we discuss how to set up, estimate time, log time, deal with interruptions, and integrate with Agile as a team. We discuss timer software and even some of the great health benefits of the Pomodoro Technique.

A Technology Radar is a tool that forces you to organize and think about near term future technology decisions, both for you and your company. This talk discusses using the radar for personal breadth development, architectural guidance, and governance.

ThoughtWorks Technical Advisory Board creates a “technology radar” twice a year, a working document that helps the company make decisions about interesting technologies and where we spend our time. ThoughtWorks then started conducting radar-building exercises for our clients, which provides a great medium for technologists company-wide to express their opinions about the technologies they use every day. For companies, creating a radar helps you document your technology decisions in a standard format, evaluate technology decisions in an actionable way, and create cross-silo discussions about suitable technology choices. This session describes the radar visualization and how to conduct a radar building session for yourself. After a brief introduction, the bulk of the workshop consists of attendees building a radar for the group, following the same procedure you'll use when you do this exercise at your company. At the end, we'll have created a unique Radar for this event and practiced doing it for yourself.

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 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.

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.

The key to understanding Clojure web development is ideas, not language constructs. In this talk, we will approach Clojure web development via 7 Big Ideas. Each of these ideas is valuable and useful a la carte, and not necessarily only in Clojure. Taken together, they begin to fill in the picture of why Clojure is changing the way many programmers think about web development.

The key to understanding Clojure web development is ideas, not language constructs. In this talk, we will approach Clojure web development via 7 Big Ideas:

• edn, not json
• core.async, not callbacks
• platform, not language
• data, not objects
• protocols, not interfaces
• libraries, not frameworks
• Ash za durbatulûk!

Each of these ideas is valuable and useful a la carte, and not necessarily only in Clojure. Taken together, they begin to fill in the picture of why Clojure is changing the way many programmers think about web development.

Java 8 is the biggest change to the Java language ever. The addition of lambdas, functional interfaces, and streams fundamentally changes the programming model for applications. This talk summarizes those changes, along with optionals, method references, and other new features of the language.

Demonstrations will include the map/filter/reduce mechanism, the streaming API, how to write functional interfaces, predicates, suppliers, consumers, method references, default methods in interfaces, optionals, and more.

Functional programming is receiving much attention recently. Most mainstream languages, including C++, Java, and C# now support lambda expressions and functional style. Why is there a sudden interest in adapting something that was largely ignored for decades? What are the technical reasons, how do we benefit, in what ways can using these techniques make our applications better and our development efforts easier as well?

In this technical presentation we will learn about the technical underpinnings of functional programming, the fundamental problems they address, and the large impact of those on application development

Microservice architectures place great emphasis on autonomous product teams that develop and deploy equally autonomous services using decentralized release management, testing, and deployment strategies. I don’t have to wait on you to deploy my service, and you don’t have to wait on me. And yet the complexity associated with managing these large, distributed systems seems like it would demand even greater discipline and centralized coordination of testing activities. Fortunately, while greater discipline is in fact required, we don’t require the centralized coordination that would seem to destroy many of the benefits of embracing microservices. In this session will examine principles and practices that will help us develop an effective testing strategy for microservices.

Topics will include:

• who moved my trust boundary?
• expressing API’s as versioned contracts
• what’s in a contract? the good, the bad, and the ugly
• leveraging consumer-driven contracts
• exploratory testing for risk discovery
• recovery OVER prevention
• dogfooding

“Computers are useless. They can only give you answers.” –Picasso

If everything is explicitly described in uniform, robust and comprehensive data models, it is easy to imagine how to ask questions of the data. The social, technical and financial costs of getting the information into that state, however, will keep that from ever being a reality. So, how can we integrate and reason over choppy and sloppy data from multiple sources in a variety of formats? We will see how the RDFS and Web Ontology Language (OWL) W3C standards help us connect and reason over content that leaves things unsaid without writing a bunch of custom code.

This is not artificial intelligence, but it is influenced by work done in that field.