Microservices are all the rage. But this isn’t a session on microservices. It’s a session on modularity. At the end of the day, microservices are just one way to the increase modularity of our software system. But there are others.

In this session we’ll refactor a monolith using patterns of modular architecture. In the end, you’ll see how the underlying set of principles used to modularize the monolith are virtually identical to the benefits of a microservice architecture, albeit manifest in a different way. Once modularized, you’ll also be amazed at how much architectural agility we have in our ability to now shift between different approaches to modularity, including microservices.

With Java 9, modularity will be built in to the Java platform…Finally! In this session, we explore the default Jigsaw module system and compare it to the alternative module system, OSGi, on the Java platform.

We will demonstrate the impact that Jigsaw will have on our existing applications and identify what we must do to get ready for Jigsaw. You will also see firsthand how to use the Jigsaw module system and the benefits that support for modularity on the Java platform will have on your applications.

HTML5 hasn't fundamentally changed the way we build web applications — JavaScript frameworks did that. Not so with Web Components! Web Components are the most important update to HTML and the Document Object Model in recent years. They have a major impact on client-side architecture, on framework selection, and on distribution and reuse of code.

In this session, I'll explain to you the four Web Components standards, their current state, and why you should care. I'll give several examples of complex applications built in Web Components, and running in all modern browsers — including a rich mobile game.

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.

An evolutionary architecture supports incremental, guided change along multiple dimensions.

For many years, software architecture was described as the “parts that are hard to change later”. But then microservices showed that if architects build evolvability into the architecture, change becomes easier. This talk, based on my upcoming book, investigates the family of software architectures that support evolutionary change, along with how to build evolvable systems. Understanding how to evolve architecture requires understanding how architectural dimensions interact; I describe how to achieve appropriate coupling between components and services. Incremental change is critical for the mechanics of evolution; I cover how to build engineering and DevOps practices to support continuous change. Uncontrolled evolution leads to undesirable side effects; I cover how fitness functions build protective, testable scaffolding around critical parts to guide the architecture as it evolves.

The software development ecosystem exists in a state of dynamic equilibrium, where any new tool, framework, or technique leads to disruption and the establishment of a new equilibrium. Predictability is impossible when the foundation architects plan against changes constantly in unexpected ways. Instead, prefer evolvability over predictability. This keynote illustrates how to achieve evolutionary architectures and how to retrofit existing systems to support better evolution.

This session compares Service-oriented, Service-based, and Micro-service architectures, describing the problem each is designed to solve, differences and similarities, variants and hybrids, and engineering practices.

Microservice architectures are quite popular, described as “SOA done correctly”. But what are the real differences between SOA, Microservice, and service-based architectures? What about middle ground between the shared everything of SOA versus shared nothing of microservices? This talk explores the similarities and differences between various service-oriented architectural styles. I describe the characteristics of SOA, microservices, and hybrid service-based architectures, along with the considerations and constraints for each. I also discuss specific engineering practices, orchestration styles, reuse strategies, and migrating from monolithic applications to service-based or microservice architectures. No one architecture can solve every problem, and many projects take on more complexity than necessary by choosing the wrong paradigm.

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?

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.

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.

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?

In this session, we'll open the hood on Spring Boot and see how it works. Using this knowledge, we'll look at ways to optimize Spring Boot, override autoconfiguration, and create custom extensions to Spring Boot's Actuator.

Spring Boot does many wonderful things that get you well on your way to developing amazing Spring applications. But how does it tick? How can you customize it? And how can you override it's default autoconfiguration when you want something a little different?

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.

Security is an important aspect of any application. For many years, Spring Security has been the go-to framework for securing Spring-based application. But historically Spring Security has been cumbersome to work with, involving an enormous amount of XML configuration to shape an application's security scheme.

In recent versions of Spring Security, however, XML-based configuration has taken a backseat to a powerful Java-based configuration option. Spring Security's Java-based configuration offers a fluent API for defining the security constraints for an application which is easy to read and eliminates the need for klunky XML configuration. On top of Spring Security's own configuration improvements, Spring Boot autoconfiguration makes it incredibly easy to get started securing your application, minimizing even the amount of Java configuration required.

