Containers: What Every Developer Needs to Know about Docker & More!

Containers have been a feature of the Linux kernel since 2007, and were in use behind the curtain at Google well before then. But developers, for the most part, did not know about or use them. Enter Docker in 2013, and all of a sudden if you're not using containers, you're no longer playing with the cool kids. Is it all hype? Or will you be deploying your applications in containers before you know it? This workshop will arm you with what you need to know and give you hands-on practical experience with container technology.

We'll cover some (or all!) of the following topics:

• Docker 101
• Rocket and the App Container Spec
• Container Scheduling: Lattice, Kubernetes, Marathon
• Container Networking: Weave, SocketPlane
• Container Data Management with BOSH
• Service Discovery
• Containers and Microservices
• Continuous Delivery of Containers

Building Microservices

Microservices Architecture is a concept that aims to decouple a solution by decomposing functionality into discrete services. Microservice architectures can lead to easily changeable, maintainable systems that can be more secure, performant and stable.

In this workshop, you will discover a consistent and reinforcing set of tools and practices rooted in the philosophy of small and simple; this can help you move towards a microservice architecture. Microservices are typically small systems, with single responsibilities, communicating via the web's uniform interface, installed as well-behaved operating system services. However, with these finer-grained systems come new sources of complexity.

What you will learn
During this workshop, you will understand in depth what the benefits are of finer-grained architectures, how to break apart your existing monolithic applications, and the practical concerns of managing these systems. We will discuss how to ensure your systems can be more stable, how to handle security and the additional complexity of monitoring and deployment.
We will cover the following topics:
Principle-driven evolutionary architecture
Capability modelling and the “town planning” metaphor
RESTful Web integration and event-driven systems of systems
What microservices are (and aren't)
Integration techniques including cross-microservice use cases like search and reporting
How to handle interface version changes
Deployment techniques and supporting technology
The importance of matching your organisational structure and your architecture
Continuous Integration and testing of microservices

Angular Workshop

Angular is a new JavaScript framework from Google. If you are looking into developing rich web applications, Angular is your friend. Angular embraces HTML and CSS, allowing you to extend HTML towards your application, and uses plain JavaScript which makes your code easy to reuse, and test. In this workshop we will start from the ground up, and build our way through a simple application that will let us explore the various constructs, and the familiarize ourselves with some of the new terminology in Angular.

In this workshop we will get down and dirty with Angular. In this workshop we will start with the very basics of how to boostrap our AngularJS application, and work slowly towards making REST-ful AJAX requests to a backend. List of topics include

• Bootstrapping an AngularJS application using ng-app
• ng-init and the evaluation {{ }} directive
• A brief look at $rootScope
• ng-model
• Controllers, Dependency Injection, and the View-Model (controller as syntax)
• Looping using ng-repeat
• Forms using ng-form, form validation and submission in AngularJS
• Angular provided filters and how to write our own
• Factories
• Making AJAX requests using $http
• Routing and route params using $routeProvider and $routeParams

If time permits we will discuss a few good practices when working with AngularJS applications.

This is a hands on tutorial so bring your laptops!

Android Workshop

Learn Android development from the ground up. We’ll start with the SDK and the Android Studio IDE and build, test, and deploy applications on both emulators and physical devices.

Several examples will be provided that cover a range of topics from basic activities to the SQLite database to accessing RESTful web services.

iOS Development with Swift

Swift is Apple's new language for developing iOS and OS X apps. Swift is a type-safe language that builds on the best of C and Objective-C with the clarity and features of a modern language. This workshop will cover the fundamentals of the Swift language and the latest features of the iOS toolkit.

In this hands-on session, you will learn to use Swift, XCode 7, Interface-Builder, UIKit Controlls, Auto-Layout, JSON, and iOS UnitTesting.

Cassandra Workshop

What do you do when your data is not only big, but also needs to be fast? Apache Cassandra is a scalable, fault-tolerant database that has found its way into more than 25% of the Fortune 100 and continues to enjoy significant adoption in the marketplace.

In this workshop, we’ll explore Cassandra’s internals, its flexible data model, its SQL-like query language, some deployment scenarios, and some common language bindings. You’ll leave ready to begin exploring Cassandra on your own.

Software Architecture Fundamentals

The job Software Architect places in the top ten of most annual surveys of best jobs, yet no clear path exists from Developer to Architect. Why aren’t there more books and training materials to fill this demand? First, software architecture is a massive multidisciplinary subject, covering many roles and responsibilities, making it difficult to teach because so much context is required for the interesting subjects. Second, it’s a fast moving discipline, where entire suites of best practices become obsolete overnight. This workshop provides the fundamentals to transition from developer to architect, or to help “accidental” architects.

Part 1 of this workshop focuses on the many elements required to make the journey from developer to architect, covering process topics like the impact of Continuous Delivery on architecture, technical subjects like application, integration, and enterprise architecture, and soft skills. While we can’t make you an architect overnight, we can start you on the journey with a map and a good compass.
Part 1, From Developer to Architect, covers:

• Soft skills
• Continuous Delivery
• Understanding large codebases
• Architecture patterns
• Architecture anti-patterns
• Integration architecture overview
• Introduction to enterprise architecture

Part two of this workshop takes a deeper dive in application, integration, and enterprise architecture topics, including evaluating architectures via Agile ATAM, the impacts of continuous delivery on architecture, comparing architectures, SOA, SOAP, and REST, integration hubs, and enterprise architecture approaches and strategies.

Part 2, Deeper Dive, covers:

• Continuous Delivery for architects
• Applying abstraction
• Comparing architectures
• SOAP vs REST/ WS vs Messaging
• Integration hubs
• Enterprise architecture approaches and strategies
• Comparing service-based architectures

To fully leverage knowledge, you need application. The last part of this workshop uses the public domain Architectural Katas exercise to apply learnings from the first two parts.

Hacking & Hardening Java Web Applications Workshop

It seems like everyday there is a new headline about a security breach in a major company’s web application. These breaches cause companies to lose their credibility, cost them large sums of money, and those accountable undoubtedly lose their jobs. Security requires you to be proactive. Keep your employer out of the headlines by learning some key security best practices.

This hands-on workshop is designed to teach you how to identify and fix vulnerabilities in Java web applications. Using an existing web application, you will learn ways to scan and test for common vulnerabilities such as hijacking, injection, cross-site scripting, cross-site forgery and more. You will learn best practices around logging, error handling, intrusion detection, authentication and authorization. You will also learn how to improve security in your applications using existing libraries, frameworks and techniques to patch and prevent vulnerabilities.

Functional Programming with Java8

With Java supporting lambda expressions, we have nothing to stop us from creating functional style of code for our day to day applications. We are so used to object-oriented programming, but remember the paradigm shift we went through to adapt to that way of programming. It is yet another paradigm shift and most of us wonder how in the world can we write functional style code. Much like how OO was not as much about the syntax as it was about the design, functional programming is about the design, the idioms, and the data structures we would use to program.

In this hands-on workshop, we will learn about functional programming using practical examples, create small apps that will make use of this style of programming, and relate to how it differs from the traditional way were used to and the benefits it offers.

Scaling and Fault Tolerance Workshop

There was a day when it was common to see the twitter fail whale! This imagine, extinct today, was the sign that scaling at twitter was broken in some way. What did Twitter do in order to increase their ability to scale, be more fault tolerant all while growing significantly. The answer is a move to Apache Mesos and leveraging container technology.

Google in 2009 had a top secret project we now know as the Google Borg project. That technology was reincarnated in an open source project out of UC Berkley known as Apache Mesos. Mesos has grown up significantly while at Twitter providing production tested solution for scaling applications and containers. In addition Solomon himself stated at DockerCon EU in December 2014 that Mesos is the only reliable way to scale docker in a production environment today.

This session is a hands on workshop. It is broken into 3 separate but related parts.

The first part is an 1.5 hour lecture of the challenges of the datacenter today. It will provide an overview of

* containers, 
* static vs. elastic partitions 
* schedulers.

The second part is a dive into docker with time for hands on labs. You will need access to docker for 1/2 of this session. We will have some discussion on the issues of running Java in a container with a focus on needs of production.

The third part will be on Apache Mesos and several different schedulers. We will discuss:

* different types of containers
* stateful service solution
* service discovery
* typical failures at twitter and how to avoid them

This also has a hands on component. You will need either:

* A Google Compute Engine account
* A AWS account
* Software local on your laptop to run vagrant

The last shorter part will include an overview of technologies on the horizon in this fast paced micro-services space.

R : Analyzing and Visualizing Data

At the intersection of Big Data, Data Science and Data Visualization lives a programming language that ranks higher on the TIOBE index than Scheme, Fortran, Scala, Prolog, Erlang, Haskell, Lisp and Clojure.

The R language and environment is an open source platform that has quickly become THE language for analyzing data and visualizing the results. This talk will introduce you to the language, the environment and how it is being used with Big Data and Linked Data.

You don't need to be a stats head to attend this session. We'll introduce some basic concepts. If you are a stats head, there is plenty of material that you will still enjoy.

• History of R
• Language basics, data types and main structures
• Some statistics fundamentals
• R Graphics
• R and Big Data
• R and Linked Data

An Introduction to Video Game Development

With many AAA video games in its portfolio, Unity has become a powerhouse within the game development and simulation industry. But Unity is more than a game engine — it's a complete ecosystem of tools, workflows, and integrations. Very small development teams and even individual hobby developers can create great games with Unity, for any platform, 3D or 2D.

In this workshop, I'll give an overview of tools and techniques for building games for desktop and mobile using the Unity. We will break down a real game for iOS, from asset creation, to building scenes, to scripting in C# (on Windows and Mac), to animation, to testing and finally publishing a game. You will leave this workshop with an understanding of the power of Unity, and the knowledge necessary to start building games. Game development is a thrill, and all developers can benefit from a knowledge of the cutting edge tools.

Building a PaaS Workshop

Platform as a Service (Paas) is all the buzz today…. but why? What's the value proposition? Once you have decided that it is for you… what are your options?

This 2 session presentation is broken down in to 3 parts. The first is understanding why organizations on moving to PaaS and what to expects. The second and third part includes a walk through of PaaS options with part 2 being traditional PaaS and part 3 highlighting container based PaaS solutions.

We will conclude with a short discussion on getting PaaS like experiences without a PaaS and what that might look like.

Bulletproof JavaScript Workshop

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 hands on workshop 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.

Clojure Workshop

In an increasingly crowded field of languages, Clojure stands alone. It is a dynamic, functional, high performance dialect of Lisp that runs on both the JVM and CLR. The creator cast aside assumptions from both the Lisp and Java communities to create a remarkable language implementation.

This workshop introduces Clojure to Java developers who might not have seen a Lisp and don’t yet understand why that’s such an advantage. I introduce the language syntax (what little there is of it), cover interoperability with Java, macros, mutlti-methods, and more. I also cover the functional aspects of Clojure, showing its powerful immutable data structures, working with threads and concurrency, and sequences. Beyond just showing syntax, I also show how to build real applications in Clojure, and give you a chance to do the same. Attending this workshop shows enough to pique your interest and show why many of the people who were interested in Java in 1996 are interested in Clojure now.

Continuous Delivery for Architects Workshop

Architecture doesn't exist in a vacuum, a painful lesson developers who built logically sound but operationally cumbersome architectures learned. Continuous Delivery is a process for automating the production readiness of your application every time a change occurs–to code, infrastructure, or configuration. Some architectures and practices yield code that works better in this environment. This session takes a deep dive into the intersection of the architect role and the engineering practices in Continuous Delivery.

Yesterday's best practice is tomorrow's anti-pattern. Architecture doesn't exist in a vacuum, a painful lesson developers who built logically sound but operationally cumbersome architectures learned. Continuous Delivery is a process for automating the production readiness of your application every time a change occurs–to code, infrastructure, or configuration. Some architectures and practices yield code that works better in this environment. This session takes a deep dive into the intersection of the architect role and the engineering practices in Continuous Delivery. I first set context for the information you must master before delving into the nuances of modern architectural concerns. I discuss the role of metrics to understand code, how Domain Driven Design's Bounded Context reifies in architecture, how to reduce intra-component/service coupling, the tension between coupling and cohesion, microservices architectures, and other engineering techniques.

This workshop allows you to apply techniques either against a sample codebase…or bring one of your own. Suggested exercises include using metrics to learn more about the structure of your class, how to determine how to partition a mono-lithic architecture into a service-based ond, and Architectural Katas with Devops added.

Continuous Delivery Workshop, part 1 of 3: Deployment Pipelines

The first part of the Continuous Delivery workshop covers the differences between continuous integration, continuous deployment, and continuous delivery). It also introduces the deployment pipeline_, along with usage, patterns, and anti-patterns. This part concludes with some applied engineering principles.

