•  

NFJS Twin Cities Software Symposium  schedule

Friday 4th March 2016

  • Continuous Delivery Workshop, part 1 of 3: Deployment Pipelines

    by Neal Ford

    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.

    At 1:15pm to 2:45pm, Friday 4th March

  • Introduction to Java 8

    by Ken Sipe

    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

    At 1:15pm to 2:45pm, Friday 4th March

  • Refactoring the Monolith: LIVE!

    by Matt Stine

    Many of us would love to embrace microservices in our day-to-day work. But most of us don’t have the opportunity to start over with a pure greenfield effort. We have to understand how to refactor our existing monolithic applications toward microservices. Practical steps include building new features as microservices, leveraging anti-corruption layers, strangling the monolith.

    In this presentation we’ll go light on the theory and walk through the actual process of turning a strawman monolith into a family of well-factored microservices.

    At 1:15pm to 2:45pm, Friday 4th March

  • Service-Based Architecture: Microservices Hybrids

    by Mark Richards

    Microservices is an architecture style that is quickly gaining popularity in the industry. However, it is hard to apply this architecture style to traditional large-scale monolithic applications. In this session we will look at ways of creating hybrid service-based architectures that can be easily adopted to fit traditional large-scale business applications while still providing many of the benefits a microservices architecture provides. Between Service-oriented architecture (SOA) and microservices there is indeed a middle ground - and that middle ground is called service-based architecture.

    Agenda:

    Microservices architecture overview
    Service-oriented architecture overview
    Service-based architecture
    Comparing architectures

    At 1:15pm to 2:45pm, Friday 4th March

  • Web Apps with AngularJS - Part I

    by Raju Gandhi

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

    Add to Itinerary
    Slides
    Video
    Eval

    At 1:15pm to 2:45pm, Friday 4th March

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

    by Neal Ford

    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.

    At 3:15pm to 4:45pm, Friday 4th March

  • Java 8/9 Memory and Garbage Collectors

    by Ken Sipe

    A look into Java memory including Metaspace and garbage collectors including G1.

    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 including details on Metaspace and how they are used by the JVM. Finally this session will explore the different GC options and how they affect response times and throughput.

    At 3:15pm to 4:45pm, Friday 4th March

  • Microservice AntiPatterns and Pitfalls Part 1

    by Mark Richards

    Even though teams are gaining more experience in designing and developing microservices, nevertheless there is still a lot to learn about this highly distributed and somewhat complicated architecture style. Unfortunately, lots of microservices anti-patterns and pitfalls emerge during this learning curve. Learning about these anti-patterns and pitfalls early on can help you avoid costly mistakes during your development process. While anti-patterns are things that seem like a good idea at the time and turn out bad (see martinfowler.com/bliki/AntiPattern.html), pitfalls are those practices that are never a good idea at the time - ever. In part 1 of this 2-part session I will cover some of the more common pitfalls you might encounter while creating microservices, and describe some of the ways of avoiding these pitfalls.

    Agenda
    Part 1 will focus on the following Microservices Pitfalls:

    Grains of Sand Pitfall
    Developer Without a Cause Pitfall
    Jump on the Bandwagon Pitfall
    Logging Can Wait Pitfall
    Using Too Much Acid Pitfall
    Static Contract Pitfall
    Service Orphan Pitfall
    Are We There Yet Pitfall
    Dare to be Different Pitfall

    At 3:15pm to 4:45pm, Friday 4th March

  • Reactive Fault Tolerant Programing with Hystrix and RxJava

    by Matt Stine

    As we build distributed systems composed of microservices, we introduce new potential performance problems and failure points. As the number of nodes in our system increases, these problems rapidly amplify. In order to keep our composite systems responsive, we can apply the techniques of reactive programming. In order to keep our composite systems healthy, we can apply fault tolerance patterns like circuit breakers and bulkheads.

    In this presentation we’ll examine how to leverage two popular libraries from Netflix, Hystrix and RxJava, to create reactive and fault tolerant systems.

    At 3:15pm to 4:45pm, Friday 4th March

  • Web Apps with AngularJS - Part II

    by Raju Gandhi

    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.

    At 3:15pm to 4:45pm, Friday 4th March

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

    by Neal Ford

    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.

    At 5:00pm to 6:30pm, Friday 4th March

  • JavaScript Patterns Revisited

    by Raju Gandhi

    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.

    At 5:00pm to 6:30pm, Friday 4th March

  • Microservices AntiPatterns And Pitfalls Part 2

    by Mark Richards

    Even though teams are gaining more experience in designing and developing microservices, nevertheless there is still a lot to learn about this highly distributed and somewhat complicated architecture style. Unfortunately, lots of microservices anti-patterns and pitfalls emerge during this learning curve. Learning about these anti-patterns and pitfalls early on can help you avoid costly mistakes during your development process. While anti-patterns are things that seem like a good idea at the time and turn out bad (see martinfowler.com/bliki/AntiPattern.html), pitfalls are those practices that are never a good idea at the time - ever. In part 2 of this 2-part session I will cover some of the more common anti-patterns you might encounter while creating microservices, and describe some of the ways of avoiding these anti-patterns.

    Agenda
    Part 2 will focus on the following Microservices anti-patterns:

    All The World's a Stage AntiPattern
    Hop on the Bus AntiPattern
    The Timeout AntiPattern
    Reach-In Reporting AntiPattern
    I Was Taught to Share AntiPattern
    Data-Driven Migration AntiPattern
    Give it a Rest AntiPattern

    At 5:00pm to 6:30pm, Friday 4th March

  • Scaling up on the web

    by Ken Sipe

    The drive to continuous delivery, micro services and PaaS includes the need to auto scale and potentially auto provision services. This session will identify the legacy thinking of a statically partitioned world and drive to the scalable world of Apache Mesos.

    This session will look at the failings of the many of today's cloud technology, identify the goals we have and look into the tooling of how to get there. In this session we will look at:

    static vs elastic partitioning
    vm vs containers
    separating cluster capacity from application scale
    load balancing with HAProxy
    This session will be packed with demonstrations.

    At 5:00pm to 6:30pm, Friday 4th March

  • The Pragmatic Programmer Revisited

    by Matt Stine

    While rummaging through some books the other day, I came across my copy of The Pragmatic Programmer. Flipping to the copyright page, I realized that it had been 16 years since its publication. Many of our careers have been deeply affected by reading and considering the many nuggets of wisdom contained in this book, and it is near the top of multiple recommended reading lists.

    In this presentation, we’ll revisit this book, and we’ll also consider what we’ve learned since its publication - what would we change? And what remains timeless?

    At 5:00pm to 6:30pm, Friday 4th March

  • Keynote: The Art of the Impossible

    by Michael Carducci

    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.

    Michael uses illusion, anecdotes and other examples to help identify your mental obstacles. In this talk you will learn how to apply what you've learned to the real world; 6 techniques to bypass your mental obstacles.

    At 7:15pm to 8:00pm, Friday 4th March