In this session, we'll take a look at what's involved in securing a Spring application with Spring Security. In doing so, we'll take full advantage of Spring Boot to autoconfigure as much security as we can get away with and then rely solely on Spring Security's Java-based configuration to shape the security aspect of an application. We'll also briefly look at how to use Spring Security when securing microservices.

Understand Java from a functional programming point of view. This part covers the basics of lambdas and streams, emphasizing functional programming by transforming collections using the stream approach.

Also includes method references and static and default methods in interfaces.

Functional features in Java, including parallel streams, the java.util.function package, the Optional data type, and reduction operations.

The talk also covers the new date and time package based on Joda time, as well as collectors and implementing the Collector interface.

Java SE 8 introduces many new features that can simplify your code. Using streams, lambdas, and the new Optional type all change the way we write Java. In this presentation, we'll work through a series of examples that show how to rewrite existing code from Java 7 or earlier using the new Java 8 approach.

Examples will include replacing anonymous inner classes with lambdas, switching from iterating over collections into transforming streams, using immutables wherever possible, lazy evaluation, and more.

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.

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.

Apache Spark is quickly taking over the MapReduce space of Hadoop and with good reason. This session will provide an overview of Spark, how it works and the different packages it brings to the world of data analytics.

This is a technical deep dive into Apache Spark Basics which includes:

• Spark Overview
• RDD
• Spark Essentials
• Overview of SQL, Streaming, Machine Learning and Graphs
• Running in a Production environment such as Apache Mesos / DCOS

By the end of this conference you will have learned many new tools and technologies. The easy part is done, now for the hard part: getting the rest of the teamand managementon board with the new ideas. Easier said than done.

Whether you want to effect culture change in your organization, lead the transition toward a new technology, or are simply asking for better tools; you must first understand that having a “good idea” is just the beginning. How can you dramatically increase your odds of success?

You will learn 12 concrete strategies to build consensus within your team as well as 6 technique to dramatically increase the odds that the other person will say “Yes” to your requests.

As a professional mentalist, Michael has been a student of psychology, human behavior and the principles of influence for nearly two decades. There are universal principles of influence that neccessary to both understand and leverage if you want to be more effective leader of change in your organization.

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 higherup in the organization.

It happens to us all; there are simply days where it seems impossible to get anything done. 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.

Rather than focusing on any one productivity methodology (e.g. GTD) This talk analyzes the internal and external factors that affect our productivity and offers broader strategies to get back on track.

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.

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.

Regular Expressions are an undervalued, underutilized tool in the developer toolbox. Few programming technologies have stood a comparable test of time for their capacity to improve developer productivity, to shortcut complex tasks, to reduce dependency on various libraries, and to encourage code reuse. They also help to teach patterns and improve pattern recognition, not only for code, but for programmers themselves. Competency with regexes will make you a better programmer, regardless of your choice of language or platforms. And it will impress your peers, too!

This workshop will teach you the fundamentals of writing, debugging, and testing PCREs (Perl-compatible Regular Expressions) in multiple programming languages. With hands-on examples we will cover regex syntax, metacharacters, assertions, grouping, quantifiers, greed, capturing, balanced matches, and replacing. We'll compose regexes from scratch to parse some common string formats such as URLs, email addresses, and even JSON. Given enough time, we'll even learn look-around assertions, and examine some creating uses of regexes in the field of natural language processing.

“There's a new JS framework every week! There's a new JavaScript feature every week! There's a new HTML5 feature every week! We are losing our minds OMG@#$HELPUS!”

Settle down everybody. Shiny new frameworks distract you from the stability offered by the web platform: ES6 is the first major update to JavaScript since 2009, and HTML5 was 18 years in the making! More importantly, few of these innovations significantly change the architecture of web applications — we owe browser innovation and frameworks for that. But since the browser evolved in to a full-blown application runtime, we now need solid front-end architecture, and front-end architects. It's not just about JavaScript, it's about the entire browser platform. And you can't pick frameworks to simplify that platform until you understand its underpinnings.

