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.

Despite our wishing it were so, software architecture is not static throughout a project. Yet, we make many of our software architecture decisions early in the software development lifecycle. In today’s volatile technology and business climate, big architecture up front is not sustainable. In this session, we will explore several techniques 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? Possess the flexibility to evolve as new requirements emerge? To satisfy the architectural qualities, including performance, security, availability, reliability, and scalability? Yes. Yes. Yes. 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? Especially in a volatile technology climate where organizations seek to move their applications to the cloud, expose application capabilities to new endpoints, and deliver new capabilities quickly? In this session, we’ll explore techniques to increase architectural agility and provide some actionable advice that will help you get started immediately.

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, and clearly articulate the benefits of OSGi.

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

Monolithic applications are difficult to understand, maintain, and extend with new features and functionality. Modularity helps achieve these goals. Unfortunately, few applications have been designed with modularity in mind. In this workshop, we take a deep dive into modularity.

In part 1, we'll start developing a software system using several of the patterns of modular architecture. We'll explore the patterns and then apply them to develop a sample application. Along the way, we'll discuss implementation variations and the consequences of our decision. When finished, we'll have a simple but useful application that you can take home with you and easily extend with new functionality. This session is all pure Java, and you'll be able to apply the techniques you learn immediately. Be sure to bring a laptop.

In part 2, we'll finish the exercise we began in part 1. We'll continue applying several of the patterns of modular architecture. Upon completing the application, we'll have a short retrospective to discuss the consequences of our design decisions. To wrap up, we'll explore how using a framework (OSGi) that supports modularity extends the benefits of our modular architecture over to runtime without impeding our ability to leverage our modules directly atop standard Java. Be sure to bring a laptop.

Becoming more agile

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.

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.

Find yourself overwhelmed with hundreds of to-dos? Is your hard-drive littered with dozens of killer ideas that you started with enthusiasm and then just fizzled away? Do you feel like you are moving as fast as can but only getting to the wrong place quicker? Well perhaps this session will help.

There are various techniques and strategies available to us today that aim to help with exactly this conundrum - from Getting Things Done ™ to Personal Kanban. Unfortunately it is often easy to be extremely productive using these systems, but not very effective. After all, it's not about getting things done, but getting the RIGHT things done. In this talk we will discuss not only how to get things done, but also attempt to figure out what it is you actually need to be doing.

In this session, I will attempt to show you how you can leverage various strategies to be more effective, knock to-dos out and have fun while doing it. If time permits we will close with an overview of the tools that are available to you, and how you can use these to become a to-do list ninja :)

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.

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.

Over the years, Java developers have learned through trial-and-error the best ways to use Java's type system. But certain parts of the type system like wildcard generics and covariant return types are
under used; in-part, because they are not well understood.

Fortunately by going back to the mathematical roots of type systems, we can understand not only wildcard types and covariance, but also why we should prefer composition over inheritance and even how compilers perform some of their optimization magic.

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.

In this session, we will take a look at Angular - a new MVC framework by 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

This is an intro-level talk we will take a look at Angular and developing 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
ng-model
Controllers, Dependency Injection, and the View-Model ($scope)
Looping using ng-repeat
Forms using ng-form, form validation and submission in AngularJS
Angular provided filters
Making AJAX requests using $http

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

JavaScript will celebrate it's 19th birthday in 2014. 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.

In this session we will take a look at some of the features that ECMAScript 6 brings to the table and see what kind of browser support is available for it.

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.

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!

In this presentation, we'll see how to use Spring to create, secure, streamline, hyperlink, and consume REST APIs.

In modern applications, there are a diverse array of clients consuming content from the web. Each of these clients has unique capabilities and limitations, therefore demanding presentation of the application to be tailored to each device. As a result, presentation logic is often pushed into the client itself, leaving the application to serve a common data-oriented lightweight API to be consumed by each client.

cloud architecture… an architectural walk through cloud services and components

high level
Data Centers / VDC
CDN
Monitoring
Load Balancing
Queue
Storage (s3, etc)
DNS
Search
Routing
(Amazon + Open Source) example: CloudSearch vs ElasticSearch
Security

low level
HAProxy
Nerve
synapse
queues
compute
dns

cloud architecture… an architectural walk through cloud services and components

high level
Data Centers / VDC
CDN
Monitoring
Load Balancing
Queue
Storage (s3, etc)
DNS
Search
Routing
(Amazon + Open Source) example: CloudSearch vs ElasticSearch
Security

low level
HAProxy
Nerve
synapse
queues
compute
dns

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.

Many software developers point their career towards ascending to the gilded rank of Architect…but what does it mean to actually be one? While many of us labor under false pretense of abject technical decision making, the reality is often very different. You'll code less, spending more time on activities that lack an objective green/red bar. But you'll also an opportunity to impact far more than one project.

