Building 3rd party integrations require deep understanding of the business problems. You would not want to reinvent the wheel to solve common issues. In this talk we will explore different case studies with patterns which helps solves real world issues. We will start with exploring SOA patterns like Service host, Active service, Transactional service, Workflodize, Edge component. After that we will look at patterns related to performance, scalability and availability like Decoupled invocation, parallel pipelines, Gridable service, Service instance, Virtual Endpoint, and Service watchdog.
Lastly we will dive into security and manageability patterns like Secured message, Secured Infrastructure, Service firewall, Identify provider, and Service Monitor. Message exchange patterns include Request/Reply, Request/Reaction, Inversion of Communications and Saga. In Service consumer pattern we will explore Reservation, Composite front end and client/Server/Service. In Service integration patterns we will explore Service bus, Orchestration, Aggregated reporting. Lastly we will examine Service anti-patterns like Knot, Nanoservice, Transactional integration.

Data integrity, security, recovery, privacy and regulatory compliance are essential attributes for enterprise implementation. Enterprise customers ask for transparency in how the vendors will provide security programs. Many questions need to be asked for any cloud implementation to policy makers, architects, coders, and testers.
In this presentation, we will explore data security and storage, privacy, and data compliance issues. We will explore the security management in the cloud. The presentation is useful for anyone starting from Executives to developers who are going to implement the Enterprise Applications in both private and public cloud.

Ever wonder how to step back and analyze the architecture from a different point of views? In this talk, we will explore architectural principles, concerns, and communication. We will discover a core set of architectural principles, which can be used for evaluating the decisions throughout the project life cycle. Then we will examine concerns for the projects by exploring Availability, Scalability, Extensibility, Repeatability, Compatibility, Sustainability, Security and Third party integrations.

Ever wonder how to step back and analyze the architecture from a different point of views? In this talk, we will explore architectural principles, concerns, and communication. We will discover a core set of architectural principles, which can be used for evaluating the decisions throughout the project life cycle. Then we will examine concerns for the projects by exploring Availability, Scalability, Extensibility, Repeatability, Compatibility, Sustainability, Security and Third party integrations. Lastly, we will explore how the architecture comes to life by understanding the principles and concerns and performing effective communication. We will explore different communication methods like Domain model, process diagram, the context diagram, UI mocks, and Logical Architecture Diagram. We will explore RAID modeling to define Risks, Assumptions, Issues, and Dependencies.
We will explore
1) Project Skills: Partnership, Discovery, Conceptualization, Estimation, Management
2) Technology Skills: Platform Development, Architectural Perspectives, Governance, Know-how
3) Visionary Skills: Technology Innovation, Strategic Road mapping, Entrepreneurial Execution

In this talk, we will explore different cloud computing architecture design patterns blueprints and how you can take advantage of them. We will study cloud patterns for Private and Hybrid cloud deployments, Cloud Services, Common cloud management platforms, Security, Cloud governance, resiliency, Performance, and consumability.

In this talk, we will explore different cloud computing architecture design patterns blueprints and how you can take advantage of them. We will explore cloud patterns for Private and Hybrid cloud deployments, Cloud Services, Common cloud management platforms, Security, Cloud governance, resiliency, Performance, and consumability.
Few patterns we will explore are as follows:
Sharing, Scaling and Elasticity Patterns
Reliability, Resiliency and Recovery Patterns
Data Management and Storage Device Patterns
Cloud Service and Storage Security Patterns
Network Security, Identity & Access Management and Trust Assurance Patterns

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!

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.

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

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.

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!

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

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.

Jasmine is a browser centric testing framework. It's the default test framework in Jasmine and is the most popular framework among JavaScript developers. It takes a BDD testing approach.
Mocha is a popular testing framework for JavaScript - for any JavaScript environment, including the Web Browser, NodeJS, and Titanium. It allows for simple asynchronous testing, test coverage, and integration to CI tools. In this session, learn all you need to know about getting started for writing beautiful tests in JavaScript for these environments. We’ll discuss a number of add-ons for Mocha to make testing a breeze. We’ll talk about “should” and “chai” for expectation matching. We’ll discuss “simon” for mocking in your test cases. We’ll also talk about test automation with Grunt.