In this workshop, we will dissect the components of a modern web client into three buckets:

1. Networking: How does data get to and from the client? We will discuss the various underlying APIs and libraries for client-server communication.
2. Rendering: How does the user interface get created and painted? We'll look at the HTML5 APIs for manipulating the DOM, and explain how various frameworks including AngularJS, React, and Polymer regard and manipulate the DOM.
3. Distribution & Maintenance: How does the resulting app get distributed and updated, either on the web or to app stores?

I'll lay the foundations to simplify the complex world of front-end tools, frameworks, and architecture. I'll share patterns to help you manage the complexity of front-end development and back-end integration for modern web clients. And I'll convince you to never again complain about how fast the world of front-end technologies is moving.

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.

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

This presentation will cover:

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

Reactive is a the latest buzzword to consume our industry. This presentation distills and defines reactive systems, describe the difference between reactive architecture vs. reactive programming, describe common patterns, and demos the popular reactive JVM technologies like RXJava, and Akka.

Introduction to reactive gets in deep on a discussion of patterns: Source, Sink, Back Pressure, Reactive Pull/Push including a Light introduction to actors using Akka, ReactiveX using RXJava and Reactive Streams in RXJava and Akka. We also will showcase the differences between ReactiveX and Akka.

A set various tools to write reactive, concurrent, fault-tolerant applications and services using immutable data, asynchronous message passing using local and remote actors, software transactional memory, and supervised systems. This entire presentation is done in Java.

Akka is a set of various tools to write reactive, concurrent, fault-tolerant applications and services using immutable data, asynchronous message passing using local and remote actors, software transactional memory, and supervised systems.

Akka is also part of the Typesafe stack, a stack that include the Play web framework, Spray, Slick, and the Scala programming language. This Akka presentation will cover Java style usage of Akka with actors, asynchronous message passing, supervision, and streams

Spock is a groovy based testing framework that leverages all the “best practices” of the last several years taking advantage of many of the development experience of the industry. So combine Junit, BDD, RSpec, Groovy and Vulcans… and you get Spock!

There are 3 tools I use on every Java project I control… this is one of them and with good reason.

This session assumes some understanding of testing and junit and builds on it. We will introduce and dig deep into Spock as a test specification and mocking tool. Topics include:

• Unit testing
• Data driven tests
• Mocking and Stubbing
• Partial Mocks
• Spock Extensions

You've heard the old adage “It's not what you know it's who you know.” The focus of this session is divided between ways to better connect with everyone you meet as well as ways to grow your network, help and influence people and ultimately build long-term relationships and build your reputation.

Networking isn't about selling nor it isn't about “taking.” Done properly it benefits everyone. Among the benefits are strengthening relationships; getting new perspectives and ideas; building a reputation of being knowledgable, reliable and supportive; having access to opportunities and more!

Slides available online: https://prezi.com/ck1fdbhgqwiq/?token=8f8240f753ad9ae2c50ce696657020f40a877a40fa224790652eb412ac5eb8d3

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.

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.

When the opportunity arises for development of a new application, or the modernization of an old one, the architect is faced with a myriad of often conflicting choices. There are so many choices there's a significant risks of falling into analysis paralysis or simply defaulting to safe solutions. (“No one ever got fired for choosing IBM.“) On the other side of risk adversity lies RDD - Resume Driven Design - where all the newest, riskiest technologies are thrown into the mix just so the app development will be hot and sexy.

This session explores some architectural trade-offs and lays out a road map for successfully architecting a new project, with key emphasis on targeting accidental complexity and launching the project on the right course while preserving plenty of alternatives.

Suppose you've just been assigned to be the architect on a new development project. The new CTO has no love for the status quo process the organization has been (not) delivering software. (Not delivering software is exactly why there is a new CTO.)

You've been emailed half a dozen Powerpoints outlining the business needs. It's clear the business stakeholders care about two things: Time-to-market and functional effectiveness. Otherwise, they don't care about any of the technical gobbledygook the developers usually use when discussing projects. The developers love all the new languages and technologies and will hate implementing some boring CRUD app for the 99th time.