In this talk, I'll speak to my own journey. We'll touch on influencing coworkers, the importance of communication and the importance of cup of coffee.

winning with agile by analyzing the failings of others

Simulation allows a rigorous, scalable, and reproducible approach to testing. The separation of concerns, and the use of a versioned, time-aware database, give simulation great power. This talk will introduce simulation testing, walking through a complete example using Simulant, an open-source simulation library.

Simulation allows a rigorous, scalable, and reproducible approach to testing:

Statistical modeling

Simulation begins with statistical models of the use of your system. This model includes facts such as “we have identified four customer profiles, each with different browsing and purchasing patterns” or “the analytics query for the management report must run every Wednesday afternoon.” Models are versioned and kept in a database.

Activity streams

The statistical models are used to create activity streams. Each agent in the system represents a human user or external process interacting with the system, and has its own timestamped stream of interactions. With a large number of agents, simulations can produce the highly concurrent activity expected in a large production system.

Distributed execution

Agents are scaled across as many machines as are necessary to both handle the simulation load, and give access to the system under test. The simulator coordinates time, playing through the activity streams for all the agents.

Result Capture

Every step of the simulation process, including modeling, activity stream generation, execution, and the code itself, is captured and stored in a database for further analysis. You will typically also capture whatever logs and metrics your system produces.

Validation

Since all phases of a simulation are kept in a database, validation can be performed at any time. This differs markedly from many approaches to testing, which require in-the-moment validation against the live system.

Separation of concerns

The separation of concerns above, and the use of a versioned, time-aware database, gives simulation great power. Imagine that you get a bug report from the field, and you realize that the bug corresponds to a corner case that you failed to consider. With a simulation-based approach, you can write a new validation for the corner case, and run that validation against your past simulation results, without ever running your actual system.

This talk will introduce simulation testing, walking through a complete example using Simulant, an open-source simulation library.

Traditional automated testing approches combine input generation, execution, output capture, and validation inside the bodies of single functions. Generative testing approaches gain expressive power by isolating these steps.

With generative testing:

a generator is a declarative description of possible inputs to a function
execution is up to your program
outputs are data, and can be captured for future study
validators are programs that have access to the generators, the program, and the outputs

There are a number of benefits to this approach:

once test data generation is separate, it is immediately obvious that such data generation should be statistical, not merely a few hand-picked cases
validators can be reused in a variety of
it becomes easier to identify and develop declarative, logic-based validations, rather than imperative ones
the various phases can be decoupled and run at different times

This talk introduces test data generation and generative testing, using for its examples the data.generators and test.generative libraries developed by the author.

Resources

Statistics is hot lately, due in part to the easy availability of large data sets and the successes of people like Nate Silver. These aren't your father's statistics, however. A quiet revolution has swept through the field, shifting it from traditional frequentist methods toward a more Bayesian approach. This talk will discuss Bayes' Theorem and show you how to do simple, back-of-the-envelope calculations to apply it to a wide variety of problems.

In addition, we'll also talk about common errors non-experts make when dealing with statistical conclusions, ranging from small sample size issues to the use of arbitrary endpoints to the problem of overfitting and more.

Just like you need to understand execution plans to write efficient SQL, it helps to understand the JVM's execution engine to write efficient Java code.

In this talk, you'll learn how Java's Just-in-Time (JIT) compiler dissects your code, and by doing so you'll learn how to write efficient code more efficiently, but also gain a better understanding of concurrency challenges as well.

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.

AngularJS is a JavaScript-based Web framework from Google that focuses
on building single-page Web applications. It adds features to HTML
that make it more suitable for building these applications. Examples
include directives (new elements and attributes) and binding expressions
that provide two-way data binding with model data represented as plain
JavaScript objects.

AngularJS accelerates Web application development, requiring far less
JavaScript code than equivalent applications built using other
client-side frameworks. A large amount of code in many dynamic
Web applications is focused on performing DOM manipulations.
Libraries like jQuery make DOM manipulation easy.
AngularJS makes writing DOM manipulation code mostly unncecessary.

Attendees will receive a solid introduction to the features of AngularJS and the benefits of using it.

Topics discussed will include:

modules
templates
provided directives
form validation
controllers
scopes
filters
digest cycle
watches
dependency injection
routes
Batarang Chrome extension
Karma for unit testing
Protractor for end-to-end testing

In modern applications, Javascript is increasingly prevalent both on the client-side and to some degree on the server-side. As we continue to crank out more Javascript code, we're finding that many of the same hard-lessons we learned in writing decoupled Java code are equally desirable in Javascript code. Without the benefit of dependency injection and AOP, both Java and Javascript code can quickly become an unnavigable and untestable mess.