This session is a code-driven class that covers the Jasmine and Mocha JavaScript testing library. It is an introductory level session.

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.

Unlock your latent photographic memory. In this session you'll learn failsafe techniques and systems that allow you to never forget names, appointments, or numbers. In the process you'll be more effective and imaginative at work; improve reading speed and comprehension, and shorten study times.

An improved memory will change your life, literally. In the session we will describe in detail several memory techniques that, with a little practice, will have you remembering virtually anything you want.

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

Agenda:

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

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

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

Agenda:

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

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

Agenda:

Architecture decisions
Architecture refactoring techniques
Communicating your architecture

Being a software architect is a tough job. Not only do you have to have significant technical depth and breadth, but you also need to understand the business domain you are working in. While these aspects are important, there is another perhaps more vital aspect of being an architect - the soft skills. Too many architects fail to realize the importance of soft skills, and as a result do not achieve success in their career as an architect. In this two-part session I will focus on the soft skills of architecture. In part two I will cover the people skills side of architecture, including working in architecture teams, making implementation teams effective, negotiation techniques, and leadership skills.

Agenda:

Working in architecture teams
Making implementation teams effective
Negotiation skills
Leadership skills

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.

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.

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

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.

You don't need massive frameworks to build mobile apps responsive to touch events, that contain fluid animations, or that are easily deployed to app stores. All you really need is a solid grasp of the JavaScript, CSS3, and HTML5 features and APIs that enable a compelling experience.

In this session, I will show some examples of mobile apps built with HTML5 that offer instantaneous handling of touch events such as pan gestures. I'll demonstrate best practices using CSS3 transitions to implement card and panel design patterns typical of mobile user interfaces. And I'll show just how easy it is to extend the device features available to HTML5 using Cordova, packaging a mobile app for app store deployment.

Web Components change the way you build web applications and think about front-end architecture. Finally, web developers have a sane way to scope and modularize not just their JavaScript, but also the HTML5 and styling. The approach is elegant, encourages compatibility between frameworks, and piggybacks on the web browser's success as an open and extensible runtime. The Polymer framework demonstrates how frameworks can and should evolve in a Web Components world.

In this session, I'll provide an overview of Polymer, and demonstrate the creation of Web Components using the framework. Data binding, true encapsulation of code and style, and dynamic HTML imports are all ready for your use. You will leave with a solid understanding of Polymer basics, and real-world examples of Polymer being used in production today. You will be able to guide your current development to better align with upcoming web standards, and to understand how they will change the way we build and deploy web applications. I'll also show you examples of a large personal project using Web Components to build an entire iOS application.

If the web browser is growing up, then Web Components are the browser leaving home. Finally.

Workshop Requirements

For this workshop, you should bring a laptop with some IDE installed – Brackets (from brackets.io) works well. We'll do the rest in the session, including installing Polymer itself.

JavaScript frameworks are great, but you don't need to rely on them to create maintainable, high performance applications. In fact, the more code you can create independent of a framework, the more reuse you'll get from it, regardless of the frameworks being used. Understanding these patterns (and antipatterns!) will help you write maintainable, high performance code for both client and server, regardless of which libraries and frameworks you use.

You will leave this workshop armed with a toolbox for building and profiling JavaScript to run anywhere. We will examine:

Basic JavaScript patterns.
Efficient (and non-efficient!) iteration patterns.
Closures, anonymous functions, immediately-invoked expressions, and scoping.
Objects, prototypes, modules, and mixins.
Pubsub patterns.
The right ways to write and wrangle asynchronous code, including promises and async libraries.

JavaScript frameworks are great, but you don't need to rely on them to create maintainable, high performance applications. In fact, the more code you can create independent of a framework, the more reuse you'll get from it, regardless of the frameworks being used. Understanding these patterns (and antipatterns!) will help you write maintainable, high performance code for both client and server, regardless of which libraries and frameworks you use.

You will leave this workshop armed with a toolbox for building and profiling JavaScript to run anywhere. We will examine:

Basic JavaScript patterns.
Efficient (and non-efficient!) iteration patterns.
Closures, anonymous functions, immediately-invoked expressions, and scoping.
Objects, prototypes, modules, and mixins.
Pubsub patterns.
The right ways to write and wrangle asynchronous code, including promises and async libraries.