After years of yearning for a greenfield project, now's your chance to shine - or fall on your keister. Where to start? In this session, we'll develop an architectural road map for successfully bootstrapping your new project without getting yourself boxed into a bad place.

In this session we'll explore implementation of some Enterprise Integration Patterns using Apache Camel with Java, Groovy and Spring.

Camel makes defining Message routes easy and supports configuring dozens of endpoint types, including internal direct web service endpoints, Amazon Web Services (AWS) endpoints, file and FTP end points, JMS endpoints and many more, It also makes mocking and testing endpoints easy to reduce test fragility.

We'll start with a brief introduction to Enterprise Integration Patterns and messaging, then build up increasingly complex routes to a variety of endpoints.

We'll then explore methods for working with messages during the routing. We'll combine multiple messages, split messages into multiple parts, and transform messages from one form to another.

We'll also explore Camel's facilities for testing of routes and processors.

Just a few years ago, it looked like Java's best days were behind it. All the developer “trend setters” seemed to migrating to Ruby, Groovy, Scala, Clojure and even JavaScript. Many Java developers wondered if it was time for them to defect from the Java camp. Then came Java 8. It's truly a game changer.

Java 8 introduced many enhancements including new command line tools, security enhancements, JavaFX changes, and more. It also introduce a new Date-Time API for making working with dates less tedious and error-prone. All of these are useful additions, but none are game changers.

In contrast, Java 8's new functional programming additions are truly game changers. New functional constructs added to the language include lambda expressions, streams, method references, default methods, and more. These dramatic new additions will inspire you to program in fluent and functional ways that will liberate you focus on implementing functionality rather than imperatively instructing the computer how to do things. For shifting to a functional style of programming, you'll be rewarded with cleaner, more maintainable code that you'll be passionate about writing.

This talk will highlight essential elements of these functional programming additions to Java 8. By the time you leave the talk, your mind will be racing with all the ways you can leverage these features to write cleaner code that's more fluent, less imperative, and more easily maintained - all without leaving the comfort of our newly invigorated Java language.

Hypothesis and data driven development ties together current thinking about requirements, Continuous Delivery, DevOps, modern architecture, and engineering techniques to help rethink building 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 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. This talk also demonstrates how to undertake major architectural restructuring with zero regression failures by relying on data and the scientific method.

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

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

This talk is designed to catapult your productivity, enhance your emotional intelligence, and refine your problem-solving skills. This talk is not just a series of presentations; it's a transformative experience tailored for the ambitious software developer and architect seeking to leave a mark in the fast-paced world of technology.

Dive into the essence of developer and architect productivity, where we unravel the secrets to optimizing your workflow and leveraging your skills for maximum impact. Discover the “24 Hours Instant Happiness” principle, a proven strategy to inject a dose of joy into your daily routine, fostering a positive work environment and personal life.

“Maximizing Your Impact” takes you deeper into the realm of influence, equipping you with the tools to excel in your projects and inspire those around you. Through “Effective Communication” and the intriguing “Mirror Technique,” learn how to build rapport, foster collaboration, and lead with empathy, amplifying your charisma in all professional interactions.

As we delve into the core of success, “Emotional Intelligence is 85% of Success” highlights the paramount importance of self-awareness, self-regulation, motivation, empathy, and social skills in achieving your goals. The “6 Phase Meditation Approach” and “Day Launcher” sessions are designed to refine your focus, creativity, and emotional stability, setting a solid foundation for a productive day ahead.

The inclusion of “Empathy Maps” and “IDEO Case Studies” offers a practical lens through which to view user-centric design and innovation. At the same time, the “SCAMPER Technique” provides a creative framework for problem-solving, ensuring you're equipped to tackle challenges with agility and inventiveness.

Elevate your productivity to new heights with “5 Choices for Super Productivity,” a comprehensive guide to prioritizing effectively, embracing extraordinary outcomes, and mastering your technology. Learn the art of “Managing Energy, Not Time,” a paradigm shift that promises to enhance your efficiency and job satisfaction.

