Have you ever wanted (or needed!) to add search to your web site or application but thought it was too hard hard because you wanted things like scalability, fault tolerance and real-time search? Elastic Search may be just the ticket for you. It's Open Source, fast, scalable and easy to set up. Oh, and it's “cool, bonsai cool.”
Search is hard. It's not just about finding the “needle in the haystack” - it's about making search reliable, scalable and fast. Elastic Search aims to solve all these problems and more. It's got the features you need for a modern application, like multi-tennancy, painless setup and auto-sharding. Oh, and it's easy to integrate regardless of the technology stack you're developing with - simply use JSON over HTTP. No need to plan out a complex schema beforehand, either. It's schema free and document oriented.
Despite it's simplicity of use and ease of setup, Elastic Search is no lightweight. It's built on rock solid foundations such as Apache Lucene and comes from the creator of Compass project.
In this session, we'll go over the basics of Elastic Search and dive right in to see it in action. You'll see how it sets set up and running in no time across multiple nodes and how easily it integrates with applications. We will explore what happens when a node drops out, as well as how to deploy it with technologies like Chef.
This two-session workshop provides a hands-on introduction to Mule Enterprise Service Bus (ESB).
Agenda
Environment Setup
ESB Core Concepts
Mule ESB Fundamentals
Mule ESB Exercises
This two-session workshop provides a hands-on introduction to Mule Enterprise Service Bus (ESB).
Agenda
Environment Setup
ESB Core Concepts
Mule ESB Fundamentals
Mule ESB Exercises
The modularity patterns provide us with proven design techniques to develop a modular software architecture that is extensible, reusable, maintainable, and adaptable. In this session, we’ll explore 9 of the 18 modularity patterns.
This session introduces and examines the following patterns:
The modularity patterns provide us with proven design techniques to develop a modular software architecture that is extensible, reusable, maintainable, and adaptable. In this session, we’ll explore the remaining 9 modularity patterns.
This session introduces and examines the following patterns:
Modularity is coming to the Java platform! Java 8 will introduce the Jigsaw module system. OSGi is here today. Don’t wait to start designing modular software. Contrary to popular belief, you don't need a framework or a new runtime to start building modular software applications. You can start today. Learn how!
In this session, we'll examine what it means to develop modular software on the Java platform. We'll examine the goals and benefits of modular software, and explore the patterns of modular architecture that help us develop modular software systems. With just a few easy steps, we'll see how to transform our software from a huge monolith to an extensible system of collaborating software modules. By examining an existing software system, we'll see first hand how we can increase software modularity with minimal disruption. You'll walk away not just with a much deeper understanding of the benefits of modular software, but also a migration roadmap for refactoring existing applications to increase their modularity. In other words, you'll see how to get ready today for the application platform of tomorrow.
A little old lady once challenged a well-known scientist’s explanation on the structure of the universe, countering that the world is really a flat plate supported on the back of a giant tortoise. The scientist rebutted the little old lady’s challenge with one of his own by asking what the tortoise was standing on. The little old lady’s sly reply was that it’s, “turtles all the way down.” So too is software architecture “turtles all the way down”.
In this session, we cover a broad range of topics that include challenging traditional practices of software architecture, examining what it takes to bring down the ivory tower, probing the paradoxical aspects of architecture’s goal, and investigating the inextricable link between temporal decisions and structural flexibility. From the highest level applications and services to the code that exists in the bowels of the system, and everything in between, we explore how an effective software architecture must be turtles all the way down. In the end, we will all have gained deep insight to the value of agile architecture.
What do you need to know about combinatorics, number theory, and the underpinnings of public key cryptography? Well, maybe more than you think!
In this talk, we'll explore the branch of mathematics that deals with separate, countable things. Most of the math we learn in school deals with real-valued quantities like mass, length, and time. However, much of the work of the software developer deals with counting, combinations, numbers, graphs, and logical statements: the purview of discrete mathematics. Join us for this brief exploration of an often-overlooked but eminently practical area of mathematics.
By now, we are all familiar with the new orthodoxy: the product owner discerns the needs of the customer and feeds them to developers in the form a prioritized backlog. Developers pull work from that backlog, always confident that they're working on the highest-priority feature at the moment, and never having to worry about how those priorities are allocated. This system is simple, efficient, and has helped many teams function better than they used to.
Shakespeare wrote, “The first thing we do, let's kill all the lawyers.” It might be time to apply this aphorism to product management.
A few revolutionary companies are experimenting with the idea that developers should be in charge not only of when they build new features, but what features to build. Rather than mere code technicians following the will of a product and marketplace expert, developers themselves become experts in their product domain, building the tools users need—by conceiving of those tools themselves. Dispensing with the product owner creates an entirely new organizational tenor: one in which everyone is encouraged to master the business's domain, to organize their work in autonomous ways, and to take ownership of the purpose for which the organization exists.
Come ready to hear ground-breaking ideas and engage in group discussion about how these ideas might be put into practice in your workplace.
Invoke dynamic is a Java 7 feature that had the most impact at the bytecode level and also in terms of performance. First perceived as a feature to help dynamically typed languages on the JVM, it turned into a powerful feature that has been exploited quite a bit in the implementation of features in the Java
language itself.
In this presentation we will understand what problem this features really solves and how it has influenced other features in the Java language and on the Java platform.
User experience and rich interaction is top in the list of things that influence the success and adoption of applications. Such richness and interactions were owned by desktop and native applications in the past. Over the recent years the web has become increasingly interactive, but the true richness was still lacking. But all that has changed with HTML 5 canvas and animation techniques.
Come to this session to learn how to create rich interactive applications with good animation, mouse and touch based interactions.
Developing a rich user interface for web applications is both exciting and challenging. HTML 5 has closed the gaps and once again brought new vibe into programming the web tier. Come to this session to learn how you can make use of HTML 5 to create stellar applications.
.
Attendees are expected to pair up and work on the labs. Software requirements:
As mobile computing takes over the world, organizations have a dilemma. Do you build separate native apps to get the best user interface or save money and write a mobile web app? Calatrava turns this binary decision into a sliding scale.
I'll talk about how this new open source framework helps build cross-platform mobile apps, with high-quality, native user interfaces.
If you bring a Mac with Git, Ruby, RVM, Bundler, NodeJS, Android SDK and XCode, you can play along too.
The question of how much design to do up-front on a project is an engaging one. Too much design often results in overkill, complexity, and wasted work. Too little design results in insufficient system structures that require rework, additional complexity, and wasted effort. How can we know what the right balance is? Alan Shalloway shows how to use the advice from Design Patterns coupled with the attitude of not building what you don’t need from Agile. The trick is in observing potential variation, how it may affect you, and then how to isolate these risks in a simple manner.
Alan describes the essence of emergent design – that is, starting with a simple design and letting it evolve as the requirements evolve. He also demonstrates how to refactor to better designs and how this is different from refactoring bad code.
While Scrum and XP have become very popular in agile development shops, most companies adopting them run into problems beyond just a few teams. These challenges often fall into a common set of patterns, which points to a lack of systems thinking—the process of understanding how things influence one another within a larger whole.
Alan Shalloway shares his ideas on how the agile community can move beyond its team-centric approach to adopt a more holistic, systems-based approach. Systems thinking creates new opportunities to create substantially larger development teams—Alan calls them “pan-teams.” These teams work interdependently with a common vision and context. Pan-teams enhance the motivations for the teams and individuals to collaborate as a normal part of their daily work thus reducing the amount of forced collaboration. Although not a panacea, systems thinking provides a better platform to solve enterprise-wide challenges because your organization learns to approach problem-solving holistically and avoid the trap of unintended consequences
This seminar starts by teaching the basics of design patterns. However, instead of focusing on patterns as solutions, we’ll investigate the thought process that created the patterns in the first place. While patterns are often described as “solutions to recurring problems in a context” that’s really only the first step to understanding what patterns really are.
Patterns are really a thought process to solving problems. The patterns themselves, as individual design elements, are interesting and somewhat useful. But, it is when you learn to think in a pattern-oriented way that they deliver the vast majority of their value to you. Patterns are the result of following a few principles – find what varies, encapsulate it and design to an interface that hides the variation – as well as a few additional supporting practices. This seminar will lay these out.
There is a lot of confusion about what Kanban is. Some of this is due to the fact that many people who have never used Kanban have been deriding it – saying it is a mechanistic team management method that doesn’t respect people. The fact that Kanban is quickly growing and gaining a reputation for success where other Agile methods have had challenges belies that categorization.
But what is Kanban? Even when listening to Kanban thought leaders one will hear different answers. 1) it’s a power agile management system based on lean-flow. 2) it’s a transition management method to assist teams to achieve continuous learning. 3) It’s a way to create visibility for executives to improve their product portfolio management. I can almost here Gilda Radner and Dan Aykroyd on Saturday Night Live describing New Shimmer!
This talk discusses how Kanban actually is a multi-faceted method that assists process, transition and collaboration. Kanban is not a mere tool, or even a set of practices. It’s a mindset that attends to people, their culture, and the systems they find themselves working in. The talk presents a few of the basics of Lean-Flow and theory of constraints that it is based on as well as some of the psychological aspects of people adopting new methods.
While this talk is intended for those considering adopting Kanban, those currently using Scrum will find it helpful as many of the principles and practices of Kanban fit well into the Scrum framework.
Learning Objectives
• Kanban as a transition method
• Kanban as a team practice
• Kanban as a collaborative tool between executives, management and teams
• Why does Kanban work
• How one can improve Scrum with the Kanban mindset
• The principles of Kanban
• Why Kanban works
• Why Scrum works
Have you looked into Scala? Scala is a new object-functional JVM language. It is statically typed and type inferred. It is multi-paradigm and supports both object oriented and functional programming. And it happens to be my favorite programming language.
If you are interested in Scala, how you are planning to learn Scala? You probably are going to pick up a book or two and follow through some examples. And hopefully some point down the line you will learn the language, its syntax and if you get excited enough maybe build large applications using it. But what if I tell you that there is a better path to enlightenment in order to learn Scala?
Scala Koans, a set of test cases that will teach you Scala language. The Scala koans will help the audience learn the language, syntax and the structure of the language through test cases. It will also teach the functional programming and object oriented features of the language. Since learning is guided by failing tests it allows developers to think and play with the language while they are learning.
Namaste,
For those planning to attend the Scala Koans…
Welcome to Scala Koans!
Scala Koans is an interactive session that puts the programming and learning in your hands. Therefore, a laptop is required by all participants. If you do not have a laptop, then perhaps you have a friend with a laptop, is so, well, that would work too. In order to participate in the Scala Koan endeavor, a few things are required:
The process of actually running the koans will be covered during the session. 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 for the koans 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.
If you want to get started with the set up:
Before attending the koans session, you may 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. 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
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
That is it. Hope to see you soon.
Have you looked into Scala? Scala is a new object-functional JVM language. It is statically typed and type inferred. It is multi-paradigm and supports both object oriented and functional programming. And it happens to be my favorite programming language.
If you are interested in Scala, how you are planning to learn Scala? You probably are going to pick up a book or two and follow through some examples. And hopefully some point down the line you will learn the language, its syntax and if you get excited enough maybe build large applications using it. But what if I tell you that there is a better path to enlightenment in order to learn Scala?
Scala Koans, a set of test cases that will teach you Scala language. The Scala koans will help the audience learn the language, syntax and the structure of the language through test cases. It will also teach the functional programming and object oriented features of the language. Since learning is guided by failing tests it allows developers to think and play with the language while they are learning.
Namaste,
For those planning to attend the Scala Koans…
Welcome to Scala Koans!
Scala Koans is an interactive session that puts the programming and learning in your hands. Therefore, a laptop is required by all participants. If you do not have a laptop, then perhaps you have a friend with a laptop, is so, well, that would work too. In order to participate in the Scala Koan endeavor, a few things are required:
The process of actually running the koans will be covered during the session. 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 for the koans 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.
If you want to get started with the set up:
Before attending the koans session, you may 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. 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
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
That is it. Hope to see you soon.
Writing documentation is hard enough. Why do we insist on making it harder by burying the content in an XML schema like DocBook or wrestling with finicky WSYWIG editors? Come learn how to achieve writing zen with AsciiDoc and use Asciidoctor to produce beautiful HTML 5, DocBook and PDF documents–or even a slide deck like the one used in this presentation!
What if you could write documentation just as you write email? Imagine if you could forget about the layout and styling and just let your thoughts flow. That's the idea behind lightweight markup languages such as AsciiDoc. They provide a plain text syntax designed for humans–easy to edit, read, version and share in raw form.
AsciiDoc goes further by satisfying even the most advanced technical semantics and publishing requirements. AsciiDoc is a capable shorthand alternative to DocBook and can produce beautiful HTML 5, ePub and PDF output–even slides!
Follow the lead of authors. Drop the angled bracket and discover the zen of writing docs with AsciiDoc.
How many times have you wanted to start a new project in Java EE, but struggled with copying and pasting all the pieces together? Forge can take you from 0 to Java EE, Spring, GWT and more in few swift keystrokes.
But, are you confident enough to push your application to production right now? Will it deploy? Integrate all the components? Keep the fail whale at bay? Confidence comes from tests. Real tests written with Arquillian.
In this workshop, you'll learn how to achieve continuous development using Forge to automate mundane tasks and Arquillian to write real tests. Together, let's build an application, test it, and deploy it both locally and to the cloud! Let's learn to use tools to make us more confident developers.
How many times have you wanted to start a new project, but struggled with copying and pasting all the pieces together? Has the Maven archetype syntax left you with your eyes crossed? Everyone else is talking about Rails, Grails, and Roo, and you're left thinking, “I wish it were that easy for Java.” Well, it is!
Forge can take you from 0 to Java EE, Spring, GWT and more in few swift keystrokes. Forge helps streamline application development, eases the pain of setting up enterprise testing and integration, and utilizes the full power of JBoss AS 7 for development, testing, and deployment. You can even switch seamlessly between Forge and the Eclipse-based JBoss Developer Studio.
But, are you confident enough to push your application to production right now? Will it deploy? Integrate all the components? Keep the fail whale at bay? Confidence comes from tests. Real tests.
Discover how to use Arquillian to develop tests that execute inside a container, use BDD and ATDD for integration and acceptance tests that your stakeholders can grok and gain the confidence you need to continue developing, knowing your application will remain standing when faced with the real world.
In this workshop, you'll learn how to achieve continuous development using Forge to automate mundane tasks and Arquillian to write real tests. Together, let's build an application, test it, extend it, and deploy it both locally and to the cloud! Let's learn to use tools to make us more confident developers.
How many times have you wanted to start a new project in Java EE, but struggled with copying and pasting all the pieces together? Forge can take you from 0 to Java EE, Spring, GWT and more in few swift keystrokes.
But, are you confident enough to push your application to production right now? Will it deploy? Integrate all the components? Keep the fail whale at bay? Confidence comes from tests. Real tests written with Arquillian.
In this workshop, you'll learn how to achieve continuous development using Forge to automate mundane tasks and Arquillian to write real tests. Together, let's build an application, test it, and deploy it both locally and to the cloud! Let's learn to use tools to make us more confident developers.
How many times have you wanted to start a new project, but struggled with copying and pasting all the pieces together? Has the Maven archetype syntax left you with your eyes crossed? Everyone else is talking about Rails, Grails, and Roo, and you're left thinking, “I wish it were that easy for Java.” Well, it is!
Forge can take you from 0 to Java EE, Spring, GWT and more in few swift keystrokes. Forge helps streamline application development, eases the pain of setting up enterprise testing and integration, and utilizes the full power of JBoss AS 7 for development, testing, and deployment. You can even switch seamlessly between Forge and the Eclipse-based JBoss Developer Studio.
But, are you confident enough to push your application to production right now? Will it deploy? Integrate all the components? Keep the fail whale at bay? Confidence comes from tests. Real tests.
Discover how to use Arquillian to develop tests that execute inside a container, use BDD and ATDD for integration and acceptance tests that your stakeholders can grok and gain the confidence you need to continue developing, knowing your application will remain standing when faced with the real world.
In this workshop, you'll learn how to achieve continuous development using Forge to automate mundane tasks and Arquillian to write real tests. Together, let's build an application, test it, extend it, and deploy it both locally and to the cloud! Let's learn to use tools to make us more confident developers.
During the all day iOS hands-on tutorial, we will do soup to nuts iOS development. We will start with how to use XCode and build a universal application for iPhone and iPad using a variety of common APIs. We will finish up talking about and demoing how to prepare and deploy to the app store.
The app we build will allow us to experiment with a bunch of APIs including Core Data, Camera, and more.
Minimum:
- Mac
- Yosemite
- Xcode 6
- iOS 8.0 or greater
- Free Apple developer account
Preferred:
- Device (iPhone, iPod Touch or iPad)
- Paid Apple developer account
Please come prepared with the software downloaded and install as they are very large downloads.
Build your awareness of the basic concepts and value of Domain-Driven Design (DDD) in one day through group exercises, paired code walkthroughs, lecture and games.
Understand what DDD is and when and why it is valuable to software intensive organizations. Overview the basic principles and processes needed develop the useful sort of models, tie them into implementation and business analysis, and place them within a viable, realistic strategy.
Many people are drawn to the ideas of REST but aren't sure how to take the next steps. This workshop will help get you to a comfortable place by introducing the concepts and walking through a series of exercises designing REST APIs from a variety of domains.
We will break up into teams and tackle the various aspects of a solid, stable, evolvable REST API design. This will not be a tutorial in particular REST implementations (Jersey, Restlet, etc.). The ideas will transcend specific technologies although we will talk about some particular choices.
This class goes underneath design patterns to understand the principles behind the patterns. Patterns are a manifestation of 3 principles:
This session describes how to think in terms of the principles of patterns to be able to discover patterns in your designs and to create new quality designs when patterns aren’t present.
After presenting the fundamental lessons of design patterns the class proceeds into how patterns can be used both in an upfront manner or in an agile manner. The tutorial continues by comparing and contrasting seemingly different design methods:
This is the first in a new series on resource-oriented systems. The goal of the series is to provide practical guidance on the design and implementation of next generation systems that are flexible, extensible, high-performance and future-friendly. The talks are designed to work as arc, building upon each other, but they should also stand alone. The first topic is a guided walk through of building quality REST APIs.
We will focus on the architecture of the Web and how it can help us model and manipulate our important business concepts. We will discuss the role of stable identifiers, intentional representation design, hypermedia affordances and architectural consistency. The goal is not to be “RESTful”, the goal is to build systems that display the properties we require.
This talk will be accessible for people new to REST, but also different enough that those who have attended previous REST talks will learn new things.
This is the second in a new series on resource-oriented systems. The goal of the series is to provide practical guidance on the design and implementation of next generation systems that are flexible, extensible, high-performance and future-friendly. The talks are designed to work as arc, building upon each other, but they should also stand alone. This second talk is an introduction to the use of Semantic Web technologies to enable collaboration without coordination.
REST is a means to an end, but it is not a satisfactory end state. It usually pushes complexity to the client in ways that make data integration difficult across multiple sources. The W3C Semantic Web initiative introduces us to new technologies for linking resources and querying across them in powerful new ways. We will learn about the RDF model, what it brings to the table and how we can use it connect information regardless of where and how it is stored. We will use the SPARQL protocol and query language to ask powerful questions of arbitrary resources. We will also see how we can create new information just by asking for it.
In our industry, we have a problem. It's called the Software Problem. It is an embarrassing indictment of our capacity to deliver quality software on time and under budget. Beyond that, when we do deliver running code, it is often fragile and hard to extend. There are many reasons for this and many solutions. But one that does not get enough attention is how we approach information.
This is a theoretical discussion. You may not learn something you can use right away, but you may learn new ways of thinking about designing and building systems with an information-centric focus. We will discuss the roles of databases, services, software models, REST, the Web and the roles they all play together.
For a long while, we've built applications pretty much the same way. Regardless of the frameworks (or even languages and platforms) employed, we've packaged up our web application, deployed it to a server somewhere, and asked our users to point their web browser at it.
But now we're seeing a shift in not only how applications are deployed, but also in how they're consumed. The cost and hassle of setting up dedicated servers is driving more applications into the cloud. Meanwhile, our users are on-the-go more than ever, consuming applications from their mobile devices more often than a traditional desktop browser. And even the desktop user is expecting a more interactive experience than is offered by simple page-based HTML sites.
With this shift comes new programming models and frameworks. It also involves a shift in how we think about our application design. Standing up a simple HTML-based application is no longer good enough.
In this 2-part workshop, you'll get hands-on experience building a simple, yet complete next-generation application that can be deployed in the cloud, consumed from any device, and offers a rich experience for your users.
For maximum benefit, please come to this workshop with a laptop prepared. We won't allot any time for setting up your environment during the workshop.
Here's what you'll need: A laptop setup with…
For a long while, we've built applications pretty much the same way. Regardless of the frameworks (or even languages and platforms) employed, we've packaged up our web application, deployed it to a server somewhere, and asked our users to point their web browser at it.
But now we're seeing a shift in not only how applications are deployed, but also in how they're consumed. The cost and hassle of setting up dedicated servers is driving more applications into the cloud. Meanwhile, our users are on-the-go more than ever, consuming applications from their mobile devices more often than a traditional desktop browser. And even the desktop user is expecting a more interactive experience than is offered by simple page-based HTML sites.
With this shift comes new programming models and frameworks. It also involves a shift in how we think about our application design. Standing up a simple HTML-based application is no longer good enough.
In this 2-part workshop, you'll get hands-on experience building a simple, yet complete next-generation application that can be deployed in the cloud, consumed from any device, and offers a rich experience for your users.
For maximum benefit, please come to this workshop with a laptop prepared. We won't allot any time for setting up your environment during the workshop.
Here's what you'll need: A laptop setup with…
This workshop will bring you up to speed on the specifics of the Groovy programming language. We'll touch on most of the major features of the language, from collections and closures to builders, AST transformations, and metaprogramming. Specific examples will cover topics from Groovy itself and will be supported by unit and integration tests and built using Gradle.
Featured topics will include: collections, closures, operator overloading, scripts and classes, unit and integration testing, AST transformations, parsing and building both XML and JSON, and working with SQL. If time is available, other projects from the Groovy ecosystem, like Gradle, Spock, and GPars, will be included.
A minimum comfort level with Java is assumed. Some exposure to Groovy would be helpful but not required.
The workshop requirements are pretty minimal. You'll need:
The Groovy downloads are found at the Groovy homepage, http://groovy.codehaus.org .
Groovy has a Windows installer, or you can just download the zip file, unzip it, set a GROOVY_HOME environment variable to point to the unzipped directory, and add the “bin” subdirectory to your path.
If you are on a Mac or Unix flavor (or Windows with cygwin), consider GVM, located at http://gvmtool.net . That works for both Groovy and Grails, as well as a few other projects.
No IDE is necessary, but if you prefer to go that way, the Groovy plugin for Eclipse is fine. If you want to use Grails as well, consider the Groovy & Grails Tool Suite, found at http://grails.org/products/ggts . IntelliJ IDEA is great and you're welcome to use it as an alternative.
Git is a version control system you may have been hearing a bit about lately. But simply hearing more about it may not be enough to convince you of its value. Getting hands on experience is what really counts. In this workshop, you'll bring your Windows, Mac or Linux laptop and walk through downloading, installing, and using Git in a collaborative fashion.
The workshop style of this class will allow you to observe and discover the value of this new version control tool first hand. You'll be cloning, creating, commiting, and pushing repositories by the conclusion of this session.
PreReq:
Basic knowledge of a version control system. Subversion knowledge is a plus, but not imperative.
With Java supporting lambda expressions, we have nothing to stop us from creating functional style of code for our day to day applications. We're 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'd 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 we're used to and the benefits it offers.
Please bring your laptops. Install the compilers for the language you'd like to use. If you'd like to use Java 8, please make sure you have the right version (Java 8 with lambda expression) installed. Also make sure you have your favorite IDE on the machine you bring along.
Get your skills up to speed for JavaScript, the oft-misunderstood language of the web, in this full day workshop. We'll start from the very basics and learn the ins-and-outs of JavaScript. We'll look at the (many) quirks in JavaScript, and work through advanced features that make this language so powerful.
We'll talk about JavaScript design patterns, frameworks, and conventions. We'll end the day with and advanced, hands-on session, on functional programming in JavaScript. Come with an open-mind and ready to dig into code!
This workshop requires a laptop, and assumes the attendee has ZERO knowledge of JavaScript. We'll break down your bad habits, and build upon known patterns and best practices to raise your JavaScript-fu.
You may have noticed today's web applications involve more than a few lines of JavaScript. You've probably also figured out JavaScript lacks certain…features…that make writing non-trivial applications more challenging. How do we resolve this conundrum? Luckily for us, we can leverage libraries like Backbone add some structure to our code. Backbone brings the concepts of the model view controller pattern we've applied to the server for years to the browser.
In this workshop, we'll introduce the idea of asynchronous user interfaces and show how Backbone helps us write that style of application. We'll work our way up from the bottom building a simple application along the way. We'll create models, we'll use a templating library (or two) and we'll also explore Underscore - a JavaScript utility belt you can use right now today without committing to building MVC style web applications.
If you're struggling to manage an increasing amount of JavaScript or you want to build more responsive web applications, this workshop can help!
For this workshop you should have:
Optionally, you can have Git installed but it isn't required. Before the workshop, take a minute to setup the code somewhere on your laptop. The code is on github:
https://github.com/ntschutta/backbone_workshop
You can clone the repo from there or simply download a zip if you prefer. That's it! See you in Florida!
You may have noticed today's web applications involve more than a few lines of JavaScript. You've probably also figured out JavaScript lacks certain…features…that make writing non-trivial applications more challenging. How do we resolve this conundrum? Luckily for us, we can leverage libraries like Backbone add some structure to our code. Backbone brings the concepts of the model view controller pattern we've applied to the server for years to the browser.
In this workshop, we'll introduce the idea of asynchronous user interfaces and show how Backbone helps us write that style of application. We'll work our way up from the bottom building a simple application along the way. We'll create models, we'll use a templating library (or two) and we'll also explore Underscore - a JavaScript utility belt you can use right now today without committing to building MVC style web applications.
If you're struggling to manage an increasing amount of JavaScript or you want to build more responsive web applications, this workshop can help!
For this workshop you should have:
Optionally, you can have Git installed but it isn't required. Before the workshop, take a minute to setup the code somewhere on your laptop. The code is on github:
https://github.com/ntschutta/backbone_workshop
You can clone the repo from there or simply download a zip if you prefer. That's it! See you in Florida!
The word just came down from the VP - you need a mobile app and you need it yesterday. Wait, you've never built a mobile app…it's pretty much the same thing as you've built before just smaller right? Wrong. The mobile experience is different and far less forgiving. How do you design an application for touch? How does that differ from a mouse? Should you build a mobile app or a mobile web site? This workshop will get you started on designing for a new, and exciting, platform. Whether that means iPhone, Android, Windows Phone or something else, you need a plan, this talk will help.
We'll look at some popular web sites discussing what we would do differently in a mobile context and then take a look at the actual mobile experience to see what other designers actually did. Using paper, we'll work though a design or two of our own. We'll wrap up discussing various methods of creating a mobile app - should we use the web or build something native? What about shell apps? While we might not have all the answers, at the end of this workshop you'll know what questions to ask when thinking through your own situation.
This workshop is more analog than digital - a laptop is not required. A pen or pencil though, is!
The word just came down from the VP - you need a mobile app and you need it yesterday. Wait, you've never built a mobile app…it's pretty much the same thing as you've built before just smaller right? Wrong. The mobile experience is different and far less forgiving. How do you design an application for touch? How does that differ from a mouse? Should you build a mobile app or a mobile web site? This workshop will get you started on designing for a new, and exciting, platform. Whether that means iPhone, Android, Windows Phone or something else, you need a plan, this talk will help.
We'll look at some popular web sites discussing what we would do differently in a mobile context and then take a look at the actual mobile experience to see what other designers actually did. Using paper, we'll work though a design or two of our own. We'll wrap up discussing various methods of creating a mobile app - should we use the web or build something native? What about shell apps? While we might not have all the answers, at the end of this workshop you'll know what questions to ask when thinking through your own situation.
This workshop is more analog than digital - a laptop is not required. A pen or pencil though, is!
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.
Gradle is a compelling new build tool that incorporates the lessons learned from a decade of Ant and Maven. More than just a compromise between declarative and imperative build formats, or between convention and configuration, Gradle is a sophisticated software development platform that simple builds easy and complex, highly automated continuous software delivery pipelines possible to build. Using its extensible APIs and expressive DSL, you're equipped to build your next build.
Bring your laptop to this session for the following:
Gradle is a compelling new build tool that incorporates the lessons learned from a decade of Ant and Maven. More than just a compromise between declarative and imperative build formats, or between convention and configuration, Gradle is a sophisticated software development platform that simple builds easy and complex, highly automated continuous software delivery pipelines possible to build. Using its extensible APIs and expressive DSL, you're equipped to build your next build.
Bring your laptop to this session for the following:
Things have changed considerably in the last 15 years for software development. In every area of the organization – development, QA, management and the business side. Between design patterns, TDD, ATDD, refactoring, emergent design, eXtreme Programming, Agile, Scrum, Lean and Kanban, new methods have dramatically enlarged our knowledge about how to develop software.
While some still claim software development is complex and we should be using black-box frameworks, this talk presents the idea that we now know enough to dramatically increase the productivity of the industry. The issue is no longer not knowing how to develop great software. The challenge is getting people to incorporate known practices into their development methods. Getting behavioral change is much more complicated than understanding what the change needs to be.
This talk introduces three concepts that we can use to help us take software development to the next level:
• The Technology Gap – the difference between what we know and what we do
• Trim Tabs – the concept that some activities have more than leveraged impact but change the environment within which we work
• The Pickup Sticks Model - for deciding the order of introducing new concepts
While there is a creative aspect to software development, there is a science to it as well. We must embrace this dual nature and increase our capabilities. The time is now.
Spend a day learning how to develop native apps on the world's most popular smartphone platform. You'll get hands on experience developing a native Android app that will use most of the major components available in the framework.
The workshop will be taught using Android Studio with the new Gradle build system.
Use Android Activites to create the User Interface. Learn how to run background services. Create broadcast receivers to react to changes in the phones state. You'll even learn how to interact with the location services and display Google maps.
We'll take a deep dive into the details. You'll write code to interact with Android's built-in SQLite database. You'll add logging to your app and you'll even learn how to do unit testing in the Android environment.
Leave the class with hands-on skills and a working application that will be ready to publish to the Android Market.
Don't miss out on this excellent opportunity. Register now!
Please install Android Studio before arriving at the workshop.
We'll be using Android Studio for this workshop.
Java (if you don't have it)
http://www.oracle.com/technetwork/java/javase/downloads/java-archive-downloads-javase6-419409.html#jdk-6u45-oth-JPR
Android Studio
The website has version 0.8.14 - which can be upgraded to 1.0 once you install it.
http://developer.android.com/sdk/installing/studio.html
Android SDK
Note: The SDK is a separate download from the Android Studio Bundle
Click on the link for “GET THE SDK FOR AN EXISTING IDE” to download the SDK
http://developer.android.com/sdk/index.html
Labs
Download all files
http://goo.gl/RjItQn
To make the best use of our time during the one day tutorial, it is very helpful if you can have the IDE installed
and working by the time class starts.
Also, make sure that you have installed the most recent versions of the following components using the SDK manager:
Tools
Android SDK Tool
Android SDK Platform-tools
Android SDK Build-tools
Android 4.4.2 (API 19)
Documentation for Android SDK
SDK Platform
Intel x86 Atom System Image
Source for Android SDK
Extras
Android Support Repository
Android Support Library
Google Repository
Intel x86 Emulator Accelerator
Try to complete the first lab in the file “labs/Lab02-1.pdf”
Note: The Android labs must be run on an emulator or a real device. The most time consuming part of the workshop is getting the emulator running. Try to set up a working emulator before arriving.
Please feel free to contact me with any setup questions:
Monolithic applications are difficult to understand, maintain, and extend with new features and functionality. Modularity helps achieve these goals. Unfortunately, few applications have been designed with modularity in mind. In this workshop, we take a deep dive into modularity. We'll start by briefly examining the benefits of a modular architecture and exploring several patterns that help us design modular software. Then we'll launch into several exercises where we take an existing monolithic software system and refactor it to a modular architecture.
Along the way, we'll examine useful tools that help us along the journey and will demonstrate the benefits of our new architecture.
JavaScript has a mixed heritage: OO and Functional. To date, us developers have focused on the OO side of JavaScript and not much mind-share has been given to the other, more powerful side. In this session we'll explore how to use the power of functional Javascript.
JavaScript has elements of two distinct programming languages: Self and Scheme. These two languages are very different - and some of JavaScript's weirdness is due to this mixing of very different language designs. The conceptual models are also very different between Self and Scheme - one is a prototypical object based language, while the other is a functional language. In this session, we'll discuss the elements of how the Scheme functional programming language manifest in JavaScript. We're going to explore how you can write JavaScript in a more elegant and powerful way by applying functional concepts.
So you think you've picked up enough JavaScript to be dangerous, but feel like the whole prototypical language thing is still a mystery. In this session, we'll go from basic JavaScript to advanced JavaScript. We'll discuss and code modular JavaScript with CommonJS. We'll look into the details of a prototype language and discuss things like parasitic inheritance. We'll also look at JavaScript libraries that will help you get the most out of JavaScript - not jQuery, but a library like UnderscoreJS and SugarJS.
This is a fast paced session meant to bring you up to speed with the latest and greatest JavaScript techniques and tools. Whether you're building client side JavaScript with HTML5 or Appcelerator Titanium, or server-side JavaScript with node.js, you'll come away with knowledge and patterns for how the pro's use JavaScript for building real apps.
We've come a long way down the JavaScript road. Gone are the days of 'just hack it' for the web - architecting even a small project in JavaScript can be a challenge. Thankfully, there are several frameworks to help you; the most popular currently is Backbone.js.
Before you start using a framework in JavaScript, you will want to understand the techniques expert JavaScript programmers use to build them. In this session, we'll dive into design patterns in JavaScript, and do live coding so you can see these patterns applied. Even if you're not using a framework, you can use these design patterns to make your code more maintainabile, elegant, and concise.
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.
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.
Ever wish you could use your JavaScript-foo to build a NATIVE mobile app? Wish there was an open-source platform that would let you build awesome cross-platform mobile apps? Come to this session and learn about Titanium, an open-source, JavaScript based platform for creating native mobile apps.
Titanium is an open-source development tool for producing cross-platform mobile applications by Appcelerator. Using Titanium, you develop your mobile application using Javascript coded against the Titanium API's. The Titanium platform invokes their builder to take your Javascript and build a native application for iOS and Android.
This session will walk you through the details of building great apps for the Android and iOS platforms. We'll talk about Titanium development, its ecosystem, and architecture. We'll spend time looking at lots of code - we'll build an app, in fact, while we discuss and explore the framework. We'll also spend some time discussing best practices, what to expect when developing against it, and the limits of this type of development.
There's a bevy of options for developing mobile apps. If you're looking at cross-platform solutions, there's a multitude of options to choose from. In this session we'll explore the three basic categories for developing mobile apps: native, cross-platform-to-native, and mobile web. We'll discuss the sweet spot for each of these three approaches and the benefits and drawbacks of each. Technologies discussed include Android, iOS, HTML5/CSS3, Phonegap, Titanium, and jQuery Mobile.
There's a bevy of options for developing mobile apps. If you're looking at cross-platform solutions, there's a multitude of options to choose from. In this session we'll explore the three basic categories for developing mobile apps: native, cross-platform-to-native, and mobile web. We'll discuss the sweet spot for each of these three approaches and the benefits and drawbacks of each. Technologies discussed include Android, iOS, HTML5/CSS3, Phonegap, Titanium, and jQuery Mobile.
Languages offer a lot more than syntax and compilers. They often have supporting libraries and special facilities that set them apart from other languages. Some languages offer special compiler support for a particular construct, like tail call optimization, for example. Others provide interesting library support or capabilities.
In this presentation we will dive into 12 cool things we can do with different languages on the JVM, things that are either impossible or hard to do in Java, but are quite easy and useful to realize in other popular languages on the JVM. If mixing these languages is an option on your projects, you'll have dozen more reasons after this presentation.
Your application has state. Every action that every user takes changes this state. Yet, so much time and effort is spent on trying to persist something that is so transient. What if you didn't need to bother with the slowness of “persistence”? What if you could free the core of your application from I/O?
I will look at a couple of patterns that question one of the basic assumptions of today's architectures - that persistence of state is central to your application.
Mobile devices are gaining popularity but the diversity of these devices poses a challenge for development. HTML 5 promises to bring a consistent API to program the client side for both desktop and diverse mobile devices. One additional challenge with mobile devices is network connectivity, or the lack of it. Mobile devices are often taken into remote areas with low or no connectivity. While a native app can run on the device anytime, a web based application by default depends on having connectivity, unless of course we use the offline capabilities of HTML 5. Come to this presentation to learn how to create applications that can switch seamlessly between connected and offline mode.
Learn about offline options, configurations, local storage and how to program all of that, in this highly interactive, live coding session.
Getting software released to 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.
In this workshop we take the unique approach of moving from release back through testing to development practices, analyzing at each stage how to improve collaboration and increase feedback so as to make the delivery process as fast and efficient as possible. 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. We spend the first half of the workshop introducing this pattern, and discussing how to incrementally automate the build, test and deployment process, culminating in continuous deployment.
Getting software released to 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. This workshop focuses on the Deployment Pipeline concept from Continuous Delivery.
In this workshop I move from release back through testing to development practices, analyzing at each stage how to improve collaboration and increase feedback so as to make the delivery process as fast and efficient as possible. 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 spend the first half of the workshop introducing this pattern, and discussing how to incrementally automate the build, test and deployment process, culminating in continuous deployment.
Getting software released to 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.
In the second half of the workshop, we introduce agile infrastructure, including the use of Puppet to automate the management of testing and production environments. We'll discuss automating data management, including migrations. Development practices that enable incremental development and delivery will be covered at length, including a discussion of why branching is inimical to continuous delivery, and how practices such as branch by abstraction and componentization provide superior alternatives that enable large and distributed teams to deliver incrementally.
Getting software released to 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.
In the second half of the workshop, we introduce agile infrastructure, including the use of Puppet to automate the management of testing and production environments. We'll discuss automating data management, including migrations. Development practices that enable incremental development and delivery will be covered at length, including a discussion of why branching is inimical to continuous delivery, and how practices such as branch by abstraction and componentization provide superior alternatives that enable large and distributed teams to deliver incrementally.
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.
We've been told to keep things simple. It turns out, that's easily said than done. Creating something simple is, well, not really that simple. If simple was sitting next to us, would we even recognize it? Is my design simple, is yours simple? How can we tell?
That's a simple question, but the answer to it is… well come to this talk to find out.
No business objectives will be accomplished during this talk.
The purpose of “Pure Fun” is to participate in the sheer joy of using computers. Each talk is an individual performance where you might see or participate in some of the following:
Clojure is a powerful dynamic language that compiles to many target environments, including the JVM, JavaScript, and the CLR. In this talk, you will learn how to think in Clojure, and why you should want to.
Clojure encourages functional style with persistent data structures, a rich library of pure functions, and powerful processing support via the seq and reducer abstractions. Clojure implements a reference model for state, where references represent atomic successions of values, and change is encapsulated by value and reference constructors. This reference model is more substantive and suitable to application development than individual techniques such as Software Transactional Memory (STM) or actors.
The most important single principle behind Clojure is simplicity. Clojure's abstractions are simple and orthogonal. A la carte polymorphism, careful support for names and namespaces, the reference succession model, and a wide selection of small, composable protocols make Clojure programming swift, surgical and accurate.
Clojure's expressiveness does not mean that you have to compromise on power. It is an explicit design goal of Clojure to provide access to the power of the underlying platform, and for programmers never to have to “drop down” to the platform level for performance-sensitive work.
Clojure is a powerful dynamic language that compiles to many target environments, including the JVM, JavaScript, and the CLR. In this talk, you will learn how to think in Clojure, and why you should want to.
Clojure encourages functional style with persistent data structures, a rich library of pure functions, and powerful processing support via the seq and reducer abstractions. Clojure implements a reference model for state, where references represent atomic successions of values, and change is encapsulated by value and reference constructors. This reference model is more substantive and suitable to application development than individual techniques such as Software Transactional Memory (STM) or actors.
The most important single principle behind Clojure is simplicity. Clojure's abstractions are simple and orthogonal. A la carte polymorphism, careful support for names and namespaces, the reference succession model, and a wide selection of small, composable protocols make Clojure programming swift, surgical and accurate.
Clojure's expressiveness does not mean that you have to compromise on power. It is an explicit design goal of Clojure to provide access to the power of the underlying platform, and for programmers never to have to “drop down” to the platform level for performance-sensitive work.
After over 10 years and several significant releases, Spring has gone a long way from challenging the then-current Java standards to becoming the de facto enterprise standard itself. Although the Spring programming model continues to evolve, it still maintains backward compatibility with many of its earlier features and paradigms. Consequently, there's often more than one way to do anything in Spring. How do you know which way is the right way?
In this 2-part workshop, you'll get a hands-on feel for the current best approaches in Spring development. We'll see how to take advantage of some of the latest tricks Spring has to offer to build an application with minimal boilerplate and none of the cruft that is often carried around in Spring applications.
For maximum benefit, please come to this workshop with a laptop prepared. We won't allot any time for setting up your environment during the workshop.
Here's what you'll need: A laptop setup with…
After over 10 years and several significant releases, Spring has gone a long way from challenging the then-current Java standards to becoming the de facto enterprise standard itself. Although the Spring programming model continues to evolve, it still maintains backward compatibility with many of its earlier features and paradigms. Consequently, there's often more than one way to do anything in Spring. How do you know which way is the right way?
In this 2-part workshop, you'll get a hands-on feel for the current best approaches in Spring development. We'll see how to take advantage of some of the latest tricks Spring has to offer to build an application with minimal boilerplate and none of the cruft that is often carried around in Spring applications.
For maximum benefit, please come to this workshop with a laptop prepared. We won't allot any time for setting up your environment during the workshop.
Here's what you'll need: A laptop setup with…
This talk will explore the area of real-time data ingest into Hadoop and present the architectural trade-offs as well as demonstrate alternative implementations that strike the appropriate balance across the following common challenges:
Today, application developers devote roughly 80% of their code to persisting roughly 20% of the total data flowing through the applications. That means two things:
In this talk, we will demonstrate how capturing all event data could dramatically simplify data collection and management within the enterprise.
In a recent interview with Dr. Dobb's, the pioneer of object-orientation and co-designer of Smalltalk, Alan Kay, said: “The Actor model retained more of what I thought were the good features of the object idea.” Actors are a powerful concept, which greatly reduce the complexity of distributed, concurrent systems. Yet, the Actor model is rarely used today, and when it is used, is often relegated to a technical, infrastructural concern. What would it be like to leverage Actors as the central theme in a carefully crafted domain-driven designed model, along with a memory-based grid/fabric, NoSql storage, and CQRS? Discover the incredible and liberating simplicity with the new open-source Actor model grid that supports interoperability between Java and .NET systems. You will see how highly concurrent and event-driven systems can be created while incurring minimal architectural and other technical debt in your projects. Assign junior and mid-level developers finite tasks that address strategic business logic without the need to understand complex\thread-based or messaging infrastructure.
This talk takes you through the theory of Actors and how the Actor model supports lock-free concurrency, distributed-computing, low latency, and high throughput. Some of the topics covered include: Actor theory, using Actors, mailboxes, share-nothing, creating Actors as first-class domain concepts, grid/fabric-based low-latency access, NoSQL persistence, as well as Java and .NET platform interoperability.
This workshop leads you through the central concepts of Domain-Driven Design (DDD) and allows attendees to work through software modeling problems that address integrating new Core Domains with legacy systems using an event-driven architecture.
Learn hands-on to use DDD strategic design patterns to model in a financial trading legacy application, and to model and develop a new Core Domain that supports algorithmic trading. Again, using hands-on modeling exercises you will employ DDD tactical modeling to create a new algo-trading Core Domain that integrates with the legacy trading system.
This workshop leads you through the central concepts of Domain-Driven Design (DDD) and allows attendees to work through software modeling problems that address integrating new Core Domains with legacy systems using an event-driven architecture.
Learn hands-on to use DDD strategic design patterns to model in a financial trading legacy application, and to model and develop a new Core Domain that supports algorithmic trading. Again, using hands-on modeling exercises you will employ DDD tactical modeling to create a new algo-trading Core Domain that integrates with the legacy trading system.
So you've gotten a handle on Git and know how to use it for everyday development tasks like committing code and pushing and pulling changes with the rest of the team. But do you really know how it works under the covers? In this brief demonstration, we'll commit a file to a brand new repository without ever touching the git add or git commit commands, and in the process learn some critical Git internals that every power user should know.
We'll also take a look at some advanced history and undo commands like reflog and reset, and how to rewrite past mistakes with interactive rebase. Bring your questions and Git challenges for 90 minutes of advanced Git fun!
Most developers think of Git and GitHub as two sides of the same coin, but all too often our attention is focused on the Git side alone, and not on the capabilities of Planet Earth's most-used Git hosting service. More than two million developers have already joined the site that offers amazing features like pull requests, wikis, project pages, integrated web site hosting, issue tracking, metric visualizations, permission controls, and easy integration with third-party services.
Come to this talk to learn how to make better use of GitHub through the site's commonplace and advanced features alike.
The Java EE 7 platform focuses on Boosting Productivity and Embracing HTML5. JAX-RS 2 adds a new Client API to invoke the RESTful endpoints. JMS 2 has undergone a complete overhaul to align with improvements in the Java language. Long awaited Batch Processing API and Concurrency Utilities are now added to make the platform richer. A new API to build WebSocket driven applications is added. JSON parsing and generation is now included in the platform itself. JavaServer Faces has added
support for HTML5. There are several other improvements in this latest version of the platform. Together these APIs will allow you to be more productive by simplifying enterprise development.
This hands-on lab will provide a comprehensive introduction to the updated Java EE 7 platform using WildFly. The attendees will learn the design patterns of building an application using Java EE 7.
Please bring a laptop, download and install the following software for the lab:
The Java EE 7 platform focuses on Boosting Productivity and Embracing HTML5. JAX-RS 2 adds a new Client API to invoke the RESTful endpoints. JMS 2 has undergone a complete overhaul to align with improvements in the Java language. Long awaited Batch Processing API and Concurrency Utilities are now added to make the platform richer. A new API to build WebSocket driven applications is added. JSON parsing and generation is now included in the platform itself. JavaServer Faces has added
support for HTML5. There are several other improvements in this latest version of the platform. Together these APIs will allow you to be more productive by simplifying enterprise development.
This hands-on lab will provide a comprehensive introduction to the updated Java EE 7 platform using WildFly. The attendees will learn the design patterns of building an application using Java EE 7.
Please bring a laptop, download and install the following software for the lab:
The Java EE 7 platform focuses on Productivity and HTML5. JAX-RS 2 adds a new Client API to invoke the RESTful endpoints, allows asynchronous client/server, and server-side content negotiation. JMS 2 is undergoing a complete overhaul to align with improvements in the Java language. Long awaited Batch Processing API and Concurrency are also getting added to build applications using capabilities of the platform itself. Together these APIs will allow you to be more productive by simplifying enterprise development.
WebSocket attempts to solve the issues and limitations of HTTP for real-time communication. A new API is getting added to build WebSocket driven applications. Processing JSON structures is inherent in any HTML5 applications and a new API to parse and generate JSON is being added to the platform. JavaServer Faces will add support for creating reusable flows and HTML5-friendly markup. There are several other improvements coming in this latest version of the platform.
The Java EE 7 platform is scheduled to release in Q2 2013. Most of the implementations are already integrated in GlassFish. This talk will provide a code-intensive introduction to the updated Java EE 7 platform. Several live demos will be shown during the talk. Don't miss out on this session to learn all about how to leverage the new and exciting standards in building your next enterprise application.
The Java EE 7 platform focuses on Productivity and HTML5. JAX-RS 2 adds a new Client API to invoke the RESTful endpoints, allows asynchronous client/server, and server-side content negotiation. JMS 2 is undergoing a complete overhaul to align with improvements in the Java language. Long awaited Batch Processing API and Concurrency are also getting added to build applications using capabilities of the platform itself. Together these APIs will allow you to be more productive by simplifying enterprise development.
WebSocket attempts to solve the issues and limitations of HTTP for real-time communication. A new API is getting added to build WebSocket driven applications. Processing JSON structures is inherent in any HTML5 applications and a new API to parse and generate JSON is being added to the platform. JavaServer Faces will add support for creating reusable flows and HTML5-friendly markup. There are several other improvements coming in this latest version of the platform.
The Java EE 7 platform is scheduled to release in Q2 2013. Most of the implementations are already integrated in GlassFish. This talk will provide a code-intensive introduction to the updated Java EE 7 platform. Several live demos will be shown during the talk. Don't miss out on this session to learn all about how to leverage the new and exciting standards in building your next enterprise application.
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.
The session will cover various GC tuning techniques, in particular focus on tuning large scale JVM deployments. Come to this session to learn about GC tuning recipe that can give you the best configuration for latency sensitive applications. While predominantly most enterprise class Java workloads can fit into a scaled-out set of JVM instances of less than 4GB JVM heap, there are workloads in the in memory database space that require fairly large JVMs. In this session we take a deep dive into the issues and the optimal tuning configurations for tuning large JVMs in the range of 4GB to 128GB.
In this session the GC tuning recipe shared is a refinement from 15 years of GC engagements and an adaptation in recent years for tuning some of the largest JVMs in the industry using plain HotSpot and CMS GC policy. You should be able to walk away with the ability to commence a decent GC tuning exercise on your own. The session does summarize the techniques and the necessary JVM options needed to accomplish this task. Naturally when tuning large scale JVM platforms, the underlying hardware tuning cannot be ignored, hence the session will take detour from the traditional GC tuning talks out there and dive into how you optimally size a platform for enhanced memory consumption.
This session shares many of the production proven methods of running Java on vSphere. Covering how to size JVMs, and VMs for large scale deployments. The session will have a special section on GC tuning and show how a wide range of JVMs can be tuned using a GC recipe developed over the past 15 years of actual field experience in tuning JVMs.
Three key trends and associated tuning techniques are discussed in this session. The key trends are: Consolidation, Elasticity and Flexibility, and Performance
Consolidation
Many of our customers find that their middleware deployments have proliferated and are becoming an administrative challenge associated with higher costs. We see a trend across customers who look to virtualization as a way of reducing the number of server instances. At the same time, customers are taking the consolidation opportunity to rationalize the number of middleware components needed to service a particular load. Middleware components most commonly run within a Java Virtual Machine (JVM) with an observed scale of 100 to 1000s of JVM instances and provide many opportunities for JVM instance consolidation. Hence, middleware virtualization provides an opportunity to consolidate twice – once to consolidate server instances, and, secondly, to consolidate JVM instances. This trend is far-reaching, because every IT shop on the planet is considering the cost savings of consolidation.
One customer in the hospitality sector went through the process of consolidating their server footprint and at the same time consolidated many smaller JVMs that were less than 1GB heap. They consolidated many of these smaller 1GB JVMs into 2 categories, those that were 4GB, and others that were 6GB. They performed the consolidation in such manner that the net total amount of RAM available to the application was equal to the original amount of RAM, but with fewer JVM instances. They did all of this while improving performance and maintaining good SLAs. They also reduced the cost of administration considerably due to the reduced number of JVM instances they had to manage, and refined environment that helped easily achieve SLA.
Another customer, in the insurance industry, was able to achieve the same as the above customer, but additionally was able to over-commit CPU in development and QA environments in order to save on third party software license costs.
On the other hand, sometimes we come across customers that have a legitimate business requirement to maintain one JVM for an application, and/or one JVM per a line of business. In these cases, you cannot really consolidate the JVM instances, as that would cause intermixing of the lifecycle of one application from one line of business with another. However, while such customers don’t benefit from eliminating additional JVM instances through JVM consolidation, they do benefit from more fully utilizing the available compute resource on the server hardware, that otherwise would have been underutilized in a non virtualized environment
Elasticity and Flexibility
It is increasingly common to find applications with seasonal demands. For example, many of our customers run various marketing campaigns that drive seasonal traffic towards their application. With VMware, you can handle this kind of traffic burst, by automatically provisioning new virtual machines and middleware components when needed, and then automatically tear down these VMs when the load subsides.
In addition, the ability to change updating/patching hardware without causing outage is paramount for middleware that supports the cloud era scale and uptime. VMware VMotion gives you the ability to move VMs around without needing to stop applicators and or the VM. This flexibility alone makes virtualization of middleware worthwhile when managing large-scale middleware deployments. One customer in the financial space, handling millions of transactions per day, used VMotion quite often to schedule their hardware upgrades without any time downtime. What otherwise would be a costly scheduled downtime to their business.
Performance
Customers often report improved middleware platform performance when virtualizing. Performance improvements are partly due to the updated hardware that customers will typically refresh during a virtualization project. There is also some performance improvement due to the robust VMware hypervisor. A recent customer that reported a great level of performance provided the following testimony
“With our OrderExpress project we upgraded our Middleware Services, Commerce, Portal, WCM, Service Layer, DB2 Database; migrated from AIX to Linux; virtualized on VMware; moved the application into a three-tier DMZ; increased our transactions by over 150 percent; and added significant new capabilities that greatly improved the customer experience. Changing such a wide range of technology components at once was a huge challenge. However using VMware vSphere and additional architectural changes we were successful in improving performance by over 300 percent; lowered costs in the millions; improved security, availability, and scalability; and how we plan to continue evolving this application to maintain greater than 30 percent yearly growth.”
– Jeff Battisti, Senior Enterprise Architect at Cardinal Health
In this session, I will show some actual JVM and VM sizes for middleware components both small and large JVMs. Will also detail out GC tuning recipe that I have developed over the years,that has been shown to handle JVM heap sizes form 4GB to 88GB+, and higher. Of course the introduction of in-memory databases has driven the trend to have these larger JVMs and hence why we will discuss what is the best way to tune the JVM, VM, and the hardware platform they are deployed on.
I see the sizing question as the most commonly asked question with our customer base,and as a result I plan to focus on it during the session.
Agile methods depend on effective cross-functional teams. We’ve heard many Agile success stories…at the team level. But what happens when a product can’t be delivered by one team? What do you do when the “team” that’s needed to work on a particular product is 20 people? Or 20 teams? One response is to create a coordinating role, decompose work, or add layers of hierarchy. Those solutions introduce overhead and often slow down decision making. There are other options to link teams, and ensure communication and integration across many teams. There are no simple answers. But there are design principles for defining workable arrangements when the product is bigger than a handful of agile teams.
In this talk, I'll cover principles and practices and explain how they work together to address coordination, integration, and technical integrity.
“Self-organizing team” may be the most over-used, mis-understood, vague, and mis-leading term of the decade. So what is a self-organizing team? How are self-organizing teams different from other teams? How can managers and team members get the self-organizing mojo going? What are the challenges that self-organizing teams face?
In this workshop, we'll explore all these questions and get beyond the buzzword.
No matter what lifecycle or process your project uses, the participants on your project have some strongly-held beliefs. “The iteration must be two weeks long.” “No, the iteration must be three weeks long.” “You must ask these three questions at the standup.” “No, you must sit down at the standup.” “You must only measure velocity.” “No, you must only measure cumulative flow.” “You must never use waterfall.” “You must always use waterfall.”
How do you know the project management practices are working for you? When is it time to reexamine those beliefs? Such questions are hard. But, they are necessary to ask and answer, if you want to keep improving and keep innovating.
There are no best practices. There are practices that help projects. It’s good to know when your project or program has outgrown the practices it uses. In this session, we will seek the patterns that help us realize when a project has outgrown its training wheels.
You don’t have to be a social butterfly to succeed with social networking. Whether you are searching for a new job, marketing your business, or recruiting for a candidate, you need to know how to network. But as a professional, you want to network with authenticity. Authentic networking means making a warm connection–having a reason to connect. You need to build your reputation to network.
You start to build your reputation at work. You extend your reputation on social networking sites, mailing lists, and with online participation.
During this session, you will analyze your current online network and your current online participation. You will focus on using social networking sites, mailing lists, and other online email and writing to build your reputation. You’ll leave with an action plan and a budding network to help you with that action plan.
We all know the benefits of Service Oriented Architecture (SOA), but it’s not without it’s pitfalls. If you’re providing an API, wether for internal or external use, testing it is essential. Even if you only consume other APIs, testing them to make sure they didn’t change or break can be critical. RSpec is Behavior Driven Development (BDD) testing framework. Although RSpec was born out of the Ruby community, it’s not limited to testing Ruby APIs! It turns out it’s a great way to test ALL your APIs, regardless of language.
This session will cover what RSpec is, how to install it and how to start writing tests. What good are tests if you don’t run them? Not much. We’ll also cover how to integrate your RSpec tests with Jenkins, so you can run it as part of your builds.
Continuous Delivery, DevOps, Cloud and Scalability are all the rage. At the heart of all of those is the ability to reliably recreate infrastructure on demand.
In this session, we'll learn to work with Infrastructure as Code. We'll use puppet to automate infrastructure in EC2 for a sample application that uses Apache, Tomcat, MySQL and MongoDB.
Continuous Delivery, DevOps, Cloud and Scalability are all the rage. At the heart of all of those is the ability to reliably recreate infrastructure on demand.
In this session, we'll learn to work with Infrastructure as Code. We'll use puppet to automate infrastructure in EC2 for a sample application that uses Apache, Tomcat, MySQL and MongoDB.
Although Agile has proven to provide incredible benefits in software development and delivery, it is not foolproof, nor a “Silver Bullet.” Plenty of factors need to be considered before attempting this highly disciplined approach.
Learn from the mistakes other organizations have made and discover which pitfalls to avoid to ensure that your first attempt at applying an Agile approach will be met with a successful outcome. This hour-long web seminar will explore these areas and provide clear steps your team and organization should consider to provide a clear set of tools to maximize the opportunity for best results possible.
Some come to Agile assuming it involves less discipline than their traditional methods, but this is a misperception. Today, the need for discipline in software development is greater than it ever was. Agile answers that need, arriving at discipline through the Team. Agile Teams must collaborate to develop strong discipline in both planning and execution.
We'll discuss how teams can obtain Agile discipline to achieve one of our core principles of delivering “working software” frequently. We'll explore some of the key Agile planning and engineering practices like continuous planning, Test-Driven Development, Continuous Integration and Acceptance testing. We'll look at the discipline involved in these practices, their inter-relationship, and the benefits they realize in delivering value to the customer.
Performance tuning an application can be stressful and time consuming activity and is considered by some a dark art. Fortunately Java platform provides many tools that can allow anyone to master the many issues real life production application throw at application developers.
In this session we will look some basic approaches to discovering the root causes for common performance bottlenecks and some of the tools that are available to aid in those endeavors.
In this talk we will discuss general database refactoring patterns, database multi-tenancy models as well as techniques that are used to apply 100s of changes to 1000's of live databases with 0 downtime for the application.
The session will provide an overview of database refactoring theory, common patterns as well as a short case study of putting all of the concepts together in order to apply 100,000's of database changes to the production environment reliably.
Robert Martin assembled the SOLID family of principles to provide a useful guide to help us create object-oriented software designs that were resilient in the face of change. In recent years, the need to write highly-concurrent software in order to leverage increasingly ubiquitous multicore architectures, as well as general interest in more effectively controlling complexity in large software designs, has driven a renewed interest in the functional programming paradigm. Given the apparent similarity in their goals, “What is the intersection of SOLID with functional programming?” is a natural question to ask.
In this talk, we'll explore this intersection. We'll begin with a tour of the evolutionary patterns associated with enterprise software and programming paradigms, as well as take a look at the ongoing quest for best practices, the goal being to elucidate the motivation for examining this intersection of SOLID and functional programming. We'll then walk through each of the SOLID principles, examining them in their original object-oriented context, and looking at example problems and solutions using the Java language. Then for each principle, we'll examine its possible intersection with the functional programming paradigm, and explore the same problems and solutions using the Clojure language. We'll close by examining the transcendent qualities of the SOLID principles and how they can make any design simpler, regardless of the programming paradigm employed.
For much of the last two years I've delivered a two-part series at NFJS shows entitled “Effective Java Reloaded.” For all pracical purposes, it is an ala carte style rehash of the book Effective Java, written by Josh Bloch. One of my favorite parts of the discussion is of Item #15, which tells us to “Minimize Mutability.” If we turn this inside out, we're actually saying that we want to MAXIMIZE IMMUTABILITY. When we do this, we reap many benefits, such as code that is easier to reason about and that is inherently thread-safe. This can carry us a long way in the direction of program correctness and decreased complexity. However, when we start to program with immutability, several major questions arise.
First, the necessity of using a separate object for each distinct value, never reusing, or “mutating” an object, can quickly cause performance concerns. These concerns are amplified when we're talking about large collections such as lists and maps. These problems are largely solved by what we call “persistent data structures.” Persistent data structures are collections from which we create new values, not by copying the entire data structure and apply changes, but by creating a new structure which contains our changes but points at the previous structure for those elements which have not changed. This allows us to work with data structures in a very performant way with respect to time and resource consumption. We'll examine persistent data structures, their associated algorithms, and implementations on the JVM such as those found in the TotallyLazy library.
Second, because all of an immutable object's state must be provided at the time of construction, the construction of large objects can become very tedious and error prone. We'll examine how the Builder pattern can be applied to ease the construction of large objects, and we'll examine Builder implementations in Java and Groovy.
Third, we run into problems when we start to use frameworks that expect us to program in a mutable style. A prime example is Hibernate, which expects our persistent classes to follow the well-worn JavaBean convention, including a no argument constructor and getters and setters for each property. Such a class can never be mutable! So how do we program with frameworks such as Hibernate and yet still minimize mutability? The key is found in not letting frameworks dictate the way that you design your code. Just because the framework require something, don't let it force you to make the wrong decision. Use the framework as a tool to write your code, don't let your code be a tool of the framework. We'll examine strategies for doing exactly that.
You should come away from this talk better equipped to program in a way that minimizes mutability and maximizes immutability.
No matter where you slice software engineering:
The root cause of many, if not most problems, is the common absence of critical thinking in how we approach decision making. Instead of thinking critically about our engineering decisions, we often follow a Cargo Cult mentality or blindly follow the pronouncements of the Blowhard Jamboree. The end results all too often include suboptimal productivity, excessive spending, poor quality and cancelled projects.
When we think instead critically about a component of software engineering, we take it apart. We discard our presuppositions. We challenge tradition. We gather our own evidence. We question everything.
This talk will examine the pathologies associated with not thinking critically, including a tour of the antipatterns that can emerge from such a practice. We'll then walk through the concentric circles of the critical thinking process, including evidence evaluation, argument evaluation, and argument construction. You'll leave this session with a critical thinking framework which can be applied to software engineering as well as beyond.
Traditional automated testing approches combine input generation, execution, output capture, and validation inside the bodies of single functions. Generative testing approaches gain expressive power by isolating these steps.
With generative testing:
There are a number of benefits to this approach:
This talk introduces test data generation and generative testing, using for its examples the data.generators and test.generative libraries developed by the author.
Simulation allows a rigorous, scalable, and reproducible approach to testing. The separation of concerns, and the use of a versioned, time-aware database, give simulation great power. This talk will introduce simulation testing, walking through a complete example using Simulant, an open-source simulation library.
Simulation allows a rigorous, scalable, and reproducible approach to testing:
Simulation begins with statistical models of the use of your system. This model includes facts such as “we have identified four customer profiles, each with different browsing and purchasing patterns” or “the analytics query for the management report must run every Wednesday afternoon.” Models are versioned and kept in a database.
The statistical models are used to create activity streams. Each agent in the system represents a human user or external process interacting with the system, and has its own timestamped stream of interactions. With a large number of agents, simulations can produce the highly concurrent activity expected in a large production system.
Agents are scaled across as many machines as are necessary to both handle the simulation load, and give access to the system under test. The simulator coordinates time, playing through the activity streams for all the agents.
Every step of the simulation process, including modeling, activity stream generation, execution, and the code itself, is captured and stored in a database for further analysis. You will typically also capture whatever logs and metrics your system produces.
Since all phases of a simulation are kept in a database, validation can be performed at any time. This differs markedly from many approaches to testing, which require in-the-moment validation against the live system.
The separation of concerns above, and the use of a versioned, time-aware database, gives simulation great power. Imagine that you get a bug report from the field, and you realize that the bug corresponds to a corner case that you failed to consider. With a simulation-based approach, you can write a new validation for the corner case, and run that validation against your past simulation results, without ever running your actual system.
This talk will introduce simulation testing, walking through a complete example using Simulant, an open-source simulation library.
This workshop is aimed at Java and Java EE developers looking to understand and apply a Rule Engine to solve problems typically and painfully addressed with traditional programming techniques.
In this workshop you will learn how to build lean applications using Test-Driven Development Techniques in conjunction with jBoss’ Drools Rule Engine to streamline, simplify and minimize the maintenance burden of a growing application in a rapidly changing business environment
Eclipse IDE - Juno
The Drools IDE is part of the JBoss Tools family of plugins
Select “Help” » “Install New Software…”
Next to the “Work with:” field, select “Add…”
Enter:
http://download.jboss.org/drools/release/5.4.0.Final/org.drools.updatesite/
with a name like “JBoss Tools”
Code samples are hosted on Git. A Git Enable Eclipse installation is preferred but we can always use git from the command line
This workshop is aimed at Java and Java EE developers looking to understand and apply a Rule Engine to solve problems typically and painfully addressed with traditional programming techniques.
In this workshop you will learn how to build lean applications using Test-Driven Development Techniques in conjunction with jBoss’ Drools Rule Engine to streamline, simplify and minimize the maintenance burden of a growing application in a rapidly changing business environment
Eclipse IDE - Juno
The Drools IDE is part of the JBoss Tools family of plugins
Select “Help” » “Install New Software…”
Next to the “Work with:” field, select “Add…”
Enter:
http://download.jboss.org/drools/release/5.4.0.Final/org.drools.updatesite/
with a name like “JBoss Tools”
Code samples are hosted on Git. A Git Enable Eclipse installation is preferred but we can always use git from the command line
An introduction to CoffeeScript as a drop in replacement for JavaScript and a tour of how it can impart structure to what has traditionally been a most disorganized part of our Web Applications.
An introduction to CoffeeScript as a drop in replacement for JavaScript and a tour of how it can impart structure to what has traditionally been a most disorganized part of our Web Applications.
Update: We'll be using Android Studio and Gradle for this workshop
The smartphone has been the current platform of choice for Android development but we are now in the “year of the tablet” and it is time to upgrade your skills. Even though you think you know Android programming, you still need to learn the unique techniques for developing for tablet.
We'll analyse the UI patterns important on tablets (like Action Bars). And you'll learn how to use the specialized classes (like Fragments) that were created especially for tablets.
The following topics are included in this presentation:
The Tablet Marketplace
Tablet UI design
Optimizing layouts for larger screens
Dips, Sips and pixels
Action Bars
Fragments
Side Navigation
3rd Party Libraries
Update: We'll be using Android Studio and Gradle for this workshop
The smartphone has been the current platform of choice for Android development but we are now in the “year of the tablet” and it is time to upgrade your skills. Even though you think you know Android programming, you still need to learn the unique techniques for developing for tablet.
We'll analyse the UI patterns important on tablets (like Action Bars). And you'll learn how to use the specialized classes (like Fragments) that were created especially for tablets.
The following topics are included in this presentation:
The Tablet Marketplace
Tablet UI design
Optimizing layouts for larger screens
Dips, Sips and pixels
Action Bars
Fragments
Side Navigation
3rd Party Libraries
Have you tried to “utilize” people at 100% and realized your team couldn’t finish anything? Or, you were supposed to “rank and yank” because some famous company or leader did, even though you only have five people in your group? Maybe you have run afoul of the furniture police because you wanted different furniture or you wanted to reorganize the workspace for a better working environment. Managing and leading in organizations doesn’t have to be this way.
These are all management myths, rules, and illusions. They hurt the people in your organization, and your ability to lead. You can reclaim your leadership.
In this session, we will explore the myths you see in your organization. We will identify alternative practices that allow you to manage and lead, focused on the wellbeing of your business and the people in your business.
Build a Grails application from start to finish in this half-day workshop. We'll start with domain classes, apply constraints, add controllers and services, apply both unit and integration tests, and then add additional functionality through plugins.
This rapid introduction to Grails will take advantage of the newest features of Grails 2.0 using the interactive scripts and db console. In addition to building an application, existing samples will be reviewed as a source of good practices and plugins.
Some knowledge of Groovy is assumed but not required.
Software:
Unzip the Grails distribution, set a GRAILS_HOME variable to its location, and add the bin subdirectory to your path.
As an alternative installation mechanism, please consider GVM, located at http://gvmtool.net . That will allow you to switch Grails version with a single command. It works for Macs and Unix flavors, as well as Windows through Cygwin.
No IDE is required, but if you want to use one, consider Groovy and Grails Tool Suite. The current version is 3.3.0 and can be downloaded from http://grails.org/products/ggts. IntelliJ IDEA has Grails support in its Ultimate edition only. NetBeans also has Grails support.
Build a Grails application from start to finish in this half-day workshop. We'll start with domain classes, apply constraints, add controllers and services, apply both unit and integration tests, and then add additional functionality through plugins.
This rapid introduction to Grails will take advantage of the newest features of Grails 2.0 using the interactive scripts and db console. In addition to building an application, existing samples will be reviewed as a source of good practices and plugins.
Some knowledge of Groovy is assumed but not required.
Software:
Unzip the Grails distribution, set a GRAILS_HOME variable to its location, and add the bin subdirectory to your path.
As an alternative installation mechanism, please consider GVM, located at http://gvmtool.net . That will allow you to switch Grails version with a single command. It works for Macs and Unix flavors, as well as Windows through Cygwin.
No IDE is required, but if you want to use one, consider Groovy and Grails Tool Suite. The current version is 3.3.0 and can be downloaded from http://grails.org/products/ggts. IntelliJ IDEA has Grails support in its Ultimate edition only. NetBeans also has Grails support.
Multiple languages on the JVM offer the ability to write concise and expressive code. One thing that sets Groovy apart, more distinctively than a few others, is its ability to extend the program at runtime.
Classes are open in Groovy and we can not only add methods, but we can synthesize methods as well, at runtime. This ability provides for quite an interesting set of flexibilities, paving the way to create highly dynamic applications, domain specific languages, lightweight configurable components, all with less code.
In this workshop we will dive into metaprogramming in Groovy, using practical hands-on examples and make use of it to create some dynamic behavior. We will focus on concepts and techniques you can readily put to real use on your next project.
Multiple languages on the JVM offer the ability to write concise and expressive code. One thing that sets Groovy apart, more distinctively than a few others, is its ability to extend the program at runtime.
Classes are open in Groovy and we can not only add methods, but we can synthesize methods as well, at runtime. This ability provides for quite an interesting set of flexibilities, paving the way to create highly dynamic applications, domain specific languages, lightweight configurable components, all with less code.
In this workshop we will dive into metaprogramming in Groovy, using practical hands-on examples and make use of it to create some dynamic behavior. We will focus on concepts and techniques you can readily put to real use on your next project.
There is a good amount of excitement about the new version of Java. The big
evolution of course is the lambda expressions. In this presentation we will dive into the language features in Java 8, take a look at some of their nuances, and look at ways to put them to good use.
Java 8 language capabilities and application.
Relational databases have ruled the world since the dawn of time (or so it appears). They power our enterprises and for many in the corporate world, it may be hard to imagine life without them. Each decade a novel idea would challenge the status quo and make a case to deviate for the tradition. A flock of enthusiastic programmers, like your humble speaker back in the early 90s, would throw their support around it, only to be crushed eventually by the large vendors and enterprise standards. But, the excitement around NoSQL has shown that enterprise data is not the only thing that's persistent.
In this presentation we'll learn how NoSQL deviates from those deep rooted traditional approaches, and how this may be useful. We will also discuss the situations where these types of databases may be more appropriate.
edn and Fressian are self-describing, schema-free, batteries-included, extensible data languages. In this talk, you will find out where you might benefit from these languages over e.g. JSON or XML.
Systems use many languages, and not just programming languages such as Java, C#, Ruby, or Python. Systems also relay on data languages, both for data on the wire, and for data at rest. These data languages differ greatly in their design objectives and capabilities, and are often less understood than their programming language counterparts.
This talk will introduce two data notations: edn and Fressian, which share several common characteristics. Both are
These capabilities align well with the dynamic, flexible needs of real systems. And in their key difference (text vs. binary), edn and Fressian cover the bases of human readability and maximum performance.
The enterprise today consists of tens, if not hundreds of applications, all designed to meet the needs of the business. These applications rarely live in a silo, and often there is a need to establish a communication protocol between these applications.
There are various approaches to integration, and in this talk we will discuss the pros and cons of each. We will then focus on one particular approach, and solution - Spring Integration brought to us by the folks at Spring Source. We will talk about both inter and intra application integration, and look at some of the ways we can leverage Spring Integration within the enterprise
You've seen really cool and interesting technologies at conferences like NFJS, UberConf and The Rich Web Experience, but how do you “take it to the next level?” Setting up testbeds to play with things can be hard, involving multiple steps that need to be repeated often. Plus, you may not want to install 3 different NoSQL database and a myriad of frameworks on your system for fear of messing up what you need for your “day job.”
You've seen really cool and interesting technologies at conferences like NFJS, UberConf and The Rich Web Experience, but how do you “take it to the next level?” Setting up testbeds to play with things can be hard, involving multiple steps that need to be repeated often. Plus, you may not want to install 3 different NoSQL database and a myriad of frameworks on your system for fear of messing up what you need for your “day job.”
That's where VirtualBox, Vagrant and Puppet come to the rescue. In this session, you'll learn how to set up the VirtuaBox and Vagrant so you can run virtual machines as a platform to play. There's more to it, though. We'll also learn how to use tools like Puppet to create definitions for these VMs that will install and set up whatever you're interested in - from NoSQL databases to Spring to the latest frameworks. Something get messed up? No problem! Re-create your test environment from scratch using the Puppet scripts we'll create. Best of all, these can be shared with your co-workers saving them time and ensuring they have the same setup. See how these tools and techniques can control and manage your personal technology “digital playground!”
Puppet is a powerful framework for the automation of tasks typically performed by system administrators as part of software infrastructure provisioning and maintenance. Puppet adoption is rapidly increasing, boasting use by companies such as Google, RedHat, Constant Contact, Zynga, and Shopzilla.
Puppet is composed of three principle components:
We'll dive deeply into Puppet's architecture and features, including its idempotent configurations, cross-platform resource abstraction layer, and graph-based modeling of resources, resource providers, and resource relationships. We'll then leverage puppet to set up infrastructure of a typical JVM-based web development project with various OS, application server and datastore configurations. You'll leave a “Master of Puppet,” ready to apply it on your next software delivery effort.
While many developers have embrace simpler NoSQL variants (like MongoDB and CouchDB). Cassandra is possibly at the forefront of the NoSQL innovation, providing a level of reliability and fine tuning not found in many of the competitors offerings.
In this session we'll learn why you should consider Cassandra DB for your next large-data project and how to build a Cassandra based application from the ground up, taking advantage of virtualization techniques to emulate a complex multi-machine environment.
While many developers have embrace simpler NoSQL variants (like MongoDB and CouchDB). Cassandra is possibly at the forefront of the NoSQL innovation, providing a level of reliability and fine tuning not found in many of the competitors offerings.
In this session we'll learn why you should consider Cassandra DB for your next large-data project and how to build a Cassandra based application from the ground up, taking advantage of virtualization techniques to emulate a complex multi-machine environment.
While many developers have embrace simpler NoSQL variants (like MongoDB and CouchDB). Cassandra is possibly at the forefront of the NoSQL innovation, providing a level of reliability and fine tuning not found in many of the competitors offerings.
In this session we'll learn why you should consider Cassandra DB for your next large-data project and how to build a Cassandra based application from the ground up, taking advantage of virtualization techniques to emulate a complex multi-machine environment.
While many developers have embrace simpler NoSQL variants (like MongoDB and CouchDB). Cassandra is possibly at the forefront of the NoSQL innovation, providing a level of reliability and fine tuning not found in many of the competitors offerings.
In this session we'll learn why you should consider Cassandra DB for your next large-data project and how to build a Cassandra based application from the ground up, taking advantage of virtualization techniques to emulate a complex multi-machine environment.
Now that you've completed the “Critical Thinking in Software Engineering” lecture, it's time to put your new skills to work. In this session, we'll break up into teams. Each team will be presented with either an argument to evaluate or a problem situation for which you must construct an argument advocating a particular course of action.
Teams will then be responsible for presenting their evaluations and arguments to the group, and the group as a whole will evaluate the presentations.
Topics to include:
Where do defects come from? Technical debt is often one of our biggest challenges as poor design and defects are built up over time by cutting a corners here and there. We will discuss some key technical metrics that can shine light on these defects before they get out of control and find those that are out of control and worth your attention now.
We'll explore how the psychological effect of simply measuring technical metrics and making them visible can have immense impacts on reducing the occurences going forward.
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.
Most introductory programming books include a chapter on testing, seemingly as an afterthought. For the test-driven developer, that's a little too late. Some programmers approach a new programming language with a few test-cases to understand a concept. Others thrive under fire and want to hit the ground running in a new programming language by creating an application.
It just so happens that testing code in Scala is a great way to learn Scala, but also really good at testing Java code. This presentation started a book on how to use some of the greatest tools that you can use to test. This presentation will cover ScalaTest, Specs2, ScalaMock and ScalaCheck all in a triggered execution environment using SBT. For those that do not wish to use SBT, we will cover other options as well. Using these tools you may never want to use those plain jane java testing frameworks ever again. While this presentation is not interactive, all demos will be available on github for those that want to “play” along with their laptops.
Presentation on Akka. A set various tools to write concurrent, fault-tolerant applications using immutable data, asyncronous message passing using local and remote actors, software transactional memory, and supervised systems.
Akka is a middleware, but it is not your 1990s middleware. Akka is a set of various tools to write concurrent, fault-tolerant applications using immutable data, asyncronous 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 and the Scala programming language. This Akka presentation will cover both Scala and Java style usage of Akka and give the audience a 30k view of how it comes together. While this presentation is not interactive, all demos will be available on github for those that want to “play” along with their laptops.
Have you ever wished that your local development sandbox could look exactly like production, but you've got a mismatch between your local OS and your production OS? And what about the age old “it works on my machine” excuse that quite often stems from differences between developer sandboxes? Many have turned to virtualization, creating a machine image that can be passed around the team. But who manages the template? How do you keep things in sync?
In this session, we'll explore Vagrant (http://www.vagrantup.com), an open source tool that allows you to easily create and manage virtual development environments that can be provisioned on demand and “thrown away” when no longer needed.
Vagrant is most powerful when we think of it as a tool to enable various workflows that are useful to software development teams. In this talk, we'll walk through the following workflows and examine Vagrant's contributions:
The single most important tool in any developers toolbox isn't a fancy IDE or some spiffy new language - it's our brain. Despite ever faster processors with multiple cores and expanding amounts of RAM, we haven't yet created a computer to rival the ultra lightweight one we carry around in our skulls - in this session we'll learn how to make the most of it. We'll talk about why multitasking is a myth, the difference between the left and the right side of your brain, the importance of flow and why exercise is good for more than just your waist line.
The single most important tool in any developers toolbox isn't a fancy IDE or some spiffy new language - it's our brain. Despite ever faster processors with multiple cores and expanding amounts of RAM, we haven't yet created a computer to rival the ultra lightweight one we carry around in our skulls - in this session we'll learn how to make the most of it. We'll talk about why multitasking is a myth, the difference between the left and the right side of your brain, the importance of flow and why exercise is good for more than just your waist line.
In modern applications, Javascript is increasingly prevalent both on the client-side and to some degree on the server-side. As we continue to crank out more Javascript code, we're finding that many of the same hard-lessons we learned in writing decoupled Java code are equally desirable in Javascript code. Without the benefit of dependency injection and AOP, both Java and Javascript code can quickly become an unnavigable and untestable mess.
Where frameworks like Spring have helped us gain control over our Java code, Cujo.js similarly aims to give our Javascript code more structure and testability.
In this session, we'll look at Cujo.js, an “unframework” that provides dependency injection that takes Javascript's unique needs into consideration to create loosely-coupled code. We'll also see how, although Cujo.js isn't strictly a UI framework, elements of Cujo.js can be brought together to elegantly build client-side UIs.
In modern applications, Javascript is increasingly prevalent both on the client-side and to some degree on the server-side. As we continue to crank out more Javascript code, we're finding that many of the same hard-lessons we learned in writing decoupled Java code are equally desirable in Javascript code. Without the benefit of dependency injection and AOP, both Java and Javascript code can quickly become an unnavigable and untestable mess.
Where frameworks like Spring have helped us gain control over our Java code, Cujo.js similarly aims to give our Javascript code more structure and testability.
In this session, we'll look at Cujo.js, an “unframework” that provides dependency injection that takes Javascript's unique needs into consideration to create loosely-coupled code. We'll also see how, although Cujo.js isn't strictly a UI framework, elements of Cujo.js can be brought together to elegantly build client-side UIs.
In recent years, there has been a renewed interest in how data is stored. Although RDBMS has long been treated as a one-size-fits-all solution for data storage, a new breed of datastores has arrived to offer a best-fit solution. Key-value stores, column stores, document stores, graph databases, as well as the traditional relational database are options to consider.
With these new data storage options come new and different ways of interacting with data. Even though all of these data storage options offer Java APIs, they are widely different from each other and the learning curve can be quite steep. Even if you understand the concepts and benefits of each database type, there's still the huge barrier of understanding how to work with each database's individual API.
Spring Data is a project that makes it easier to build Spring-powered applications that use new data, offering a reasonably consistent programming model regardless of which type of database you choose. In addition to supporting the new “NoSQL” databases such as document and graph databases, Spring Data also greatly simplifies working with RDBMS-oriented datastores using JPA.
In this 2-part workshop, we'll dig in with a hands-on exploration of a variety of data stores, including Redis, MongoDB, Neo4j, and traditional RDBMS. In doing so, you'll experience first-hand how Spring Data simplifies working with these data stores.
Prerequisites:
For maximum benefit, please come to this workshop with a laptop setup and ready. We will not allot any time for environment setup during the workshop.
What you'll need: A laptop setup with:
In recent years, there has been a renewed interest in how data is stored. Although RDBMS has long been treated as a one-size-fits-all solution for data storage, a new breed of datastores has arrived to offer a best-fit solution. Key-value stores, column stores, document stores, graph databases, as well as the traditional relational database are options to consider.
With these new data storage options come new and different ways of interacting with data. Even though all of these data storage options offer Java APIs, they are widely different from each other and the learning curve can be quite steep. Even if you understand the concepts and benefits of each database type, there's still the huge barrier of understanding how to work with each database's individual API.
Spring Data is a project that makes it easier to build Spring-powered applications that use new data, offering a reasonably consistent programming model regardless of which type of database you choose. In addition to supporting the new “NoSQL” databases such as document and graph databases, Spring Data also greatly simplifies working with RDBMS-oriented datastores using JPA.
In this 2-part workshop, we'll dig in with a hands-on exploration of a variety of data stores, including Redis, MongoDB, Neo4j, and traditional RDBMS. In doing so, you'll experience first-hand how Spring Data simplifies working with these data stores.
Prerequisites:
For maximum benefit, please come to this workshop with a laptop setup and ready. We will not allot any time for environment setup during the workshop.
What you'll need: A laptop setup with:
When I got into Java I had a “Wow, look how easy it is to implement these patterns.” When I got into Groovy, I had the same reaction, but only better. The dynamic nature of Groovy makes it easier to implement some common patterns. What's better, there are some patterns that you can exploit in Groovy that are not so easy in Java. In this section, you will learn how to implement some traditional patters in Groovy, and also other patterns you are simply not used to in Java.
This presentation will go far beyond the Gang-of-four (GOF) patterns. You will learn how to implement some GOF patterns, but also some patterns that will allow you to exploit dynamic nature of Groovy and the elegance of Groovy closures.
Feature requests are steadily pouring in, but the team cannot respond to them. They are paralyzed. The codebase on which the company has “bet the business” is simply too hard to change. It's your job to clean up the mess and get things rolling again. Where do you begin? Your first task is to get the lay of the land by applying a family of techniques we'll call “Code Archaeology.”
In this session we will learn how to systematically explore a codebase. We'll look at what tools are available to help us out, slinging some wicked shell-fu along the way. We'll look at “code islands” and “code bridges,” and how to construct a “map of the code.” We'll also examine the wisdom that thought leaders like Michael Feathers and Dave Thomas have leant to this subject.
Once we've gained a thorough understanding of what we have in front of us, we'll learn approaches for getting the system under test and refactoring so that we can start to pick up the pace and respond to user requirements without making a bigger mess. You'll leave this session well prepared to tackle the next “big ball of mud” that gets dumped on your desk.
From client-side polling to SSE (Server-Sent Events) and WebSockets.
Server-side browser push technologies have been around for a while in one way or another. From crude browser polling to Flash enabled frameworks. In this session you'll get a code-driven walk-through on the evolution and mechanics of server-push technologies. From client-side polling to SSE (Server-Sent Events) and WebSockets. We'll explore a few implementation techniques, the protocols involved and the fallbacks and along the way I will help you gain a new practical understanding on this rapidly changing family of technologies and techniques
Emergent design is a big topic in the agile architecture and design community. This session covers the theory behind emergent design and shows examples of how you can implement this important concept.
This session describes the current thinking about emergent design, discovering design in code. The hazard of Big Design Up Front in software is that you don't yet know what you don't know, and design decisions made too early are just speculations without facts. Emergent design techniques allow you to wait until the last responsible moment to make design decisions. This talk covers four areas: emergent design enablers, battling things that make emergent design hard, finding idiomatic patterns, and how to leverage the patterns you find. It includes both proactive (test-driven development) and reactive (refactoring, metrics, visualizations, tests) approaches to discovering design, and discusses the use of custom attributes, DSLs, and other techniques for utilizing them. The goal of this talk is to provide nomenclature, strategies, and techniques for allowing design to emerge from projects as they proceed, keeping you code in sync with the problem domain. This talk shows lots of examples of how to make this concept work in your environment.
Groovy isn't designed to replace Java – it just makes Java cleaner and easier to develop. This presentation will look at various tasks Java developers need to do and demonstrate ways Groovy can help.
Topics will include building and testing applications, accessing both relational and NoSQL databases, working with web services, and more.
Every team goes through ups and downs. As a Tech Lead, what role do you play in riding the storm, managing conflict, growing people's skills, ensuring technical excellence and fostering innovation - all while working under time pressure?
I'll go through some practical techniques from the trenches that put the “lead” in Tech Lead.
Datasets have gotten to PB-scale, but the modeling you can do has been limited to a single-node (e.g. R, SAS) or stuck inside the database or takes hours on Hadoop-like technologies. We have built a simple clustering package, and are using it to do distributed analytics on the sum of all ram in a cluster.
This talk focuses on how the clustering technology, plus a Java-based vector math API, is being used to build full algorithms like GLM/GLMNET, Random Forest and K-means. These algorithms are complex multi-pass programs and traditional distributed programming models expose the distributed boundaries making the algorithms hard to reason about. We have a basic JDK for doing at-scale math, we can run most Plain Olde Java in (distributed) inner loops, communicate via a K/V store with exact Java Memory Model consistency (not lazy consistency). Adding more cpus makes these algorithms run faster, and adding more ram allows larger datasets. We are bringing back Moore's Law!
Today’s interconnected world requires that organizations rapidly deliver flexible-integrated solutions. The conventional approach is to integrate heterogeneous applications using web services but unfortunately that tends to tightly couple those applications. In this session we will explore several alternatives for achieving Enterprise Integration Agility.
Public Web APIs are increasing at an exponential rate resulting in an ever more connected web. This connected contagion is not just relegated to the domain of Web 2.0 but has infected the corporate world. In fact, companies are becoming more reliant on Software as a Service (SAAS) to provide key business functions.
Combating this contagion requires an approach that provides a type of insurance against constant change and lays the foundation for evergreen enterprise solutions. In this session we will explore three popular architectural styles including Message Oriented, Service Oriented, and Resource Oriented Architecture that are used to achieve Enterprise Integration Agility. In addition, I will provide examples of each architectural style using ActiveMQ/Camel, Mule ESB, and NetKernel.
In recent years, the cloud has gone from Larry Ellison's “Maybe I'm an idiot, but I have no idea what anyone is talking about,” to Microsoft's “TO THE CLOUD!” to a central part of many companies IT strategy. At the same time, the way that we consume the cloud has continued to evolve. Many of today's cloud efforts revolve around utilization of various “infrastructure as code” products (e.g. Puppet and Chef) and homegrown automation to create deployment pipelines. When we start at this level, we often end up reinventing many of the same wheels as we climb the abstraction ladder.
Platform as a Service (PaaS) offerings are positioned to allow developers (and operators) to start climbing the abstraction ladder from a higher rung, shifting the model from machine-centric deployment to application-centric deployment. This session will focus on life as an application developer using Cloud Foundry as a PaaS, with demos using Pivotal's Hosted CF at http://run.pivotal.io.
We'll cover the following topics:
All parts will require:
Needless to say you'll need a laptop! For best experience, a Mac or Linux environment is ideal (it's technically possible to get most of this working on Windows, but it's VERY DIFFICULT). Also, you'll need at least 8 GB of RAM to support running Cloud Foundry locally without too much of a performance hit.
Part one of the workshop will require a free account on Pivotal Web Services. You can create a 60-day trial with no credit card at https://run.pivotal.io.
Parts two and four will require the use of BOSH Lite. More instructions will be provided at the conference. But, to ease setup, please install the following dependencies (in addition to those for part one!):
An alternative to setting up BOSH Lite if you have trouble with the environment (or you are stuck on Windows!) is to use TryCF. This only requires an AWS account (obviously a credit card required) and an email address, and eliminates the need for this entire dependency list. The estimated cost is 28 cents per hour, so you won't run up a huge bill!
Part Three will require the use of a FREE Cloudbees account. Create one at https://grandcentral.cloudbees.com. Once you're set up, click on “Get Started with Builds” to provision your Jenkins instance. We'll complete the remainder of the setup during the lab, but it's important to get the Jenkins instance provisioned in advance so that you don't lose 10 minutes of workshop time!
It will also require the use of a FREE TRIAL account of Artifactory Online from JFrog. You can obtain an account at https://www.jfrog.com/registration/registration.html. This one is a bit quicker, but you still should try to create it before the workshop.
Poorly designed web applications fail to serve both the business and the users, leading to a unnecessary costs, and frustrated customers. By keeping the user in mind, and following a few simple guidelines, you can make huge leaps in the way your users interact with your applications.
In this session, we will focus on the enterprise - where the user-base is known and fairly consistent, but typically where user interface and interaction are not the top most priorities. We will discuss some rules for good design, look at a few simple design elements that can make your web apps shine, and your users rejoice.
Dependency injection in java has come a long way since Spring popularized the concept 10 years ago. Today, many, if not all DI libraries support writing config in JVM languages as opposed to XML. The new Dagger library changes the game again, this time pushing DI straight into the java compiler.
This session will review what Dagger does and doesn't do, how to use it, and how it works. We'll also touch on what it is like to contribute to an open source library with a “less is more” ethic. Come prepared with a basic understanding of Guice, and leave knowing the latest on dependency injection.
Programming concurrency has turned into a herculean task. I call the traditional approach as the synchronized and suffer model. Fortunately, there are other approaches to concurrency and you can reach out to those directly from your Java code.
In this presentation we will discuss the actor based concurrency and also the software transaction memory. We will then develop examples using AKKA and compare the power of these approaches in contrast to the traditional approach.
Geb is a browser automation solution for Groovy. It brings together the power of WebDriver, the elegance of jQuery content selection, the robustness of Page Object modelling and the expressiveness of the Groovy language. Geb enables more expressive, more concise, and (very importantly) more maintainable web tests.
In this session we'll explore the foundations of Geb and illustrate how it uses the language features of Groovy to make web automation and testing productive and effective. After exploring the basics we'll explore Geb's rich Content DSL and discuss patterns for achieving maintainable tests. We'll also look at how it combines with Spock, the Enterprise ready testing framework, to enable low cost executable specifications that describe user behaviour, not browser details.
The larger and more diverse your technology organization, the greater the value you can realize in standardizing your build and delivery process. Internal build standards make it easier for people to switch between teams, allowing you to more readily adjust your staffing to meet changing business needs. In this session we’ll walk through examples of leveraging Gradle’s extensibility and plugin mechanisms to develop standards, enforce compliance and deliver tailored out of the box functionality. We will also look at how to provision such customisations throughout your enterprise in a controllable way.
Gradle's flexibility combined with its support for conventions, including your conventions, provides the ability to solve your automation challenges effectively in a centralised fashion.
The session will cover various GC tuning techniques, in particular focus on tuning large scale JVM deployments. Come to this session to learn about GC tuning recipe that can give you the best configuration for latency sensitive applications. While predominantly most enterprise class Java workloads can fit into a scaled-out set of JVM instances of less than 4GB JVM heap, there are workloads in the in memory database space that require fairly large JVMs.
In this session we take a deep dive into the issues and the optimal tuning configurations for tuning large JVMs in the range of 4GB to 128GB. In this session the GC tuning recipe shared is a refinement from 15 years of GC engagements and an adaptation in recent years for tuning some of the largest JVMs in the industry using plain HotSpot and CMS GC policy. You should be able to walk away with the ability to commence a decent GC tuning exercise on your own. The session does summarize the techniques and the necessary JVM options needed to accomplish this task. Naturally when tuning large scale JVM platforms, the underlying hardware tuning cannot be ignored, hence the session will take detour from the traditional GC tuning talks out there and dive into how you optimally size a platform for enhanced memory consumption. Lastly, the session will also cover vfabric reference architecture where a comprehensive performance study was done.
The session will cover various GC tuning techniques, in particular focus on tuning large scale JVM deployments. Come to this session to learn about GC tuning recipe that can give you the best configuration for latency sensitive applications. While predominantly most enterprise class Java workloads can fit into a scaled-out set of JVM instances of less than 4GB JVM heap, there are workloads in the in memory database space that require fairly large JVMs. In this session we take a deep dive into the issues and the optimal tuning configurations for tuning large JVMs in the range of 4GB to 128GB.
In this session the GC tuning recipe shared is a refinement from 15 years of GC engagements and an adaptation in recent years for tuning some of the largest JVMs in the industry using plain HotSpot and CMS GC policy. You should be able to walk away with the ability to commence a decent GC tuning exercise on your own. The session does summarize the techniques and the necessary JVM options needed to accomplish this task. Naturally when tuning large scale JVM platforms, the underlying hardware tuning cannot be ignored, hence the session will take detour from the traditional GC tuning talks out there and dive into how you optimally size a platform for enhanced memory consumption.
This presentation covers the Guava library developed by Google (http://code.google.com/p/guava-libraries/). Guava provides collection extensions to the Java Collection API and, along with this, a cornucopia of time-saving utilities that bring Java as close as possible to some of the more functional and dynamic language competitors like Scala, Ruby, and Clojure.
This presentation focuses on the following topics: how to make Predicates and Functions; how to use new collection constructs that make life easier, including MultiMap, BiMaps, and MultiSets; how to set up and use Guava preconditions; and how to create truly immutable collections, and more. All of this is done with Java.
Time is very precious and is often threatened by phone calls, emails, co-workers, bosses, and most of all, yourself. The Pomodoro Technique reigns in unfocused time and gives your work the urgency and the attention it needs, and it's done with a kitchen timer.
In this presentation we discuss how to set up, estimate time, log time, deal with interruptions, and integrate with Agile as a team. We discuss timer software and even some of the great health benefits of the Pomodoro Technique.
Doing full stack testing (sometimes referred to as “functional” or “acceptance” testing) of web applications is a non trivial business. While such tests are undisputedly more costly to develop, maintain and execute than simple unit tests, that's no excuse to ignore this crucial aspect of a comprehensive testing strategy. Many teams still rely on expensive manual testing for coverage at this level, citing the difficulty in managing a large body of automated functional tests. In this session we'll look at how Gradle can help by orchestrating the necessary components of a Selenium 2 based toolchain.
We'll look at how Gradle's flexibility and extensibility can be used to; provision browsers to be used for testing, parameterizing test execution, grouping tests, executing tests across different browsers, parallelizing test execution in different ways and merging test results. We'll implement a focussed build framework for developing, executing and maintaining automated web tests using Java, Selenium, TestNG and using Jenkins to run our tests for us. Automated web tests have a high cost but an extremely high value, as they can give you confidence that your software actually works when fully assembled. We'll see how Gradle can reduce the cost aspect of this equation without sacrificing on the value.
Finally, we'll briefly look at using some more progressive tooling by using Geb in place of Selenium and the Spock Framework in place of TestNG. The Geb and Spock Framework tools are both side projects of Gradleware core engineers.
The Gradle development team have not been taking it easy since the release of Gradle 1.0. New features and innovations are constantly being added, rough edges are being smoothed and the platform continues to expand. In this session we’ll explore the most notable additions to Gradle since the release of 1.0 and preview some of the new and exciting features just over the horizon with Gradle founder and Gradleware CEO Hans Dockter and Gradle core developer Peter Niederwieser.
Gradle continues to evolve with a high velocity to gain new capabilities, features and increased build performance.
We’ll dig into to some of the features incorporated since the 1.0 release, such as:
We’ll also take a sneak peak at some of the upcoming features that will soon be available in Gradle.
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.
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 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 surge of interest in the REpresentational State Transfer (REST) architectural style, the Semantic Web, and Linked Data has resulted in the development of innovative, flexible, and powerful systems that embrace one or more of these compatible technologies. However, most developers, architects, Information Technology managers, and platform owners have only been exposed to the basics of resource-oriented architectures.
This talk, based upon Brian Sletten's book of the same name, is an attempt to catalog and elucidate several reusable solutions that have been seen in the wild in the now increasingly familiar “patterns” style. These are not turn key implementations, but rather, useful strategies for solving certain problems in the development of modern, resource-oriented systems, both on the public Web and within an organization's firewalls.
In this session we will look to see how we can refactor our learning - what tools, and methodologies can we use to help us learn quicker and better - how we can create a store that gives us quick access to information when we really need it.
We all work in an industry in which not only do the tools that we use change ever few years, but one in which we have to shift the very paradigms these tools are built on! Even the most trivial of projects entails tens of different toolkits, frameworks, and languages coming together, and somehow we need to know how to leverage each one. How does one keep up? Despite all our years in schools, and our in-born nature to learn, we often are never taught how to learn. How can we learn faster, and retain even more?
In this session we will take a look at various tools and techniques available to us and see how we can make our learning effective.
Find yourself overwhelmed with hundreds of to-dos? Is your hard-drive littered with dozens of killer ideas that you started with enthusiasm and then just fizzled away? Do you feel like you are moving as fast as can but only getting to the wrong place quicker? Well perhaps this session will help.
There are various techniques and strategies available to us today that aim to help with exactly this conundrum - from Getting Things Done ™ to Personal Kanban. Unfortunately it is often easy to be extremely productive using these systems, but not very effective. After all, it's not about getting things done, but getting the RIGHT things done. In this talk we will discuss not only how to get things done, but also attempt to figure out what it is you actually need to be doing.
In this session, I will attempt to show you how you can leverage various strategies to be more effective, knock to-dos out and have fun while doing it. If time permits we will close with an overview of the tools that are available to you, and how you can use these to become a to-do list ninja :)
Do you use REST from your mobile and HTML5 apps to communicate with backend services? Are you doing so securely?
Find out how to use simple authentication, access control, and encryption techniques to
protect your RESTful services. You will also learn how vulnerabilities like Cross-Site Request Forgery (CSRF) can be used by attackers to hack your services.
Using live demos, developers and architects will learn how to secure critical REST services and proactively prevent attacks from occurring to stop hackers from exploiting their applications.
The Spock framework brings simple, elegant testing to Java and Groovy projects. It integrates cleanly with JUnit, so Spock tests can be integrated as part of an existing test suite. Spock also includes an embedded mocking framework that can be used right away.
In this presentation, we'll look at several examples of Spock tests and review most of its capabilities, including mock objects and integration with Spring.
The Spock framework brings simple, elegant testing to Java and Groovy projects. It integrates cleanly with JUnit, so Spock tests can be integrated as part of an existing test suite. Spock also includes an embedded mocking framework that can be used right away.
In this presentation, we'll look at several examples of Spock tests and review most of its capabilities, including mock objects and integration with Spring.
Learn how to exploit security vulnerabilities that are commonly found in the arsenal of malicious attackers. We won't simply talk about issues like XSS, CSRF and SQL Injection, but will have live demos showing how hackers exploit these potentially devastating defects using freely available tools. You'll see how to hack a real world open source application and explore bugs in commonly used open source frameworks. We also look at the source code and see how to fix these issues using secure coding principles. We will also discuss best practices that can be used to build security into your SDLC.
Java developers and architects will learn how to find and fix security issues in their applications before hackers do.
In this session, we will take a look at Angular - a new MVC framework by Google. We will discuss some of the terminology that Angular offers, and see how we can use that to develop highly interactive, dynamic web applications. See “Detail” for a list of topics I cover and the Github repo URL
This is an intro-level talk we will take a look at Angular and developing rich web applications. Angular embraces HTML and CSS, allowing you to extend HTML towards your application, and uses plain JavaScript which makes your code easy to reuse, and test.
Note: This is an intro level talk. It is targeted towards developers who are curious about Angular and want to learn about the fundamental features and concepts in Angular.
Topics Covered -
ng-appng-init and the evaluation {{ }} directive$rootScopeng-model$scope)ng-repeatng-form, form validation and submission in AngularJS$httpGitHub URL - https://github.com/looselytyped/angudone-backend/tree/solutions
Learn about how Netflix manages tens of thousands of endpoints that form the edge of its streaming services. Get an introduction to Denominator, an open source java library for portable DNS management.
Life on the edge is innovating a system that is ultimately responsible for 1/3 of all internet bandwidth usage in the US. Even wonder how Netflix does it? This talk will overview a combination of services and open source projects that comprise the edge network, including Neflix Denominator. Discussions will include how we deal with DNS, distributed load balancing as well discovery of mid-tier services.
You'll understand which service components are involved with edge traffic management. When you leave, you'll have enough context to create your own life on the Edge with NetflixOSS!
In this session you will learn to strategically introduce technology innovations by applying specific change patterns to groups of individuals. Using these patterns and related techniques will not only benefit your organization but will ultimately benefit your career as a technologist by making you a better influencer, writer, and speaker.
The rapid pace of technological innovation has enabled many organizations to dramatically increase productivity while at the same time decrease their overall headcount. However, the vacillating global economy combined with “change fatigue” within organizations has resulted in a risk averse culture. In such an environment how can one possibly introduce and inculcate the latest technology or process within an organization? The answer is to have a solid understanding of Diffusion Theory and to leverage Patterns of Change.
Prezi Location: http://prezi.com/b85wwmw7hccn
In this session, I will demonstrate several concurrent processing techniques including Fire and Forget, Fork-Join, Producer-Consumer, and Asynchronous Web Services using the Java Concurrency Library, the Akka Framework and the Spring Framework.
Traditional concurrent development on the Java Platform requires in depth knowledge of threads, locks, and queues. Fortunately, new languages and frameworks that run on the Java Platform have made concurrent processing easier. This session apply concurrent processing patterns and techniques using several popular libraries and frameworks.
Life on the edge is innovating a system that is ultimately responsible for 1/3 of all internet bandwidth usage in the US. Even wonder how Netflix does it?
This talk will overview a combination of services and open source projects that comprise the edge network, including Netflix Denominator. Discussions will include how we control advanced features of DNS to facilitate migrations, product testing, and failover scenarios. During the session, you'll see the open source java and command-line tools we use to make this work.
Domain Specific Langauges seems like a cool idea, but where's the payoff? This talk provides an overview of how to build both internal and external DSLs (including the state of the art tools), stopping along the way to show how this is practical to your day job.
This talk defines of DSLs (Domain Specific Languages), distinguishes the types of DSLS (internal and external), and shows examples of building DSLs of several kinds. It shows how to utilize DSLs for externalizing configuration (which you're already doing, whether you realize it or not), how to make your code readable to humans, how DSLs make developer tools better (and how to use DSL techniques to build your own tools), and how DSLs can provide your users unprecedented flexibility and power, by building DSLs customized to their job. This talk provides a good foundation for the subject if you've never seen anything about it, but keeps the focus on practical goals.
Learning the syntax of a new language is easy, but learning to think under a different paradigm is hard.
Learning the syntax of a new language is easy, but learning
to think under a different paradigm is hard. This session
helps you transition from a Java writing imperative programmer to a
functional programmer, using Java, Clojure and Scala for
examples. This session takes common
topics from imperative languages and looks at alternative ways of
solving those problems in functional languages. As a Java developer, you know how to achieve code-reuse
via mechanisms like inheritance and polymorphism. Code reuse is
possible in functional languages as well, using high-order
functions, composition, and multi-methods. I show examples from my book Functional Thinking of shifting your perspective on problems, ceding messy details to the language, working smarter, not harder, and how to deal with multiparadigm languages.
What defect management application / database do you use? Wait… why do you have so many defects that you need an entire database and an application to manage it?
I'll take a holistic look at what Quality means and some tricks and techniques to wrangle your open defect counts down into the low two-digits.