Where frameworks like Spring have helped us gain control over our Java code, Cujo.js similarly aims to give our Javascript code more structure and testability.

In this session, we'll look at Cujo.js, an “unframework” that provides dependency injection that takes Javascript's unique needs into consideration to create loosely-coupled code. We'll also see how, although Cujo.js isn't strictly a UI framework, elements of Cujo.js can be brought together to elegantly build client-side UIs.

You understand the Web. Why do you do REST so wrong?

Doing REST “right” isn't a matter of conformance or purity. It isn't about pleasing hard-to-please Restafarian personalities. It's about understanding that WYBIWYG (What you Build is What You Get). Decisions have consequences. You are free to design and implement whatever you like, but you need to understand the consequences of your choices.

REST, as defined by Roy Fielding's thesis, is a collection of architectural constraints designed to yield certain properties in deployed systems. When you take shortcuts, you simply will not receive all the benefits of loose-coupling, evolvable, flexible, scalable systems. URLs are not enough. HTTP is not enough. To fully embrace the world of REST, you must understand Hypermedia. The good news is that you already do, you've apparently just forgotten.

Here's the thing though. REST is not an endpoint, it is just a beginning. Come to this talk to hear how the story starts. We will take a deep dive into why the Web works, the implications for building Hypermedia-driven REST APIs and start to look at what this means in practice.

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.

Webs of documents are fabulous enough. Webs of data will blow your mind.

A table is a fixed structure. A tree is as well. A graph can go on forever and be extended at any time by anyone.

The Web is an unbounded graph. It is our definition of scale. What happens when we start to use it as the basis of sharing information, not just documents. This does not necessarily mean the public Web (although it is certainly appropriate for that as well). It simply means thinking of information as a web of linked entities through discoverable relationships.

Linked data is a way of doing this, but it is also an established project connecting billions of entities from disparate, unrelated sources. How does that even work? What can you do with such a thing? And what does that mean for your organization?

By building on the ideas introduced in the Data Integration talk, we will explore how webs of data built on standards can change everything.

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.

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

So your server is having issues? memory? Connections? Limited response? Is the first solution to bounce the server? Perhaps change some VM flags or add some logging? In todays Java 6 world, with its superior runtime monitoring and management capabilities the reasons to the bounce the server have been greatly reduced.

This session will look at the Java monitoring and management capabilities, which includes the ability to make VM argument changes on the fly. This session will dive into the different memory compartments and how they are used by the JVM. Final this session will explore the different GC options and how they affect response times and throughput.

Introduction to Go

Introduction to Go… language of the cloud

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.

Jamie Zawinski once said “Some people, when confronted with a problem, think “I know, I'll use regular expressions.” Now they have two problems.“. Many consider regular expressions to be indecipherable, but the truth is that every programmer should consider regular expressions an integral part of their toolkit. From the command line to your favorite text editor, from parsing user input to scraping HTML pages - once you know regular expressions you will find a use for them in almost every programming context.

In this session we will attempt to unriddle the mystery that regular expressions pose. We will start at the basics and work our way towards more complex expressions.

Gradle has fast become one of the de-facto build tool in the Java ecosystem. Gradle offers a powerful DSL to configure your builds. Whether you have a simple build, or a complex build with many moving parts, Gradle's DSL and extensible API can help you make your builds easier, and possible.

In this sessio we will start from the ground up. We will write our first Gradle script and examine Gradle's configuration vs. execution phases. We will see how Gradle uses plugins to add on functionality for free to your build and end with a look at the Gradle Plugin API to see how easy it is to write your own plugins for better reuse.

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.

Groovy isn't designed to replace Java – it just makes Java cleaner and easier to develop. This presentation will look at various tasks Java developers need to do and demonstrate ways Groovy can help.

Topics will include building and testing applications, accessing both relational and NoSQL databases, working with web services, and more.

Git, at it's core, leverages a relatively simple data structure to maintain history. In this session we will take a look at this data-structure, which in turn will give us a better view of how Git manages history, and how better to work with it. NOTE: This is NOT an introduction to Git. This session assumes familiarity with Git concepts such as init, add, commit and merge.

Git has fast emerged as one of the leaders in DVCS. Git may seem arcane, but under the covers, leverages a very simple data-structure to store your version history. As developers, it has always serves us well to know how things fundamentally work, and Git is no different. In this talk we will explore this data-structure, and how the various commands you invoke against Git mutate it.

We make many assumptions when we develop our applications. Many of these assumptions no longer hold true when we start to build applications for the cloud. Cloud platforms also introduce architectural possibilities that do not exist in traditional deployment settings. This session will examine five architectural patterns that we can apply to our applications in order to prepare them for the unique characteristics of cloud environments.