As the talk culminates, “The Paradox of Choice” and the latest “Technology Trends to Focus On” prepare you to navigate the complexities of the modern tech landscape with confidence and curiosity.

This masterclass is more than just a talk; it's an invitation to transform how you work, lead, and innovate. Join us to unlock your full potential and reshape your future in software development and architecture. Whether you're looking to boost your productivity, enhance your emotional intelligence, or simply find more joy in your work, this talk is your gateway to a more fulfilling career and life.

Developers and Architects are designers, problem solvers, and innovative, creative artists. Software design is an art that requires both left and right brains to be active so you can understand what customers need. Next, we will explore habits and tools to plan, learn, research, organize, teach, develop, mentor, and architect.

Agenda
Enhancing Productivity and Personal Growth
– Developer and Architect Productivity
Strategies for improving daily workflow and efficiency in software development and architecture.

– 24 Hours Instant Happiness
Quick wins for boosting morale and happiness within the team and personal life.

– Maximizing Your Impact
Techniques to increase your influence and contributions in projects and teams.

– Effective Communication
Importance of clear communication and the Mirror Technique to improve understanding and rapport.

– Increasing Charisma
Tips for becoming more charismatic and influential in professional settings.
Building Emotional Intelligence and Mindfulness

– Emotional Intelligence is 85% of Success
Discussing the critical role of emotional intelligence in achieving professional success.

– 6-Phase Meditation Approach
Introducing a meditation technique to enhance focus, creativity, and emotional stability.

– Day Launcher
A strategy to start your day with intention and focus, setting the tone for productivity and success.

– Empathy Map
Utilizing empathy maps to better understand user needs and enhance team collaboration.

– IDEO Case Studies
Examining case studies from IDEO to illustrate successful applications of empathy in design.

– Understanding a Problem with SCAMPER Technique
Exploring the SCAMPER technique to creatively solve problems and innovate solutions.
Strategies for Super Productivity

– 5 Choices for Super Productivity
Detailed strategies for enhancing productivity by prioritizing important tasks, aiming for extraordinary outcomes, scheduling priorities (“big rocks”), mastering technology use, and maintaining energy levels.

– Managing Energy, Not Time
Shifting focus from time management to energy management to maximize productivity and well-being.

– Increasing Frequency to Do What You Want
Techniques to align daily actions with personal and professional goals more effectively.

– The Paradox of Choice
Understanding how reducing options can lead to increased satisfaction and productivity.

– Technology Trends to Focus On
Highlighting current technology trends that developers and architects should be aware of to stay ahead in their field.

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.

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 when Java will be out of class path hell? Java 9 is for application developers, library developers by enablement of a scalable platform, greater platform integrity, and improved performance. In this talk, we will explore Project Jigsaw, HTTP 2.0, Lightweight JSON API and many other features.

Ever wonder when Java will be out of class path hell? Java 9 is for application developers, library developers by enablement of a scalable platform, greater platform integrity, and improved performance. In this talk, we will explore Project Jigsaw, HTTP 2.0, Lightweight JSON API and many other features.

API Gateway is a way to connect real-world cloud-ready applications. New applications need to design the data model and create public APIs to be consumed by mobile apps, third party apps, and different devices. We will explore best practices, which you must adopt to be cloud ready. Firstly, we will examine how contract first API development is helping enable more extensible and reliable APIs. Next, we will look at

We will ask tough questions during this design session.

• How to provide security? What are the best practices for authenticating?
• When should we version APIs? Should we use HATEOS for developing APIs?
• How to support internationalization?
• How to publish and maintain APIs?

We will take deep dive into the following areas:

• RESTful APIs design patterns:
• Principles for designing APIs, Hypermedia, Entity tags caching, filtering, Partial items, HAL
• API versioning techniques:
  URI path, URI parameter, Content Negotiation, Request header
• API Security:
  Threats, Protecting APIs, Authentication, API Keys: How they work? SAML, OAuth and JSON Web Tokens
• API Gateway:
  Customer-driven contract development
• API testing:
  SoapUI, Postman