Despite our best efforts with Agile best practices – CI, unit testing, design reviews, code reviews – every few years we end up rewriting our software.

This talk is about my personal experiences with project failure, improvement failure, patterns across the industry, and the key lessons that were critical to success. I had a great team. We were disciplined with best practices and spent tons of time working on improvements. Yet still, I watched my team slam into a brick wall. We brought down production three times in a row, then couldn't ship again for another year.

We thought our problems were caused by technical debt building up in the code base, but we were wrong. We failed to improve, because we didn't solve the right problems. Eventually, we turned our project around, but with a lot of tough lessons along the way.

When I started consulting, I saw the same patterns across the industry:

Our problems are invisible. They're hard to measure, hard to explain. We rely primary on gut feel to make improvement decisions, and it's really easy to make improvements that don't make much difference.

The relentless business pressure never lets up, and developers don't have control. Without visibility, management makes ill-informed decisions, train-wrecks our projects, and drives the development team to exhaustion.

I turned the lessons I learned into the Idea Flow Learning Framework, a data-driven feedback loop for guiding improvements. By quantifying the impact of disruptions, test maintenance, confusing code, and collaboration problems, we can find our biggest problems, understand the causes, and align our development priorities with leadership.

Using the Microservices Architectural Style to incrementally adopt an Event-driven Architecture (EDA) lowers up-front costs while decreasing time-to-market. EDA extracts value from existing occurrences, limiting invasive refactoring or disrupting existing application development efforts. Implementing Event-driven Microservices yields intelligence, scalable, extensible, reactive endpoints.

This session will cover the fundamentals, patterns, techniques and pitfalls of Event-driven Microservices with several demos leveraging Spring-Boot, Camel, ActiveMQ and Docker.

This two-session workshop will cover everything from messaging basics to advanced messaging techniques leveraging Enterprise Integration Patterns. In addition, the workshop will include hands-on exercises using Apache ActiveMQ and Camel.

Agenda

Environment Setup

ActiveMQ Installation
JMeter Test Harness
Asynchronous Hello World!

Messaging Foundation

Conceptual Model
Domains (P2P & Pub-Sub)
Protocals (JMS & AMQP)
Broker Configuration
Exercises

Network Topologies

Persistance
Security
High Availability
Disaster Recovery

Advanced Messaging

Enterprise Integration Patterns
Camel Configuration
Development
Exercises

Workshop Requirements

Laptop
JDK 1.8+
Maven 3.3+
Developer Text Editor (e.g. Sublime) or IDE (e.g. IntelliJ)

Download Prior to Workshop:

ActiveMQ – Version 5.13.2+
hawtio – Version:1.4.54+

What if you could get upper management to care about your technical problems? Would you be willing to measure and prioritize the problems?

What if WE could stop the relentless business pressure that drives our software projects into the ground across the industry? I know this probably sounds impossible, but before you dismiss the idea entirely, let me show you that it is possible.

We can start a cascade of changes across the industry with only a handful of people that are willing to work together to make it happen.

90% of our software is built from existing parts. Bad software has become like environment pollution. With increasing demand for software, an irrelevant education system, and tons of developers building crappy software, we've got a dumping ground of shared software full of security risks and unexpected costs, and no way to tell what's what.

Open Mastery is a peer learning network focused on codifying open decision models and standards to solve industry-wide problems. This presentation is about the obstacles, the strategy, and the business model.

I need your help. Let's identify where the strategy might break, and figure out how to make it work. I'm launching Open Mastery in early 2016. Let's make this dream a reality.

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

In this session, we're going to combine the magic of Spring Boot and the magic of Spring Data to yield something even more powerful. You'll see how to quickly build an application's persistence layer, whether it stores data in a RDBMS, Mongo, Neo4j, or several other popular data stores. You'll also see how to create a functioning REST API with nothing more than an interface and a domain type.

Spring Boot dramatically simplifies application development with Spring. But before Spring Boot came along, Spring Data was already making developers' lives easy when it comes to working with data. When combined, Spring Data and Spring Boot can make data persistence the easiest part of your application.

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

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.

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

Topics will include:

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

This two-session workshop will cover everything from messaging basics to advanced messaging techniques leveraging Enterprise Integration Patterns. In addition, the workshop will include hands-on exercises using Apache ActiveMQ and Camel.