Releasing software to actual users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers and operations, delivery teams can get changes released in a matter of hours—sometimes even minutes—no matter what the size of a project or the complexity of its code base. The workshop materials are derived from the best selling book Continuous Delivery and creating in collaboration with the authors and other of my ThoughtWorks colleagues. Continuous Delivery details how to get fast feedback on the production readiness of your application every time there is a change—to code, infrastructure, or configuration.

The first part of the workshop describes the technical differences between related topics such as continuous integration, continuous deployment, and continuous delivery. At the heart of the workshop is a pattern called the deployment pipeline, which involves the creation of a living system that models your organization's value stream for delivering software. I discuss the various stages, how triggering works, patterns and anti-patterns, and how to pragmatically determine what “production ready” means. This session also covers some agile principles espoused by the Continuous Delivery book, including new perspectives on things like developer workstations and configuration management.

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

Continuous Delivery relies on a variety of interlocking engineering practices to work efficiently; this session covers three related topics. First, I cover the role of testing and the testing quadrant. Second, I specifically cover version control usage and offer alternatives to feature branching like toggle and branch by abstraction. Third, I describe some incremental release strategies, along with their impact on other stages of project lifecycle.

Releasing software to actual users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers and operations, delivery teams can get changes released in a matter of hours—sometimes even minutes—no matter what the size of a project or the complexity of its code base. The workshop materials are derived from the best selling book Continuous Delivery and creating in collaboration with the authors and other of my ThoughtWorks colleagues. Continuous Delivery details how to get fast feedback on the production readiness of your application every time there is a change—to code, infrastructure, or configuration.