The technology space is a lot like the ocean - miss one wave and another will come along shortly; most shiny new things begin with a sizable amount of hype as everyone rushes to play with the new toy. This cycle is often met with a level of disappointment as we quickly discover our new bauble isn't all that and a bag of chips so we rush off to the next best thing ever.

A few short years ago, HTML5 was the new hotness but at the time browser support was spotty at best. Despite the spotlight moving on to something else, browser support has improved markedly and we even have new toys to play with! In this talk, I will walk you through what is possible in today's browser as well as what other new features you might not be aware of. HTML5 may no longer qualify as bleeding edge, but it is still deserving of our attention.

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

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

If you have ever studied a martial art, chances are you are familiar with katas: the practice of individual training exercises. Repeatedly. It may seem pointless to practice the same move again and again, the only way to improve is repetition. We can apply the same concept to learning programming languages.

Working individually or in small groups, attendees will work through a set of problems using JavaScript to solve them. Whether you are new to JavaScript or an old hand, this session will give you an opportunity to hone your craft! Bring a laptop or be prepared to make a friend.

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

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

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

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.

Good architects are, almost by definition, good story tellers. And while good communication skills are vital to success as an architect, so too is an ability to constructively critique an architecture. In this talk, we'll explore why reviews are important and what it takes to perform them well. Additionally, we'll talk about the importance of planning and preparation in conducting a successful review.

Good architects are, almost by definition, good story tellers. And while good communication skills are vital to success as an architect, so too is an ability to constructively critique an architecture. In this talk, we'll explore why reviews are important and what it takes to perform them well. Additionally, we'll talk about the importance of planning and preparation in conducting a successful review.

The popularity of Docker as a micro-services tool has many organizations looking to put docker into production. With years of experience working with leading edge organizations, this workshop will not only teach Docker, but will provide real-world advice on how to work with Docker for production.

This session is a workshop and as such you will need to come with a laptop with Docker 1.10+ installed. The training and labs will include:

• Docker basics
• Container lifecycles
• Build files
• Working with the Registry
• Working with the docker machine
• Docker compose
  This will include the dos and don'ts for a production environment.

The session will end with standing up a Mesos / Marathon environment for scaling out a docker instance. Time allowing the bonus lab is standing up Kubernetes to run Docker instances.

The popularity of Docker as a micro-services tool has many organizations looking to put docker into production. With years of experience working with leading edge organizations, this workshop will not only teach Docker, but will provide real-world advice on how to work with Docker for production.

This session is a workshop and as such you will need to come with a laptop with Docker 1.10+ installed. The training and labs will include:

• Docker basics
• Container lifecycles
• Build files
• Working with the Registry
• Working with the docker machine
• Docker compose
  This will include the dos and don'ts for a production environment.

The session will end with standing up a Mesos / Marathon environment for scaling out a docker instance. Time allowing the bonus lab is standing up Kubernetes to run Docker instances.

Starting with JDK 5, we have had Futures, and they mostly went ignored. Now with concurrency and reactive technology in demand, it is essential that we understand what futures are, and how to handle them and make use of their power in asynchronous systems.

This presentation is a basic ground up introduction to Futures. We start with Futures and how they came packaged with JDK 5. We take a look at Executors, how to create a thread pool, which pool you should choose. How to model Futures in the JDK and show the difference for awaiting the answer and taking on the answer asynchronously. We also take a look at what a Promise is and when to use one. We then invest time taking a look at Guava's callback solution. Then we finally look at the handling of futures in both Scala and Clojure.

Take control of your knowledge portfolio and be in demand! Your command of the top JVM languages; Java 8, Groovy, Scala, JRuby, and Clojure; will set you apart from the rest. This presentation will introduce each of these languages, highlight common ground, and show some stark differences.

This presentation will cover:

• How to install each of the JVM languages
• Describe the “functionality” of each of the languages
• Expressiveness vs. Terseness of each language
• How each language handles mutability
• How each language handles concurrency
• Amazing tricks of each language
• Comparison of language typing
• Comparison and contrast of language performance
• Each language's killer app
• Analysis of the language culture and where to get help?
• Tips on how to start learning and keep learning with a busy schedule