We'll cover the following patterns:

Microservice
API Gateway
Stateless / Shared-Nothing
Configuration / Service Consumption
Fault Tolerance

Examples will focus on the application of these patterns using Java/Spring and Cloud Foundry-based PaaS platforms, but should be applicable to any language/framework/PaaS platform combination.

Robert Martin assembled the SOLID family of principles to provide a useful guide to help us create object-oriented software designs that were resilient in the face of change. In recent years, the need to write highly-concurrent software in order to leverage increasingly ubiquitous multicore architectures, as well as general interest in more effectively controlling complexity in large software designs, has driven a renewed interest in the functional programming paradigm. Given the apparent similarity in their goals, “What is the intersection of SOLID with functional programming?” is a natural question to ask.

In this talk, we'll explore this intersection. We'll begin with a tour of the evolutionary patterns associated with enterprise software and programming paradigms, as well as take a look at the ongoing quest for best practices, the goal being to elucidate the motivation for examining this intersection of SOLID and functional programming. We'll then walk through each of the SOLID principles, examining them in their original object-oriented context, and looking at example problems and solutions using the Java language. Then for each principle, we'll examine its possible intersection with the functional programming paradigm, and explore the same problems and solutions using the Clojure language. We'll close by examining the transcendent qualities of the SOLID principles and how they can make any design simpler, regardless of the programming paradigm employed.

For much of the last two years I've delivered a two-part series at NFJS shows entitled “Effective Java Reloaded.” For all pracical purposes, it is an ala carte style rehash of the book Effective Java, written by Josh Bloch. One of my favorite parts of the discussion is of Item #15, which tells us to “Minimize Mutability.” If we turn this inside out, we're actually saying that we want to MAXIMIZE IMMUTABILITY. When we do this, we reap many benefits, such as code that is easier to reason about and that is inherently thread-safe. This can carry us a long way in the direction of program correctness and decreased complexity. However, when we start to program with immutability, several major questions arise.

First, the necessity of using a separate object for each distinct value, never reusing, or “mutating” an object, can quickly cause performance concerns. These concerns are amplified when we're talking about large collections such as lists and maps. These problems are largely solved by what we call “persistent data structures.” Persistent data structures are collections from which we create new values, not by copying the entire data structure and apply changes, but by creating a new structure which contains our changes but points at the previous structure for those elements which have not changed. This allows us to work with data structures in a very performant way with respect to time and resource consumption. We'll examine persistent data structures, their associated algorithms, and implementations on the JVM such as those found in the TotallyLazy library.

Second, because all of an immutable object's state must be provided at the time of construction, the construction of large objects can become very tedious and error prone. We'll examine how the Builder pattern can be applied to ease the construction of large objects, and we'll examine Builder implementations in Java and Groovy.

Third, we run into problems when we start to use frameworks that expect us to program in a mutable style. A prime example is Hibernate, which expects our persistent classes to follow the well-worn JavaBean convention, including a no argument constructor and getters and setters for each property. Such a class can never be mutable! So how do we program with frameworks such as Hibernate and yet still minimize mutability? The key is found in not letting frameworks dictate the way that you design your code. Just because the framework require something, don't let it force you to make the wrong decision. Use the framework as a tool to write your code, don't let your code be a tool of the framework. We'll examine strategies for doing exactly that.

You should come away from this talk better equipped to program in a way that minimizes mutability and maximizes immutability.

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

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.

There is nothing better than looking at real-world examples to understand project failures and project successes. This session is intended to be an open conversation, based closely to a birds of a feature (BOF) session, however it will have a series of “that happened to me” topics throughout discussed from the perspective of technology.

Discussed will be a clients dating back from 2005. The actually client and there name will not be revealed, but the industry, the contraints and some of the outcomes will.

Java 8 is finally released. We haven't seen this number of changes to Java the language since Java 5. This session will provide a review of the changes to Java 8 with a focus on the language changes such as the addition of lambdas which will either have you excited for a language feature which allows you to express what you want vs. how you want it or will have you concerned about readability in your code base.

This session will introduce the changes of Java 8 including language changes such as:

type inferencing
type Optional
lambdas
streams
new collections
filters
maps
laziness
parallelism
working with resources

and will provide details of the JVM changes such as:

PermSpace
MetaSpace

Gateway Software Symposium

April 11 - 12, 2014

Statistical modeling

Activity streams

Distributed execution

Result Capture

Validation

Separation of concerns

Resources

Statistical modeling

Activity streams

Distributed execution

Result Capture

Validation

Separation of concerns

Resources

TEST