Continuous Delivery relies on a variety of interlocking engineering practices to work efficiently; this session covers three related topics. First, I cover the role of testing and the testing quadrant, including the audience and engineering practices around different types of tests. I also cover some best practices around testing, including testing ratios, code coverage, and other topics. Second, I specifically cover version control usage and offer alternatives to feature branching like toggle and branch by abstraction. Generally, I talk about building synergistic engineering practices that complement rather than conflict one another. In particular, I discuss why feature branching harms three other engineering practices and describe alternatives. Third, I describe some incremental release strategies, along with their impact on other stages of project lifecycle.

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

Two big stumbling blocks for Continuous Delivery adaptation are interactions with operations and the keepers of data. First in this session, I cover operations, DevOps, and programmatic control of infrastructure. Second, I discuss how to incorporate databases and DBA's into the Continuous Integration and Continuous Delivery process.

Releasing software to actual users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers and operations, delivery teams can get changes released in a matter of hours—sometimes even minutes—no matter what the size of a project or the complexity of its code base. The workshop materials are derived from the best selling book Continuous Delivery and creating in collaboration with the authors and other of my ThoughtWorks colleagues. Continuous Delivery details how to get fast feedback on the production readiness of your application every time there is a change—to code, infrastructure, or configuration.

Two big stumbling blocks for Continuous Delivery adaptation are interactions with operations and the keepers of data. First in this session, I cover operations, DevOps, and programmatic control of infrastructure using tools like Puppet and Chef. I also discuss the explosion of tool alternatives in this space, and cover some current-day best practices. Second, I discuss how to incorporate databases and DBA's into the Continuous Integration and Continuous Delivery process. This includes database migrations, strategies for enhancing collaboration between application development and data, and database refactoring techniques.