How do we define identity in a distributed software system? How do we manage it securely? How do we make identity assertions and verify those claims?

Technologies don't magically become solutions. They are used within domain, design and deployment contexts. This talk will focus on the singular notion of Identity and how it cross-cuts the distributed systems we are building.

We will focus on a variety of technologies and standards that help us make, identify, claim and verify identities.

Authenticated Identities are the first step to establish Privilege. Most systems fail to have sufficiently, deeply entrenched notion of how to apply and minimize privilege to avoid data and systems from being abused.

Technologies don't magically become solutions. They are used within domain, design and deployment contexts. This talk will focus on the singular notion of Privilege and how it cross-cuts the distributed systems we are building.

This talk will focus on the Valet Key problem and how to avoid it. We will visit various standards and technologies that help us strengthen our security profiles by reducing our dependence on open-ended and unfettered access to our systems and data.

Data integration costs are well beyond what they should be for such a crucial business function. The good news is that they needn't be. By relying on integration-friendly standards and technologies that were designed to support sharing information, we can reduce these costs while increasing our business capabilities.

Technologies don't magically become solutions. They are used within domain, design and deployment contexts. This talk will focus on the singular notion of Integration and how it cross-cuts the distributed systems we are building.

We will look at how the REST Architectural style leads us to integration-friendly standards such as RDF, Linked Data, SPARQL and JSON-LD. These technologies are useful both within our firewalls and with third party partners.

Our biological world changes gracefully. Our information world changes much less so. How can we embrace the inevitable technological, procedural and schematic flux that we know is going to visit upon us at some point?

Technologies don't magically become solutions. They are used within domain, design and deployment contexts. This talk will focus on the singular notion of Evolution and how it cross-cuts the distributed systems we are building.

We will focus on strategies from the Web standards space to define information systems that embrace change and handle it with relative ease.

This will include strategies for dealing with changing technologies, changing schemas and more.

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

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 this session I will cover some of the more common anti-patterns you will likely encounter while creating microservices, and most importantly describe some of the techniques for avoiding these anti-patterns.

Agenda

• Function-Driven Identification AntiPattern
• I Was Taught to Share AntiPattern
• The Timeout AntiPattern
• Hop on the Bus AntiPattern
• Data-Driven Migration AntiPattern

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 this session I will cover some of the more common pitfalls you will likely encounter while creating microservices, and most importantly describe some of the techniques for avoiding these pitfalls.

Agenda

• Grains of Sand Pitfall
• Where's the Acid Pitfall
• Logging Can Wait Pitfall
• Jump on the Bandwagon Pitfall
• Give it a Rest Pitfall

When you hear the term “Internet of Things (IoT)” what do you think of? From a customer perspective it is a bunch of cool gadgets. From the datacenter perspective IoT == the onslaught of data and previously unprecedented scale.

This presentation is provide a walk through of the technologies necessary to dynamically create in data pipelines and process them for near real-time access to analytics.

This presentation will provide an overview of the Lambda architecture along with a brief walk through of each of the components of a common IoT datacenter infrastructure. Topics to include:

• AKKA
• Kakfa
• HDFS
• Spark
• Cassandra
• Mesos / DCOS

Brief mentions of Hive, Storm and InfluxDB included.

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.

Reactive architecture patterns allow you to build self-monitoring and self-healing systems that can react to both internal and external conditions without human intervention. How would you like to design systems that can automatically grow as the business grows, automatically handle varying load (cyber Monday?), and automatically handle (and repair) internal and external errors, all without human interaction? I'll show you how to do this with your current technology stack (no special languages, tools, frameworks, or products). In this two-part session I will leverage both slides and live coding using Java and RabbitMQ to describe and demonstrate how to build reactive systems. Get ready for the future of software architecture - that you can start implementing on Monday.

Part 1 Agenda:

• Reactive systems introduction
• Channel Monitor Pattern (self-awareness)
• Consumer Supervisor Pattern (scalability and elasticity)
• Workflow Event Pattern (error handling)