Agenda

Environment Setup

ActiveMQ Installation
JMeter Test Harness
Asynchronous Hello World!

Messaging Foundation

Conceptual Model
Domains (P2P & Pub-Sub)
Protocals (JMS & AMQP)
Broker Configuration
Exercises

Network Topologies

Persistance
Security
High Availability
Disaster Recovery

Advanced Messaging

Enterprise Integration Patterns
Camel Configuration
Development
Exercises

Workshop Requirements

Laptop
JDK 1.8+
Maven 3.3+
Developer Text Editor (e.g. Sublime) or IDE (e.g. IntelliJ)

Download Prior to Workshop:

ActiveMQ – Version 5.13.2+
hawtio – Version:1.4.54+

In this session you will learn to strategically introduce technology innovations by applying specific change patterns to groups of individuals. Using these patterns and related techniques will not only benefit your organization but will ultimately benefit your career as a technologist by making you a better influencer, writer, and speaker.

The rapid pace of technological innovation has enabled many organizations to dramatically increase productivity while at the same time decrease their overall headcount. However, the vacillating global economy combined with “change fatigue” within organizations has resulted in a risk averse culture. In such an environment how can one possibly introduce and inculcate the latest technology or process within an organization? The answer is to have a solid understanding of Diffusion Theory and to leverage Patterns of Change.

Prezi Location: http://prezi.com/b85wwmw7hccn

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.

What does it mean to be Agile? What are the basic principles of Agile Software development and how do I build my Agile Team. What do I really need to build a good agile team? What skills sets are required? Do Project Managers make good Scrum Masters? I have been “doing agile” for a while now and it doesn't seem to work? Does anyone ever really do “true agile”? This presentation is an Introduction to agility and is intended for people who are unfamiliar with Agile/Lean principles and want to learn more.

These are questions that I am asked on a regular basis. Even by people with “agile experience”.
In this presentation we will cover the BASICS of Agile software development and how to build your Agile team. This talk is NOT intended for those experienced in the agile space.

QA. We all know we need it, but quality takes time. How do we squeeze it into two-week sprints? Is a story really done if we haven’t finished QA? Do your Dev teams throw “code over the wall” to be tested in the next sprint? Or are your testers expected to test all your code in the last three Days of your Sprint? These are anti-patterns we see all the time in the Large Enterprise. In this presentation we will discuss how QA is handled - and mishandled when an Enterprises “adopt” Scrum. We will conclude with the best approaches to delivering potentially shippable code, in a quickly changing business world. This presentation will assume a basic understanding of agile principles.

In this presentation we will discuss how QA is handled - and mishandled. We will conclude with the best approaches to delivering production ready code in a lean, agile world. This presentation will assume a basic understanding of agile principles. This talk is not technical in nature. It is intended for those struggling with the transition from traditional QA enterprise teams - silos, testers report to a separate management structure - to QA in an Agile environment. We will discuss QA anti-patterns and how agile addresses them.

There is a fifth dimension beyond that which is known to us. It is a dimension as vast as space and as timeless as infinity. It is the middle ground of non-commitment between light and shadow, between science and superstition, agile and waterfall, and it lies between the pit of your fear of Big Up Front Design and your Project Manager’s desperate need for “dates” and “estimates”. This is the methodology of stagnation. It is an area which we call “The Scrummerfall Zone”… NOTE: This presentation is for those who have a solid understanding of agile principles, but are struggling with the transition to agile. There will be a lot of discussion during and after the presentation. Be prepared to talk.

Have you been sucked into a twilight zone like development process in which agile terms are slapped on to waterfall practices while management triumphantly declares your efforts “Agile”? In this presentation we will discuss some of the things that happen when waterfall meets agile in the large enterprise and the confusion and chaos that ensues. We’ll end with a discussion on productive ways to challenge the acceptance of scrummerfall and help bring your organization back from “The Scrummerfall Zone”.
Notice the emphasis on discussion. This will be an interactive session with approximately 60 minutes of presentation and 30 minutes reserved for discussion and questions. Be prepared to participate and ask question.

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

Organizations have moved from making their employees available to having their applications available directly to the users. This changes the magnitude of scale
of interactions the applications have to support. Furthermore, with devices and bots accessing the systems, we’re looking at a complete different rate of response than we once had to aim for.