Design Your Agile Project

Is your agile transition not going quite the way you expected? Are people thinking that the standups are an excuse for micromanagement? Are you trying to use iterations and standups with far-flung team members and you can hear people yawning on the calls? Do you have so much work in progress that you never finish anything at the end of the iteration? You might be trying to use a standard approach to agile, when you need to personalize your approach.

Every team is different and each project is unique. While you might have the same goals as any other agile project, how you get there might be different. In this workshop, we’ll use the Cynefin framework to think through your specific challenges. We’ll see if you can use “agile out of the box” or if there is a better approach that may suit you better. You have many options. Let’s explore them together.

Enterprise Messaging Workshop

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

Graph Database Fundamentals

This half-day workshop will cover the fundamentals of Graph Databases with hands-on exercises using Neo4J.

Environment Setup

• Hello World Graph!
• Web Console
  Introduction
• What are Graphs?
• NoSQL Landscape
• Relational vs. Graph
  Fundamentals
• Constructs
• Modeling
• Languages
• Development
• Testing
  Architecture
• Graph Database
• Deployment Topologies
• High Availability (HA)
• Operations and Security
  Advanced Concepts
• Bulk Loads
• Traversals
• Indexes
• Visualization

Groovy for Java Developers

Learn Groovy from a Java developer's perspective. Use Groovy features like native collections, operator overloading, and the Groovy JDK. Additional topics will include closures, builders, AST transformations, and basic metaprogramming.