Reactive architecture patterns allow you to build self-monitoring and self-healing systems that can react to both internal and external conditions without human intervention. How would you like to design systems that can automatically grow as the business grows, automatically handle varying load (cyber Monday?), and automatically handle (and repair) internal and external errors, all without human interaction? I'll show you how to do this with your current technology stack (no special languages, tools, frameworks, or products). In this two-part session I will leverage both slides and live coding using Java and RabbitMQ to describe and demonstrate how to build reactive systems. Get ready for the future of software architecture - that you can start implementing on Monday.

Part 2 Agenda

• Thread Delegate Pattern (scalability)
• Threshold Adjust Pattern (automatic configuration and self-learning)
• Producer Control Flow Pattern (self-healing)

New architectural paradigms are emerging that challenge traditional assumptions about the way that scalable and adaptable software is built. At the heart of these paradigms is a modular approach that breaks apart the monolithic application into microservices. But breaking apart the monolith has implications beyond software architecture and microservices are just one implementation alternative.

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

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

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

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.

Scala for Java Developers is a full live code and fast paced presentation and workshop (laptops optional), and this is all about the Scala language.

Scala is a wonderful functional/hybrid language. It will become one of the 5 languages that you will need to know to be a highly successful JVM developer in the very near future (others being Groovy, Clojure, Java 8, and JRuby). Scala, as opposed to some of the other languages, has quite a learning curve. This presentation was built for questions. We will start with some basics, how this presentation will flow and end will be up to you, the audience. Bring your intellect, curiosity, and your questions, and get ready for some Scala. Laptops optional so you can try stuff out on your machine and create questions of your own!

Workshop Requirements

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

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

Unfortunately, Internet connectivity is sometimes a dicey affair and at times it can rain on our parade. To avoid having to wait for the install at the conference, you can prepare Scala before the conference! If you don't have the opportunity to do this, we will have either memory sticks or private networks at the conference. But it is preferred to do the installation before the event.

For MacOSX:

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

For Windows

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

For Linux

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

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

Eclipse - The Eclipse has an IDE plugin for Scala called aptly Scala-IDE. You can either download the complete Scala IDE which includes the complete Eclipse download. You can also download the plugin. All the information about the plugin can be found at http://scala-ide.org including an easy to follow along video located at http://scala-ide.org/docs/current-user-doc/gettingstarted/index.html. Scala-IDE is also available at the Eclipse Marketplace, although I would recommend getting the latest instructions from scala-ide.org

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

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

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

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

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

That is it. Hope to see you soon.

Scala for Java Developers is a full live code and fast-paced presentation and workshop (laptops optional), and this is all about the Scala language. This is Part 2, continuing where we left off from Part 1.

Scala is a wonderful functional/hybrid language. It will become one of the 5 languages that you will need to know to be a highly successful JVM developer in the very near future (others being Groovy, Clojure, Java 8, and JRuby). Scala, as opposed to some of the other languages, has quite a learning curve. This presentation was built for questions. We will start with some basics, how this presentation will flow and end will be up to you, the audience. Bring your intellect, curiosity, and your questions, and get ready for some Scala.

Workshop Requirements

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

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

Unfortunately, Internet connectivity is sometimes a dicey affair and at times it can rain on our parade. To avoid having to wait for the install at the conference, you can prepare Scala before the conference! If you don't have the opportunity to do this, we will have either memory sticks or private networks at the conference. But it is preferred to do the installation before the event.

For MacOSX:

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

For Windows

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

For Linux

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

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

Eclipse - The Eclipse has an IDE plugin for Scala called aptly Scala-IDE. You can either download the complete Scala IDE which includes the complete Eclipse download. You can also download the plugin. All the information about the plugin can be found at http://scala-ide.org including an easy to follow along video located at http://scala-ide.org/docs/current-user-doc/gettingstarted/index.html. Scala-IDE is also available at the Eclipse Marketplace, although I would recommend getting the latest instructions from scala-ide.org

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

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

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

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

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

That is it. Hope to see you soon.

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

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

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

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