Saturday 5th March 2016

  • Architecture Patterns

    by Mark Richards

    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

    At 9:00am to 10:30am, Saturday 5th March

  • Concourse: CI that scales with your project

    by Matt Stine

    Concourse (http://concourse.ci/) is a CI system composed of simple tools and ideas. Concourse can express entire pipelines, integrating with arbitrary resources, or it can be used to execute one-off tasks, either locally or in another CI system. Concourse attempts to reduce the risk of adoption by encouraging practices that keep your project loosely coupled to the details of your continuous integration infrastructure.

    Concourse optimizes around the following principles:

    Simplicity
    Usability
    Build Isolation
    Scalable, reproducible deployments
    Flexibility
    Local iteration
    During this session we'll learn the simple key concepts from which Concourse pipelines are constructed. We'll understand how to deploy a local Concourse cluster using Vagrant as well as a scalable Concourse cluster to your cloud of choice using Cloud Foundry BOSH. Finally, we'll look at basic and advanced examples of pipelines for Java projects.

    At 9:00am to 10:30am, Saturday 5th March

  • Effecting Culture Change

    by Michael Carducci

    While some high profile companies take pride in their developer-friendly cultures and perks, the majority of us still working long hours on death march projects for clueless, pointy-haired bosses. Is there light at the end of the tunnel?

    Great cultures are created, not inherited. Since nobody else is stepping up change things, it's on you to make it happen. In this session we discuss strategies for getting your team on board as well as when/how to approach management within the department and also higher-up in the organization.

    You'll leave this session with goals, strategies and the tools you'll need to win-over decision-makers and putting an end to a high stress work-environment.

    At 9:00am to 10:30am, Saturday 5th March

  • Hypothesis-driven Development

    by Neal Ford

    Hypothesis-driven Development ties together current product thinking about requirements, Continuous Delivery, DevOps, and strategies to rethink how you build software.

    Agile development claims to abhor “Big Design Up Front”…yet what is that giant backlog building session but BDUF in other clothing? Back in the olden days of software development, we were forced to speculate on what users want, then build it. We were basically running a buffet. But what if we could switch to à la carte? With modern engineering practices like Continuous Delivery, we can shift our perspective and start building by hypothesis rather than speculation. This talk shows the full spectrum of software development, from ideation through execution and deployment, through the lens of modern software engineering practices. I discuss building a true MVP, then building a platform using feature toggles, canary releases, A/B testing, and other modern DevOps tools to allow you to run experiments to see what your users really want. By building a platform for experimentation, product development shifts from up-front guessing to market driven. This talk unifies the practices of modern architecture, DevOps, and Continuous Delivery to provide a new approach to feature development.

    At 9:00am to 10:30am, Saturday 5th March

  • What's new in ECMAScript.next I

    by Raju Gandhi

    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.

    At 9:00am to 10:30am, Saturday 5th March

  • Cloud Native Data Integration

    by Craig Walls

    In this session, we'll look at Spring Cloud Data Flow, a cloud native programming and operating model for composable data microservices on a structured platform.

    Microservices are commonly thought of as small REST-based services that are assembled to form a larger, more complete application. In reality, however, REST is only the communication mechanism which is only a implementation detail and not intrinsic to the notion of microservices.

    Meanwhile, data processing and integration between various components of an application and external services is a key factor of many applications. In cloud native applications, this kind of data flow and processing is still relevant. Spring Cloud Data Flow offers a solution for data processing and integration where each step in the flow is, in fact, a microservice…but not necessarily a REST service.

    At 11:00am to 12:30pm, Saturday 5th March

  • Confessions of an Agile Product Manager

    by Matt Stine

    Over the past year I’ve had the pleasure of wearing the hat of “product manager” for the Spring Cloud Services team at Pivotal, operating using a distributed variant of the Pivotal Labs process. Along the way I’ve learned many valuable lessons that I hope you’ll be able to apply to your product development efforts.

    In this presentation we’ll examine the relationship of product management to engineering and to your customer, and how you can be an effective broker between the two groups

    At 11:00am to 12:30pm, Saturday 5th March

  • Living in a Container

    by Ken Sipe

    Containers and Micro-service are like peanut butter and jelly, they just go together. However do you know how resources are managed in a container and how that affects your application. This session will dive into how Java is affected living under control groups.

    This session will review containers, the underlying technology to containers along with different container runtimes such as Docker. We will look at the anatomy of a container including control groups (cgroups) and namespaces. This session will conclude with the challenges of running the JRE in a container and the impact that has on the efficiency of the process at scale.

    At 11:00am to 12:30pm, Saturday 5th March

  • Software Development AntiPatterns

    by Mark Richards

    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

    At 11:00am to 12:30pm, Saturday 5th March

  • What's new in ECMAScript.next II

    by Raju Gandhi

    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.

    At 11:00am to 12:30pm, Saturday 5th March

  • Cloud Native Spring

    by Craig Walls

    In this session, we'll explore Spring Cloud, the extension to Spring which addresses many of the common challenges of developing cloud native applications. We'll focus primarily on Spring Cloud's support for centralized configuration, service discovery, and failover/monitoring.

    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.

    Microservices present new challenges to developers, however. How do you configure your microservices? How are microservices discovered? And how can you avoid a cascading failure when one microservice becomes sluggish, unresponsive, or otherwise unhealthy?

    At 1:30pm to 3:00pm, Saturday 5th March

  • Evolutionary Software Architectures (new for 2016)

    by Neal Ford

    This session defines the characteristics the evolutionary architectures,, along with engineering and DevOps practices necessary for implementation. I include characteristics, principles, migration strategies, and team impact.

    For many years, software architecture was described as the “parts that are hard to change later”. But software architecture is the balancing of capabilities versus constraints. If build changeability one of your prime capabilites, evolutionary change becomes easier. The microservice architectural style is quite popular, but it is only one in a family of evolutionary architectures. This session defines the characteristics this family of architectural styles, along with engineering and DevOps practices necessary for implementation. I cover the principles behind evolutionary architectures, the practices needed for success, how organization and team structure affects these architectures, and specific engineer practices that facilitate evolutionary architectures. I also discuss migration strategies from common existing architectural types towards move evolutionary architectures.

    At 1:30pm to 3:00pm, Saturday 5th March

  • Full Stack JavaScript with HTML5, Node.js and MongoDB

    by Danny Brian

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

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

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

    At 1:30pm to 3:00pm, Saturday 5th March

  • Fully Optimize Your Productivity

    by Michael Carducci

    It's been called “The Zone” “Flow State” or just being focused and motivated. Although it's easy to get out of there are some day's it's impossible to get into.

    This session focuses on techniques and tips to get into the zone, stay in the zone and to protect your productivity, even in disruptive environments.

    At 1:30pm to 3:00pm, Saturday 5th March