In this presentation we will discuss the fundamentals of reactive systems, the key design goals, and the technologies that facilitate building such systems.

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.

No matter the techniques used to make enterprise solutions Highly Available (HA), failure is inevitable at some point. Resiliency refers to how quickly a system reacts to and recovers from such failures. This presentation discusses various architectural resiliency techniques and patterns that help increase Mean Time to Failure (MTTF), also known as Fault Tolerance, and decrease Mean Time to Recovery (MTTR).

Failure of Highly Available (HA) enterprise solutions is inevitable. However, in today's highly interconnected global economy, uptime is crucial. The impact of downtime is amplified when considering Service Level Agreement (SLA) penalties and lost revenue. Even more damaging is the harm to an organization's reputation as frustrated customers express their grievances on social media. Resiliency, often overlooked in favor of availability, is essential. Prezi Presentation

User Stories. We have all heard of them, but do we truly understand them? Aren’t they just use cases repackaged and marketed as “agile”? Are they just a euphemism for “requirements”?

In this presentation, we will take a deep dive into User Stories: their purpose and how to develop them. We will take a look at user stories together and dig into the really tough topics such as how to handle non-functional requirements in an agile world. Next we will discuss sizing and story point estimation and then estimate the stories we have created while discussing estimating software in general and estimation in agile in particular. Finally we will develop Acceptance Criteria and discuss what the definition of done really means to you, your team, and your product owner. You will leave with the tools you need to help your team understand and develop real user stories and establish a stable velocity.

Instant messaging, video conferencing, online audio calls and file sharing have become a crucial part of every day life. Until recently, this required the use of a centralized service. Now, with the WebRTC Standard from the W3C, we have the ability to communicate through our browsers without relying on third parties or plugins.

This talk will introduce you to the WebRTC standards from the World Wide Web Consortium (W3C). This includes:

establishing connections and sessions between peers
making video calls
making audio calls
instant messaging
file-sharing
security and privacy issues

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

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

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

Topics include:

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

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

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

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

Topics include:

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

Lattice is a cloud-native application platform that enables you to run your applications in containers like Docker, on your local machine via Vagrant. Lattice includes features like:

Cluster scheduling
HTTP load balancing
Log aggregation
Health management

Lattice does this by packaging a subset of the components found in the Cloud Foundry elastic runtime. The result is an open, single-tenant environment suitable for rapid application development, similar to Kubernetes and Mesos. Applications developed using Lattice should migrate unchanged to full Cloud Foundry deployments.

Lattice can be used by JVM developers to spin up powerful micro-cloud environments on their desktops, and can be useful for developing and testing cloud-native application architectures. This session will introduce the basics:

Installing Lattice
Lattice’s Architecture
How Lattice Differs from Cloud Foundry
How to Package and Run Your JVM Apps on Lattice

What does “better” really mean? If we eliminate duplication, is the code better? If we decide to skip the unit tests, are we doing worse? How do we decide if one design is better than another design?

In this talk, I'll introduce the Idea Flow Learning Framework, a data-driven feedback loop for improving your software development skills. By measuring the “friction” that occurs when developers interact with the code, we can identify the biggest causes of friction and systematically optimize developer experience.

With an unambiguous definition of “better” and objective feedback to learn what works, we can learn our way to better despite the vast world of gray.

About 8 years ago, my project failed, despite “doing all the right things”, and shattered my faith in best practices. Since then, I've learned to measure developer experience as an objective measure of improvement, and I've been codifying the art of “better” into patterns and decision principles for years.

Why go to all this trouble? From my experience, the biggest causes of pain are seldom what we think. When we try to make things “better”, we can easily miss our biggest problems, or inadvertently make things worse. Visibility turned my beliefs about “better” upside-down.

In this talk, we'll cover the three stages of mastery at the core of the learning framework:

Visibility - Learn to see the pain
Clarity - Understand the causes of pain
Awareness - Learn to avoid the pain

By making the pain visible and iteratively learning what works, we can master the art of software development.

New York Software Symposium

October 29 - 30, 2015

Workshop Requirements

Workshop Requirements

Workshop Requirements

Workshop Requirements

Workshop Requirements

Workshop Requirements

TEST