Modularity is coming to the Java platform! Java 9 will introduce the Jigsaw module system. OSGi is here today. But don’t wait to start designing modular software. Contrary to popular belief, you don't need a framework or a new runtime to start building modular software applications. You can start today. Learn how!

In this session, we'll examine what it means to develop modular software on the Java platform. We'll examine the goals and benefits of modular software, and explore the patterns of modular architecture that help us develop modular software systems. With just a few easy steps, we'll see how to transform our software from a huge monolith to an extensible system of collaborating software modules. By examining an existing software system, we'll see first hand how we can increase software modularity with minimal disruption. You'll walk away not just with a much deeper understanding of the benefits of modular software, but also a migration roadmap for refactoring existing applications to increase their modularity. In other words, you'll see how to get ready today for the application platform of tomorrow.

OSGi is the dynamic module system for the Java platform. Today, OSGi is a major part of most application platforms, tools, and is supported by many major frameworks. In this session, we'll explore the fundamental underpinnings of OSGi, explore the OSGi ecosystem, clearly articulate the benefits of OSGi, and examine OSGi in the context of other microservice architectures.

After a gentle introduction to OSGi, we'll explore how OSGi allows us to overcome classpath hell and design very adaptable and flexible software systems. Through several coding examples, we'll explore numerous OSGi techniques, including versioning, hot deployment, isolation, lifecycle, and OSGi specific microservices.

Traditional approaches to software architecture are broken. Attempts to define the architectural vision for a system early in the development lifecycle do not work. In today’s volatile technology and business climate, big architecture up front is not sustainable. In this session, we will explore several principles that help us create more flexible and adaptable software systems. But first, we’ll expose the true essence of what’s meant when we say “architectural agility.”

What’s the goal of architecture? To serve as a blueprint of the system that everyone understands? Possess the flexibility to evolve as new requirements emerge? To satisfy the architectural qualities, including performance, security, availability, reliability, and scalability? Yes. Yes. Yes. At the heart of these three questions are the three pillars of architecture - social, process, and structure. But how do we create software architectures that achieves all of these goals? And how do we ensure no disconnect occurs between developers responsible for implementation and architects responsible for the vision? In this session, we’ll explore several principles to increase architectural agility and provide some actionable advice that will help you get started immediately.

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.

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.

“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:

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!

In this session, we will take a look at Angular - the powerful MVVM SPA framework from Google. We will discuss some of the terminology that Angular offers, and see how we can use that to develop highly interactive, dynamic web applications. See “Detail” for a list of topics I cover and the Github repo URL

In this session we will take a look at Angular and using it to develop rich web applications. 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.

Note: This is an intro level talk. It is targeted towards developers who are curious about Angular and want to learn about the fundamental features and concepts in Angular.

Topics Covered -

Bootstrapping an AngularJS application using ng-app
ng-init and the evaluation {{ }} directive
A brief look at $rootScope and scoping rules
ng-model
Controllers, Dependency Injection, and the View-Model
Looping using ng-repeat
Forms using ng-form, form validation and submission in AngularJS
ng-messages to display form validation messages to the user
Angular provided filters and custom filters

GitHub URL - https://github.com/looselytyped/angudone-workshop/tree/solutions

In this session, we will take a look at Angular - the powerful MVVM SPA framework from Google. We will discuss some of the terminology that Angular offers, and see how we can use that to develop highly interactive, dynamic web applications. See “Detail” for a list of topics I cover and the Github repo URL

In this session we continue our discussion from Part I. As we continue to evolve our application we will seek to use, and understand a few more of AngularJS' core constructs.

Factories and services
Routing using ng-view and $routeProvider
AJAX calls to a backend using $http

If time permits we will look at a few good practices when developing AngularJS applications, ways to modularize your code, and some tools that aid in the development of AngularJS applications.

In this session we will look at some JavaScript patterns, and how you can use them within your code.

No longer can you think of JavaScript as a kiddie-scripting language. JavaScript has now been promoted to a first-class citizen within your application - and with this, comes the need to think of better abstractions, code re-use - even thinking of establishing a common vocabulary to discuss approaches to writing better, cleaner and ultimately more maintainable JavaScript code.

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 into microservices. But breaking apart the monolith has implications beyond software architecture and microservices are just one implementation alternative.

In this session, we will explore modularity’s fundamental role in a large scale software architecture. We’ll compare and contrast different implementation technologies for building modular architectures. And we’ll discover the impact that modern architecture has on infrastructure and methodology. Finally, we will examine how modern web and mobile apps fit into this overall architectural story.

Microservice architecture is a modern architectural approach that focuses on breaking apart the monolith and building modular services. But the framework we use has a tremendous impact on how we build and deploy services. A new type of framework has emerged that provides a lightweight stack for building microservices.