Tests using both JUnit and Spock will be provided, as well as a Gradle build file. All code will be made available through a git repository.

Have You Seen Java EE Lately?

With a strong focus on annotations, minimalist configuration, intelligent defaults and Java centric type-safety, Java EE is one of the most productive full-stack development platforms around today. This very code centric workshop is a quick tour of the Java EE platform as it stands today. If you haven't seen Java EE for a while and want to catch up, this session is definitely for you.

We will start with the basic principals of what Java EE is and what it is not, overview the platform at a high level and then dive into each key API like JSF, CDI, EJB 3, JPA, JAX-RS, WebSocket and JMS. This is your chance to look at Java EE 7 in the context of a realistic application named Cargo Tracker, available with an MIT license at http://cargotracker.java.net.

We will also briefly take a look at the emerging horizons of Java EE 8.

High Performance JavaScript Patterns

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.

Introduction to Hadoop Workshop

As an industry we are collecting more and more data. At some point we have to be able to make sense of the data. Unfortunately many of the tools we have historically used can not scale up to the terabytes and petabytes we have captured. Hadoop is one of those relatively new technologies that is taking the industry by storm since it has proven to scale by taking advantage of the MapReduce pattern and distributed computing.

During this hands-on tutorial you will provision a Hadoop cluster, write MapReduce jobs and learn how to store and access data via Hadoop Distributed File System (HDFS). You will also learn how cloud providers such as Amazon Web Services’ Elastic MapReduce (EMR) and Microsoft’s Azure HDInsight provide Hadoop as a service.

Java in the (Amazon) Cloud Workshop

Wonder what all the Cloud Computing hype is about? Want to know how to deploy a standard Java web application to the cloud and get limitless scalability? Well, this hands on tutorial will answer all your questions and provide confidence by walking you through the process of deploying a sophisticated Java web application to the Amazon Web Service (AWS) Cloud.

During this tutorial you will provision clustered servers (EC2), relational database (EC2 and EBS), load balancer (Elastic Load Balancing), content delivery (Cloud Front) and how to monitor your whole infrastructure. Other Amazon Web Services will be demonstrated and discussed as appropriate.

Note: An Amazon Web Services Account is a nice to have and will incur a minimal cost during the tutorial but is not a requirement. Access to AWS will be provided to you if you don’t already have access.

Measuring Quality of design (1/2 day workshop)

Before spending substantial effort in refactoring or altering design, it would be prudent to evaluate the current quality of design. This can help us decide if we should proceed with refactoring effort or a particular alteration of design. Furthermore, after evolving a design, using some design metrics would help us to evaluate if we have improved on the design front.

In this workshop we will learn about some critical qualities of design and how to measure those. We will learn about these by working through some example code, refactoring it, and evaluating the design again at each stage of refactoring.

Modeling for Architects

In some organizations, architects are dismissed as people that draw box and arrow diagrams - the dreaded whiteboard architect. While we don't want to foster that stereotype, it is important for an architect to be able to construct basic architectural diagrams. An architect must also be able to separate the wheat from the chaff eliminating those models that don't help tell the story while fully leveraging those that do.