In this session, we will explore some modern Java micro frameworks for building microservices. Example frameworks you may see include Dropwizard, Spark, Ninja, RestExpress, Play, Restlet, and RestX.

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

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.

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.

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:

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

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

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

JavaScript will celebrate it's 24th birthday in 2020. For a language that has been around for such a while it has seen very few, if any changes to the language itself. Well all that is about to change with ECMAScript.next (or ECMAScript 6). ECMAScript 6 modernizes JavaScript syntax, while bringing in features such as modules for better namespacing, class as a first class construct, and a variety of additional operators thus ensuring that JavaScript is ready for the next era of large scale modern web applications. ES 7, 8, 9 and now 10 all use the features introduced by ES6 to further the language.

In this session we will take a look at some of the features that ECMAScript 6 / 7 / 8 / 9 and 10 bring to the table. We will take an exploratory approach, and by the end of 3 hours, you will be well versed with ALL of the new features in JavaScript.

JavaScript will celebrate it's 24th birthday in 2020. For a language that has been around for such a while it has seen very few, if any changes to the language itself. Well all that is about to change with ECMAScript.next (or ECMAScript 6). ECMAScript 6 modernizes JavaScript syntax, while bringing in features such as modules for better namespacing, class as a first class construct, and a variety of additional operators thus ensuring that JavaScript is ready for the next era of large scale modern web applications. ES 7, 8, 9 and now 10 all use the features introduced by ES6 to further the language.

In this session we will take a look at some of the features that ECMAScript 6 / 7 / 8 / 9 and 10 bring to the table. We will take an exploratory approach, and by the end of 3 hours, you will be well versed with ALL of the new features in JavaScript.

In this session, we'll dig deep into the performance aspects of JavaScript and the Web Browser. Single page web applications are becoming popular very quickly, and understanding the low-level and high-level aspects of the browser platform and JavaScript runtimes embedding in them are important.

We'll cover topics such as browser pipe-lining, memory management, testing and measuring performance.

The usage of JavaScript on the server is rising. In this session, we'll talk about all the tools and utilities that comprise a modern JavaScript application, from a server-side point of view.

The usage of JavaScript on the command line and server has exploded over the past couple of years. Node.js has become popular with development shops from startups to big corporations. With its asynchronous nature, JavaScript provides the ability to scale dramatically. Along with the ability to drive your server-side applications, there are a number of tools that help with all aspects of browser development: testing, packaging, and deployment. In this session, we'll explore these tools and show you how you can incorporate these into your environment.

JavaScript has first class support for functional programming. There are many techniques for writing code in more clear, and concise form, in JavaScript using these techniques. In this session, we'll explore these techniques and talk about how to implement them. We'll use commonly used libraries like underscore to make elegant JavaScript code.

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.

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 shadow DOM and components.

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.

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.

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.

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.

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!

Workshop Requirements

Some things will be required if you to participate in the workshop

A modern JDK installation. JDK 1.8+ 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.

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 Scala 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. But it is preferred to do the installation before the event.

For MacOSX:

Download brew package manager at http://brew.sh
At a console type: brew install scala

For Windows

Visit http://scala-lang.org/download
Download the .msi package
Install the .msi package

For Linux

Download the tar.gz package
Extract the package to your favorite directory
Export SCALA_HOME to your Scala directory (scala-2.11.x)
Add to your PATH: $SCALA_HOME/bin

You may also 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. You can either download the complete Scala IDE which includes the complete Eclipse download. You can also download the plugin. 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, although I would recommend getting the latest instructions from scala-ide.org

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

VSCode - Download the “Scala Language Plugin” from the plugins within VSCode.

That is it. Hope to see you soon.

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

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

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.

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.

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!

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.

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.

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.

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.

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

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.

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.

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.

This is a revised and updated version of the previous talk, with current thinking from practice and the literature. The talk presents why conflicts with your manager are inevitable based on differences in priorities and perspectives, and how to plan for them. The goal is to show you how to build the loyalty relationship that allows you to get what you need when you need it.

Topics covered will include diagnosing communication styles, lessons from game theory, working within the organizational hierarchy, and lessons on how to build a relationship with your manager that still allows you the freedom to express yourself and what you really want.

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.

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.

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.

Soft skills
Continuous Delivery
Understanding large codebases
Architecture patterns
Architecture anti-patterns
Tooling & documentation
Integration architecture
Integration styles
Introduction to enterprise architecture

To fully leverage knowledge, you need application. Part three of this workshop uses the public domain Architectureal Katas exercise to apply learnings from the first two parts.

From the Architectal Katas website:

Architectural Katas are intended as a small-group (3-5 people) exercise, usually as part of a larger group (4-10 groups are ideal), each of whom is doing a different kata. A Moderator keeps track of time, assigns Katas (or allows this website to choose one randomly), and acts as the facilitator for the exercise.

Each group is given a project (in many ways, an RFP–Request For Proposal) that needs development. The project team meets for a while, discovers requirements that aren’t in the orignal proposal by asking questions of the “customer” (the Moderator), discusses technology options that could work, and sketches out a rough vision of what the solution could look like. Then, after they’ve discussed for a while, the project team must present their solution to the other project teams in the room, and answer challenges (in the form of hard-but-fair questions) from the other project teams. Once that challenge phase is done, the room votes on their results, and the next project team takes the floor.

Part 3, Architectal Katas, is an instructor-led hands-on Katas exercise.

This multi-disciplinary session takes a deep dive into
the confluence of topics required to fully understand the intersection
of Continuous Delivery and architecture, including evolutionary
architecture and emergent design, with an emphasis on how
architectural decisions affect the ease in changing and evolving your
code, the role of metrics to understand code, how Domain Driven
Design's Bounded Context reifies in architecture, how to reduce
intra-component/service coupling, and other techniques.

Continuous Delivery is a process for automating the production
readiness of your application every time a change occurs – to code,
infrastructure, or configuration. In the Continuous Delivery world,
rather than hone skills at predicting the future via Big Design Up
Front, Continuous Delivery emphasizes techniques for understanding
and changing code with less cost during the process. Some architectures
and engineering practices yield better designs for this
environment. This multi-disciplinary session takes a deep dive into
the confluence of topics required to fully understand the intersection
of Continuous Delivery and architecture, including evolutionary
architecture and emergent design, with an emphasis on how
architectural decisions affect the ease in changing and evolving your
code, the role of metrics to understand code, how Domain Driven
Design's Bounded Context reifies in architecture, how to reduce
intra-component/service coupling, and other techniques.

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.

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.

In this session we will look to see how we can refactor our learning - what tools, and methodologies can we use to help us learn quicker and better - how we can create a store that gives us quick access to information when we really need it.

We all work in an industry in which not only do the tools that we use change ever few years, but one in which we have to shift the very paradigms these tools are built on! Even the most trivial of projects entails tens of different toolkits, frameworks, and languages coming together, and somehow we need to know how to leverage each one. How does one keep up? Despite all our years in schools, and our in-born nature to learn, we often are never taught how to learn. How can we learn faster, and retain even more?

In this session we will take a look at various tools and techniques available to us and see how we can make our learning effective.

The Groovy Parallel Streams framework is a Groovy library for performing both Java and Groovy tasks concurrently. It offers many high-level concurrency abstractions, from Actors to Dataflow operators to Agents and Parallel Collections.

After reviewing the basic concepts, demonstrations will include communicating sequential processes, promises, dataflow concurrency, and concurrent collection processing. As multi-core and multi-processor systems become pervasive, the need for algorithms that take advantage of them becomes more and more critical. GPars is a powerful library with a straightforward syntax for managing concurrency.

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.

The surge of interest in the REpresentational State Transfer (REST) architectural style, the Semantic Web, and Linked Data has resulted in the development of innovative, flexible, and powerful systems that embrace one or more of these compatible technologies. However, most developers, architects, Information Technology managers, and platform owners have only been exposed to the basics of resource-oriented architectures.

This talk, based upon Brian Sletten's book of the same name, is an attempt to catalog and elucidate several reusable solutions that have been seen in the wild in the now increasingly familiar “patterns” style. These are not turn key implementations, but rather, useful strategies for solving certain problems in the development of modern, resource-oriented systems, both on the public Web and within an organization's firewalls.

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.

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.

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.

Agile ATAM
Continuous Delivery for architects
Applying abstraction
Comparing architectures
SOAP vs REST/ WS vs Messaging
SOA deep dive
Integration hubs
Enterprise architecture approaches
Enterprise architecture strategies

As we move toward microservices, we learn to properly decompose not only our behavior model, but also our data model into bounded contexts. This data decomposition is not without consequences. By placing strict boundaries around ownership of domain concepts, we make it more difficult to refer to concepts that naturally want to cross these boundaries. How do we “denormalize” these entities effectively? How do we keep these representations in sync? What do transactions look like? How do we ask BIG questions that span multiple contexts? These are the questions that we’ll dive into in this session.

Topics to include:

CAP Theorem
Embracing Eventual Consistency
Command-Query Responsibility Segregation (CQRS)
Caching
Event Sourcing
Lambda Architecture

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

Are you getting optimal performance from your database? Do you secretly wonder if your my.cnf is even close to tuned for your hardware and workload?
In part 1 we embark on a deep dive into DB Design, Indexes, query tuning and configuration.

Learn the tools and techniques to make good design decisions to maximize performance. How to interpret query plans and benchmark and tune your queries. Leave with a deeper understanding of all the various configuration options available and how each affects performance.

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.

Central Iowa Software Symposium

August 7 - 9, 2015

Workshop Requirements

Workshop Requirements

TEST