In this workshop, we'll discuss the various diagrams at our disposal. We'll walk through a case study and as we go, we'll construct a set of diagrams that will help us effectively communicate our design. We'll talk about stakeholders and who might benefit from each typ of diagram. Additionally we'll discuss how to constructively review an architectural model.

Next Generation Web Applications Workshop

The next generation of web applications using a cluster of resources instead of running on a single instances of a node in a cluster. To build this capability from scratch would be a costly proposition. Fortunately there is Apache Mesos. It abstracts the cloud and the data center and allows you to focus on your application needs. This is a workshop which will get into writing your first application which leverages a cluster of nodes.

To participate in this session you will need a computer with Java on it and for the best experience you will need a google account for Google Cloud Platform. An alternative is to use Vagrant with Virtualbox.

This will be a code focused workshop with focus on:

• Apache Mesos
• Protocol Buffers
• Java

Scala for Java Developers (1/2) (Laptops Optional)

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!

Scala for Java Developers (2/2) (Laptops Optional)

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.

Semantic Web Workshop

The Web is changing faster than you can imagine and it is going to continue to do so. Rather than starting over from scratch each time, it builds on what has succeeded already. Webs of Documents are giving way to machine-processable Webs of Information. We no longer care about data containers, we only care about data and how it connects to what we already know.

Roughly 25% of the Web is semantically marked up now and the search engines are indexing this information, enriching their knowledge graphs and rewarding you for providing them with this information.

In the past we had to try to convince developers to adopt new data models, storage engines, encoding schemes, etc. Now we no longer have to worry about that. Rich, reusable interface elements like Web Components can be built using Semantic Web technologies in ways that intermediate developers don’t have to understand but end users can still benefit from. Embedded JSON-LD now allows disparate organizations to communicate complex data sets of arbitrary information through documents without collaboration.

Perhaps the concepts of the Semantic Web initiative are new to you. Or perhaps you have been hearing for years how great technologies like RDF, SPARQL, SKOS and OWL are and have yet to see anything real come out of it.

Whether you are jazzed or jaded, this workshop will blow your mind and provide you with the understanding of a technological shift that is already upon us.

In this workshop, we will:

Explain the Web and Web architecture at a deeper level
Apply Web and Semantic Web technologies in the Enterprise and make them work together
Integrate structured and unstructured information
Create good, long-lived logical names (URIs) for information and services
Use the Resource Description Framework (RDF) to integrate documents, services and databases
Use popular RDF vocabularies such as Dublin Core, FOAF
Query RDF and non-RDF datastores with the SPARQL query language
Encode data in documents using RDFa and JSON-LD
Create self-describing, semantic Web Components
Model and use inferencing with the Web Ontology Language (OWL)

The search is over: Solr

Searching is an integral part of many applications today and yet it can still be difficult to integrate search into an application well. Search becomes even more challenging when you consider searching across an enterprise or need to support a large scale.

This presentation will explain how you can simplify searching with the open source enterprise search engine, Apache Solr. By the end of the presentation you will understand the relationship between Apache Lucene and Solr, how to create search documents, populate search documents all using Solr's easy REST-like HTTP/XML and JSON APIs. We will also look at some of the more interesting document mapping strategies and maybe even at some of the geo spacial searching capabilities.

Tuning Your Agile Team

Is your team working as well as it could be? Are you concerned about its practices or teamwork? If so, this is a clinic in which to bring your team. We'll experience a project and then “debug” the practices and and teamwork and see what might work better (or worse!). We will fail fast and succeed faster.

When teams transition to agile, they discover some pitfalls and traps along the way. They don’t always work by value. Their stories are too big. They may not have one product owner—they sometimes have none or three. The standups feel like micromanaging.

In this workshop, we’ll learn by doing. If you have your team with you, you’ll discover what your team does. If you come alone, you’ll discover the challenges of creating a team with new people and what that team does.

We’ll experience and then discuss how you can help your team become better, wherever it is. Learn some tips to make your agile teamwork succeed.

If you don’t have an entire team, come anyway, and you’ll learn something to bring back to your team.