Session at ÜberConf will go in-depth! If you are a developer, technical manager, or architect our sessions are for you. This is your opportunity to go beyond the basics and master critical skills. We expect that you are a competent developer who is ready to solve problems using today's best tools and practices.
| Westminster I | Westminster II | Standley I | Standley II | Lake House | Cotton Creek | Meadowbrook I | Meadowbrook II | Windsor | |
|---|---|---|---|---|---|---|---|---|---|
| 8:00 - 9:00 AM | EARLY REGISTRATION: PRE-CONFERENCE WORKSHOP ATTENDEES ONLY - WESTMINSTER BALLROOM FOYER | ||||||||
| 9:00 - 6:00 PM |
Git Bootcamp - An All-Day WorkshopMatthew McCullough |
Web Security WorkshopKen Sipe |
Domain-Driven Design (DDD) WorkshopPaul Rayner |
iOS WorkshopChristopher Judd |
Android WorkshopJames Harmon |
Workshop: Programming with HTML 5Venkat Subramaniam |
|||
| 5:00 - 6:30 PM | MAIN UBERCONF REGISTRATION - WESTMINSTER BALLROOM FOYER | ||||||||
| 6:30 - 8:30 PM | DINNER/KEYNOTE - WESTMINSTER BALLROOM 3/4 | ||||||||
| 7:30 - 8:30 PM | Keynote: Then Our Buildings Shape Us by Tim Berglund | ||||||||
| 8:30 - 10:30 PM | OPENING NIGHT OUTDOOR RECEPTION - SOUTH COURTYARD | ||||||||
Like it or not, with application servers like node.js and increasingly rich client MVC frameworks like backbone.js, Javascript is in your future.
In this session we'll look deeply at the fundamental strengths and weaknesses of the language and how to become a javascript professional. We'll include information on using Jasmine for testing your Javascript.
Intuit and even the US government want to be "lean startups".
Learn how businesses of any size can improve the effectiveness and efficiency of their software development processes using lean startup principles like Minimum Viable Product, Validated Learning and Metrics Driven Development.
Learn why key agile practices work.
We'll look at the underlying theory from fields as diverse as queueing theory and computer networking to show why popular agile approaches work.
With NoSQL data stores you need to completely rethink how to model your data.
In this session we'll look at the very different approaches to data modeling required for MongoDB and Neo4j.
None of us want to think of ourselves as "cowboy coders", but what does it mean to be a software craftsman, and is it a useful distinction? If so, what are some of the best patterns for honing our craft?
Starting with both sides of the recent debate on software craftsmanship from leaders in the SC movement to David Harvey and Dan North, we'll look at what software craftsmanship is and isn't, and then we'll explore specific patterns and practices that can help us to be better coders - whether or not we want to adopt the craftmanship moniker.
You don't need to "do scrum" or "implement lean" to be agile.
This pragmatic session shows how specific agile software development techniques can be adopted individually to solve particular problems. If you've wondered how to get started with agile or are not getting the benefits you'd expected from agile, this session will show you a way of thinking to make agile work for your organization - along with plenty of proven patterns for improving the effectiveness of your agile initiatives.
Winston Churchill famously said, "First we shape our buildings, and afterwards, our buildings shape us." He was talking about the reconstruction of the House of Parliament, which was damaged in a bombing raid in World War II. There was a debate about how to shape the chamber to best accommodate the deliberative activity of the body that met in it. Churchill was talking about buildings, but it turns out his insight is a very general one indeed.
Developers are constantly debating their choices of language, platform, editor, methodology, and even where to put the curly braces. The robust internal dialog in community is a healthy thing, but our debates are often focused on the wrong topics. Have you ever compared languages by performance benchmarks? Platforms by alleged claims of developer productivity? Methodologies by feature velocity? There is a very good chance you're doing it wrong.
Rather than focus on the material content of our debates—language performance, editor productivity, methodological velocity—we should take Churchill's advice and think about the form of our choices. How will our choice of language influence the way we solve future problems? What assumptions does our methodology make about the nature of work? How will our choice of database affect the kinds of problems we think of as solvable?
Drawing on lessons from building architecture, literature, music, the visual arts, and even software itself, we'll learn the priority of interpreting the form of things before attempting to understand their content. You may never look at software architecture the same way again.
Alternative databases continue to establish their role in the technology stack of the future—and for many, the technology stack of the present. Making mature engineering decisions about when to adopt new products is not easy, and requires that we learn about them both from an abstract perspective and from a very concrete one as well. If you are going to recommend a NoSQL database for a new project, you're going to have to look at code.
In this talk, we'll examine three important contenders in the NoSQL space: Cassandra, MongoDB, and Neo4J. We'll review their data models, scaling paradigms, and query idioms. Most importantly, we'll work through the exercise of modeling a real-world problem with each database, and look at the code and queries we'd use to implement real product features. Come to this session for a thorough and thoroughly practical smackdown between three important NoSQL products.
Neo4j is an open-source, enterprise-class database with a conventional feature set and a very unconventional data model. Like the databases we're already used to, it offers support for Java, ACID transactions, and a feature-rich query language. But before you get too comfortable, you have to wrap your mind around its most important feature: Neo4j is a graph database, built precisely to store graphs efficiently and traverse them more performantly than relational, document, or key/value databases ever could.
Neo4j is an obvious fit to anyone who thinks they have a graph problem to solve, but this is not many people. It turns out that the most interesting property of Neo4j is its architectural agenda. It wants you to think of the entire world as a graph—as a set of connected information resources. Steeped in the thinking of resource oriented architecture, this NoSQL database wants to change the way you look at your world, and unlock new value in your data as a result.
TBA
TBA
Gradle. Another build tool? Come on! But before you say that, take a look at the one you are already using.
Whether your current tool is Make, Rake, Ant, or Maven, Gradle has a lot to offer. It leverages a strong object model like Maven, but a mutable, not predetermined one. Gradle relies on a directed acyclic graph (DAG) lifecycle like Maven, but one that can be customized. Gradle offers imperative build scripting when you need it (like Ant), but declarative build approaches by default (like Maven). In short, Gradle believes that conventions are great -- as long as they are headed in the same direction you need to go. When you need to customize something in your build, your build tool should facilitate that with a smile, not a slap in the face. And customizations should be in a low-ceremony language like Groovy. Is all this too much to ask?
Gradle has received the attention of major open source efforts and has chalked up significant conversions by the Spring Integration, Hibernate, and Grails projects. What do these technology leaders see in this bold new build tool? They see not only a better way to build Java applications, but an extensive ecosystem of connecting to existing Ant and Maven build files while expanding the horizon of test, CI, and deployment automation in an easy manner. Join us for 90 minutes and let us take you on this same walk of discovery of the most innovative build tool you've ever seen.
Prerequisite: Knowledge of any build tool such as Ant, Maven, Rake, BuildR, Make, Leiningen, or SBT.
Gradle. Another build tool? Come on! But before you say that, take a look at the one you are already using.
Whether your current tool is Make, Rake, Ant, or Maven, Gradle has a lot to offer. It leverages a strong object model like Maven, but a mutable, not predetermined one. Gradle relies on a directed acyclic graph (DAG) lifecycle like Maven, but one that can be customized. Gradle offers imperative build scripting when you need it (like Ant), but declarative build approaches by default (like Maven). In short, Gradle believes that conventions are great -- as long as they are headed in the same direction you need to go. When you need to customize something in your build, your build tool should facilitate that with a smile, not a slap in the face. And customizations should be in a low-ceremony language like Groovy. Is all this too much to ask?
Gradle has received the attention of major open source efforts and has chalked up significant conversions by the Spring Integration, Hibernate, and Grails projects. What do these technology leaders see in this bold new build tool? They see not only a better way to build Java applications, but an extensive ecosystem of connecting to existing Ant and Maven build files while expanding the horizon of test, CI, and deployment automation in an easy manner. Join us for 90 minutes and let us take you on this same walk of discovery of the most innovative build tool you've ever seen.
Prerequisite: Knowledge of any build tool such as Ant, Maven, Rake, BuildR, Make, Leiningen, or SBT.
When you want to measure fractions of a millimeter, you get a micrometer. When you want to measure centimeters, you get a ruler. When you want to measure kilometers, you might use a laser beam. The abstract task is the same in all cases, but the tools differ significantly based on the size of the measurement.
Likewise, there are some computations that can be done quickly on data structures that fit into memory. Some can't fit into memory, but will fit on the direct-attached disk of a single computer. But when you've got many terabytes or even petabytes of data, you need tooling adapted to the scale of the task. Enter Hadoop.
Hadoop is a widely-used open source framework for storing massive data sets in distributed clusters of computers and efficiently distributing computational tasks around the cluster. Come learn about the Hadoop File System (HDFS), the MapReduce pattern and its implementation, and the broad ecosystem of tools, products, and companies that have grown up around this ground-breaking project.
When you want to measure fractions of a millimeter, you get a micrometer. When you want to measure centimeters, you get a ruler. When you want to measure kilometers, you might use a laser beam. The abstract task is the same in all cases, but the tools differ significantly based on the size of the measurement.
Likewise, there are some computations that can be done quickly on data structures that fit into memory. Some can't fit into memory, but will fit on the direct-attached disk of a single computer. But when you've got many terabytes or even petabytes of data, you need tooling adapted to the scale of the task. Enter Hadoop.
Hadoop is a widely-used open source framework for storing massive data sets in distributed clusters of computers and efficiently distributing computational tasks around the cluster. Come learn about the Hadoop File System (HDFS), the MapReduce pattern and its implementation, and the broad ecosystem of tools, products, and companies that have grown up around this ground-breaking project.
Clojure has recently been gaining attention as one of the most innovative languages of the JVM in current use, and it has mostly found a home on the server. In parallel, JavaScript has ascended to the position of the most important language of the web, and until recently it has lived only on the client. Few observers looked at the world of web development and predicted that these two would get together. Happily for us, they have!
ClojureScript is a dialect of Clojure that compiles to JavaScript, and targets the JavaScript runtimes of the web as a deployment environment. It offers the unparalleled expressiveness of Lisp, the performance and space efficiency of the Google Closure Compiler, interoperability with the in-browser object model, natural integration with server-side Clojure applications, and an insanely productive in-browser REPL. In a time of proliferating JavaScript extensions and client-side development frameworks, you owe it to yourself to take a look at this compelling vision of how client-side web development should be done.
Alistair Cockburn has described software development as a game in which we choose among three moves: invent, decide, and communicate. Most of our time at No Fluff is spent learning how to be better at inventing. Beyond that, we understand the importance of good communication, and take steps to improve in that capacity. Rarely, however, do we acknowledge the role of decision making in the life of software teams, what can cause it to go wrong, and how to improve it.
In this talk, we will explore decision making pathologies and their remedies in individual, team, and organizational dimensions. We'll consider how our own cognitive limitations can lead us to to make bad decisions as individuals, and what we might do to compensate for those personal weaknesses. We'll learn how a team can fall into decision-making dysfunction, and what techniques a leader might employ to healthy functioning to an afflicted group. We'll also look at how organizational structure and culture can discourage quality decision making, and what leaders to swim against the tide.
Software teams spend a great deal of time making decisions that place enormous amounts of capital on the line. Team members and leaders owe it to themselves to learn how to make them well.
Most of the time when people talk about agile software development, they talk about project and planning practices and never mention actual development practices. This talk delves into best development practices for agile projects, covering all of its aspects.
Most of the time when people talk about agile software development, they talk about project and planning practices but never mention actual development, as if development where an afterthought when writing software. This talk bills into the real details of how to do agile development. I discuss best practices like continuous integration, pair programming, how developers should interact with story cards, how to handle enterprise concerns like integration with other software packages, and a slew of other topics related to agile software development.
Prerequisite: Having worked in an organization that values bureaucracy more than individuals
In an increasingly crowded field of languages, Clojure stands alone. It is a dynamic, functional, high performance dialect of Lisp that runs on both the JVM and CLR. The creator cast aside assumptions from both the Lisp and Java communities to create a remarkable language implementation.
This workshop introduces Clojure to Java developers who might not have seen a Lisp and don’t yet understand why that’s such an advantage. I introduce the language syntax (what little there is of it), cover interoperability with Java, macros, mutlti-methods, and more. I also cover the functional aspects of Clojure, showing its powerful immutable data structures, working with threads and concurrency, and sequences. Beyond just showing syntax, I also show how to build real applications in Clojure, and give you a chance to do the same. Attending this workshop shows enough to pique your interest and show why many of the people who were interested in Java in 1996 are interested in Clojure now.
In an increasingly crowded field of languages, Clojure stands alone. It is a dynamic, functional, high performance dialect of Lisp that runs on both the JVM and CLR. The creator cast aside assumptions from both the Lisp and Java communities to create a remarkable language implementation.
This workshop introduces Clojure to Java developers who might not have seen a Lisp and don’t yet understand why that’s such an advantage. I introduce the language syntax (what little there is of it), cover interoperability with Java, macros, mutlti-methods, and more. I also cover the functional aspects of Clojure, showing its powerful immutable data structures, working with threads and concurrency, and sequences. Beyond just showing syntax, I also show how to build real applications in Clojure, and give you a chance to do the same. Attending this workshop shows enough to pique your interest and show why many of the people who were interested in Java in 1996 are interested in Clojure now.
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.
ThoughtWorks' Technical Advisory Board creates a "technolgy radar" 3 or 4 times a year. It is a working document that helps the company as a whole make decisions about what technologies are interesting and where we should be spending our time. This is a useful exercise both for you and your company. This session describes the process we use and how to adapt it to both your company and, more importantly, yourself. For career risk mitigation, you must know what the next big thing is, or at least be able to narrow it to a reasonable list. Attendees will leave with tools that enhance your filtering mechanisms for new technology and help you (and your organization) develop a cogent strategy to make good choices.
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. 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. 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.
Distributed version control is all the rage these days, but is it worth it? It has been transformative for the dozens of organizations and thousands of developers that I've mentored on the unique implementation called Git. But don't take my word for it. Discover the joy of a version control system that works for you, not against you, in a hands-on workshop. Bring a Windows, Mac, or Linux laptop and we'll install, set up, use and bend Git into workflows that weren't even possible with the version control systems of yesteryear. Be prepared to rethink how lightweight, fast, and refreshing source code control can be. After completing this workshop you'll be able to do practical work with Git for your day job or weekend OSS hobby
This full day workshop takes you from the ground up with Git. By the end of the day you'll be proficient enough to contribute to an open source project using Git or to leverage inside your corporate as the canonical version control system.
Prerequisite: Knowledge of a version control system, whether that be CVS, SVN, ClearCase, Perforce, StarTeam or Accurev.
You've heard a bit about Git, Gradle, Jenkins, and Sonar, but are you putting them to use? Are you maximizing what they can offer in terms of standardized project models, faster incremental compiles, automated commit-triggered builds, and rapid source code analysis? In this intense presentation, live demonstrations will be given for all of the latest versions of the aforementioned tools and what they have to offer a highly proficient Java developer.
Don't struggle to get the build out, functioning, and analyzed. Develop, build, analyze and deploy smartly and efficiently with a Build Lifecycle Craftsmanship approach and tooling.
You're serious about improving the quality of your code base, but with 10,000 lines of code, where do you start and how do you ensure the greatest ROI for the re-work your team members will perform?
Sonar is an open source tool that brings together the best of breed static and dynamic analysis of Java projects. The result is a unified view of problematic areas of your code on a time-line basis, allowing the team to attack the problems with the best ROI, and maintain a more watchful eye for positive and risky trends in the codebase in the future.
This workshop will get you up and running with Sonar on your laptop and analyzing the source code of a project in under 90 minutes.
Prerequisite: Knowledge of any build tool such as Ant, Maven, Rake, BuildR, Make, Leiningen, or SBT.
You're serious about improving the quality of your code base, but with 10,000 lines of code, where do you start and how do you ensure the greatest ROI for the re-work your team members will perform?
Sonar is an open source tool that brings together the best of breed static and dynamic analysis of Java projects. The result is a unified view of problematic areas of your code on a time-line basis, allowing the team to attack the problems with the best ROI, and maintain a more watchful eye for positive and risky trends in the codebase in the future.
This workshop will get you up and running with Sonar on your laptop and analyzing the source code of a project in under 90 minutes.
Prerequisite: Knowledge of any build tool such as Ant, Maven, Rake, BuildR, Make, Leiningen, or SBT.
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.
Prerequisite: Basic knowledge of a version control system. Subversion knowledge is a plus, but not imperative.
Git is a powerful content tracker and has gained acceptance by many forward leaning consultants and teams over the past several years. Those developers know that it offers the usual commit, branch, merge and tag in a distributed environment, and yet, only a few developers have explored the more powerful functions of Git. These range from searching months of history for a unit-test bug to undoing literally any mistake to splitting in-progress work into multiple commits within a single file.
This talk is targeted at developers who have dabbled with the basics of Git but are aiming to explore, gain productivity secrets, and push the very limits of this life-changing version control system.
Prerequisite: Students must have used Git use in the workplace for several months before attending this talk in addition to setting up Git according to http://teach.github.com/articles/github-class-prerequisites/
Economics, psychology, game theory, and marketing; those fields of study imply a distinct lack of semicolons and curly braces. However, even the venerable Adam Smith, were he alive today, would recognize the applicability of those seemingly tangential components to the business we call software.
Many of us self-identify with the hard core branding of "geek" and "nerd," or the softer choices, "programmer" and "developer." However, we rarely hear mentioned "business person," "saleswoman," salesman," "inventor," "strategist," or "economist," yet they are equally, if not more accurate in the description of the talents of a software craftsperson. Though unstated, we, as developers, are expected to be skilled in each of those areas. Rarely in business are so many combined talents expected from an individual contributor.
Together, we'll harness the secrets that classical and 20th century research have uncovered from observing strategic interactive decision making through a large lens. Surprisingly, smart businesses and crafty developers are just now able to fully leverage these historical findings with the advent of commodity big-data processing, machine learning, evolutionary game theory, and a dash of intuition. All of these tactics can be neatly tied together via the occasionally-maligned threads of pop psychology and behavioral economics. Discover how to seat these newfound applications of knowledge in their well-deserved place at the table of computer science for better playing of the game that we call "programming."
You're a talented coder and you apply many agile practices to your daily workflow. Still, you are looking for that next boost to better keep track of information, manage your open applications, make working with the terminal more productive, recall information quickly, manage files rapidly, and produce documentation in a portable and effective manner.
This presentation will show you how to apply DevonThink, Delicious bookmarks, RSS feeds, Pinboard.in, Pomodoro, Things, LaunchBar, Bash profiles, mind maps, markdown files and spotlight filters to become a more productive developer that has a world of information sorted and accessible at a moment's notice.
This presentation focuses on developers using the Mac platform (though a few tips are portable) since Matthew has significant experience in productivity research on this platform.
Prerequisite: Very basic developer proficiency on the Mac.
There's a ton of options for deploying to the cloud right now. Heroku and Engineyard are among the well known Platform as a Service (PaaS) providers. What if you don't want to use these PaaS services? What if you don't know which one is better? Are they cost effective? What about private deployments into internal infrastructure? This session answers these questions with a discussion of PaaS services and setting up your own PaaS using CloudFoundry.
There's a ton of options for deploying to the cloud right now. Heroku and Engineyard are among the well known Platform as a Service (PaaS) providers. What if you don't want to use these PaaS services? What if you don't know which one is better? Are they cost effective? What about private deployments into internal infrastructure? This session answers these questions with a discussion of PaaS services and setting up your own PaaS using CloudFoundry.
Creating a web site, web app, or native app for mobile use presents a special set of challenges. Specifically, developers and designers should be zoned into the techniques for usability - and usability can be enhanced greatly by taking performance elements into consideration up-front. In this session, we explore the many performance tips and tricks you can employ to make your website or web app or native app shine on mobile devices. This is an advanced course that discusses issues such as image loading, JavaScript performance, and wireless latency.
Creating a web site, web app, or native app for mobile use presents a special set of challenges. Specifically, developers and designers should be zoned into the techniques for usability - and usability can be enhanced greatly by taking performance elements into consideration up-front. In this session, we explore the many performance tips and tricks you can employ to make your website or web app or native app shine on mobile devices. This is an advanced course that discusses issues such as image loading, JavaScript performance, and wireless latency.
You've got a great idea for a mobile app. You have a team together. You're building the killer app. Do you know enough about the various app stores to know what to do next? How about pricing strategies for iOS and Android? Have you thought about the Nook Color and Amazon Fire? In this session, I'll bring my experience as CTO of TripLingo, an awesome company developing foreign language learning apps. TripLingo has been featured on the iOS store a dozen times, as well as the Android market and Nook store.
You've got a great idea for a mobile app. You have a team together. You're building the killer app. Do you know enough about the various app stores to know what to do next? How about pricing strategies for iOS and Android? Have you thought about the Nook Color and Amazon Fire? In this session, I'll bring my experience as CTO of TripLingo, an awesome company developing foreign language learning apps. TripLingo has been featured on the iOS store a dozen times, as well as the Android market and Nook store.
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.
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.
Enterprise Architecture (EA) is one of the most misunderstood terms in our industry. Ask 10 people what EA is and you will get 10 different answers. To better understand what EA is and how it impacts your company (and you!) we will go back in time to maritime Britain in the late 1700's. Through exercises in designing a fleet of war ships and making decisions about what to do with the fleet you will understand the various approaches, directions, and implications of EA and how necessary EA is to achieve any company goal. So put your admirals hat on and climb aboard this workshop for a maritime adventure you won't forget!
Workshop Agenda:
Very few applications stand alone anymore. Rather, they are combined together to form holistic systems that perform complex business functions. One of the big challenges when integrating applications is choosing the right integration styles and usage patterns. In this session we will explore various techniques and patterns for application integration, and look at what purpose and role open source integration hubs such as Camel and Mule play in the overall integration architecture space (and how to properly use them!). Through actual integration scenarios and live coding examples using Apache Camel you will learn which integration styles and patterns to use for your system and how open source integration hubs play an part in your overall integration strategy
Agenda:
Whether developer, designer, or architect, we are all presented with problems and work to find a way to solve them, usually through technology. In my opinion this is what makes this industry so much fun. Let's face it - we all love challenges. Sometimes, however, the problems we have to solve are hard - really hard. So how do you go about solving really hard problems? That's what this session is about - Heuristics, the art of problem solving. In this session you will learn how to approach problems and also learn some the common techniques for solving them effectively. So put on your thinking cap and get ready to solve some easy, fun, and hard problems.
Agenda:
Prerequisite: An open mind and a willingness to learn how to better approach and solve problems
Advanced Message Queuing Protocol (AMQP) is a new way of looking at messaging that is quickly gaining in popularity and use, particularly in the financial services industry. Unlike JMS, which defines a standard API across platforms, AMQP defines a standard wire-level protocol across languages and platforms, finally making true cross-platform messaging a reality. In this session I will start by describing exactly what AMQP is and what problems it specifically solves (that JMS can't!). I will then describe the basic architecture and how AMQP routes messages, and then, through live interactive coding, demonstrate how to build a simple producer and consumer using RabbitMQ to send and receive AMQP messages. We will then take a brief look at other aspects of AMQP such as performance, load balancing, and handling undelivered messages.
Agenda: - What is AMQP and what problems does it solve? - How AMQP works: exchanges, bindings, queues, and routing - AMQP exchange types - AMQP message structure - Sending and receiving messages using RabbitMQ - AMQP Performance characteristics - Handling Undelivered Messages
Prerequisite: Basic knowledge of messaging in general
If you need your messaging-based systems to be fast - really fast - then this is the session to attend. In this session I will introduce and demonstrate some relatively simple tips and tricks to get the best performance and throughput from your messaging system. Through live code demonstrations I will show the impact of both configuration and design changes using Spring JMS, ActiveMQ, and RabbitMQ. So buckle up those seat belts - its going to be a fast ride.
Agenda:
Prerequisite: Some knowledge of JMS messaging and messaging systems in general
The ancient Chinese warrior Sun Tzu taught his men to "know your enemy" before going into battle. For us, the same thing is knowing and understanding anti-patterns - things that we repeatably do that produce negative results. Anti-patterns are used by developers, architects, and managers every day, and are one of the main factors that prevent progress and success. In this session we will look at some of the more common and significant software development anti-patterns. Through coding and design examples, you will see how these anti-patterns emerge, how to recognize when the antipattern is being used, and most importantly, how to avoid them. Although most of the coding examples will be in Java, this is a technology-agnostic session.
Agenda
For each anti-pattern covered in this session we will look at the symptoms of the anti-pattern, what the effects are, and some techniques on how to avoid the anti-pattern.
Successful projects require any number of practices but if you don't know who you're building it for or what you're supposed to build, failure is a distinct possibility. How do we capture the who and what? Personas and story maps are two effective techniques that you can leverage. After discussing the basics, we'll break into small groups and you'll have a chance to actually try building a set of personas as well as a story map.
Personas are a time tested technique to help teams understand their users and facilitate building the right interface. While personas are often backed by extensive ethnographic research, they don't require months and months of effort.
Of course just knowing who we're building for is only part of the picture, we have to know what our users are trying to do. Wether you favor use cases, user stories or more traditional requirements documents, at the end of the day our customers are using our application to further some other goal.
You're all over jQuery - you write plugins in your sleep - and before that, you were a Prototype ninja. Your team treats JavaScript like a first class citizen, you've even written more tests than Kent Beck. Is that all there is in the land of the JavaScript developer? Believe it or not, the JavaScript party hasn't stopped. What other libraries are out there? What do they offer? This talk will survey the field of modern JavaScript libraries getting you up to speed on what's new. We'll dive in just deep enough to whet your appetite on a wide variety of libraries such as Backbone, Underscore, Zepto and more.
You're all over jQuery - you write plugins in your sleep - and before that, you were a Prototype ninja. Your team treats JavaScript like a first class citizen, you've even written more tests than Kent Beck. Is that all there is in the land of the JavaScript developer? Believe it or not, the JavaScript party hasn't stopped. What other libraries are out there? What do they offer? This talk will survey the field of modern JavaScript libraries getting you up to speed on what's new. We'll dive in just deep enough to whet your appetite on a wide variety of libraries such as Backbone, Underscore, Zepto and more.
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 talk 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.
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 talk 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.
Mobile is the next big thing and your company needs to there. But what does there actually entail? Should you build a native app? On which platforms? Do you have the skills for that? What about the web? Can you deliver an awesome experience using nothing but a mobile web browser? This talk will help you navigate these treacherous waters. We'll discuss the pros and cons of the various approaches and give you a framework for choosing.
Mobile is the next big thing and your company needs to there. But what does there actually entail? Should you build a native app? On which platforms? Do you have the skills for that? What about the web? Can you deliver an awesome experience using nothing but a mobile web browser? This talk will help you navigate these treacherous waters. We'll discuss the pros and cons of the various approaches and give you a framework for choosing.
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.
Interested in HTML5? Want a change to play around with the latest and greatest in web app development? This workshop is for you! We'll cover feature detection, web forms, the new HTML elements, take a spin around the canvas, and we'll finish up with offline/local storage and web sockets.
Detecting 101 Before you can take advantage of a new HTML5 feature, you have to make sure a given browser can support it. This section will cover the basics of detection as well as getting the most out of rocking cool libraries like Modernizer. We'll also look at just what to do when a browser doesn't support a feature you're trying to leverage.
New elements Along with a new human type-able doctype, HTML5 introduces several new semantic elements. Recognizing that nearly every website in existence has a header, a footer and some navigation divs, HTML5 gives us a header, a footer and a nav element along with a few others. HTML5 seeks to pave cowpaths, not force the web to bend to its ways...
Canvas One of the most exciting features of HTML5 is the canvas, a space you can use to draw anything from shapes to text to, well, anything! From basic drawing to graphs to full fledged games, canvas opens up a whole new world of possibility, a world sans browser plugins.
Local Storage Web apps are, in many cases, indistinguishable from their thick client brethren, at least if you're not on an airplane. OK, so many planes have wifi, but there are parts of the world that don't have reliable Internet connections! Thanks to local storage and the offline API, all is not lost - you can create a web app that works offline.
Web sockets and web workers Ajax is like so many things in the web world - a simple (but very powerful) hack that isn't defined by a spec. With the advent of the web socket API, we'll finally have a native way to have bi-directional communication with the server. As we create richer and richer clients, we're writing more and more JavaScript. While the JS engines are getting faster and faster, there are cases where it'd be very handy to run scripts in the background. Web workers give us just such an opportunity.
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.
As a web application developer, most of the focus is on the user stories and producing business value for your company or clients. Increasingly however the world wide web is more like the wild wild web which is an increasingly hostile environment for web applications. It is absolutely necessary for web application teams to have security knowledge, a security model and to leverage proper security tools.
This training workshop on security will provide an overview of the security landscape starting with the OWASP top ten security concerns with current real world examples of each of these attack vectors. The first session will consist of a demonstration and labs using hacker tools to get an understanding of how a hacker thinks. It will include a walk through of the ESAPI toolkit as an example of how to solve a number of these security concerns including hands-on labs using the OWASP example swingset.
The workshop will include several hands on labs from the webgoat project in order to better understand the threats that are ever so common today.
Attendees will come away with the following skills / capabilities: - threat modeling - security audit plan - introduction to Pen testing - key / certificate management - fixing web application security issues
Don't be the weakest link on the web!
For decades object-oriented programming has been sold (perhaps over sold) as the logical programming paradigm which provides “the way" to software reuse and reductions in the cost of software maintenance as if it comes for free with the simple selection of the an OO language. Even with the renewed interests in functional languages, the majority of development shops are predominately using object-oriented languages such as Java, C#, and Ruby. So most likely you are using an OO language… How is that reuse thing going? Is your organization realizing all the promises? Even as a former Rational Instructor of OOAD and a long time practitioner, I find great value in returning to the basics. This session is a return to object-oriented basics.
This session is intended to balance the often-touted theoretical object-oriented practices with lessons from the real world. The session will start with a review of some of the basics regarding abstractions and encapsulation. Although simple concepts, we will push the boundary of how these techniques are applied. We will discuss the difference between analysis and design and how that is reflected in our code. We will also look at the limitations of Java the language as outlined in Josh Block’s book “Effective Java”. The session will go past the basics of object-oriented principles and into what our true goals of development really are.
In the words of John Gage, "The network is the computer". At the heart of everything we do is a complex system of infrastructure from which we are often abstracted. For general application development this abstraction provides the convenience of simplifying our efforts. With a growing number of mobil applications with intermittent connectivity and higher latency, and with increased hostility on the network from a security standpoint, there is great value in pulling back the curtain and understanding the details of this computer.
This session will start with the underlying understanding of networking at a low level. At this level we will discuss, IP, MAC, ARP, DNS and DHCP. As we walk up an abstraction level, we discuss sockets, NAT, gateways and firewalls along with the use of TCP and UDP. Spending some time at this layer can make network developers more productive, as we look at tools which help us answer the question, "who owns this port?", "where is this packet going?" and "What is my latency and why?".
The session will end with a little fun looking at wifi, where will we sniff, snort, crack:) From a security stand point we will look at the challenges of wifi and how it has become the weakest component on the net.
This session is extremely fast-pace. The attendees will come away with a more enhanced understanding of the this thing we call the internet. It will include through discussion or demonstration tools such as tcproute, tcpdump, nemesis, nmap, tcpmon and wireshark.
Of all the non-functional requirements of software development, complexity receives the least attention and seems to be the most important from a long term standard point. This talk will look at some of forces that drive complexity at the code level and at a system level and their impact. We will discuss what causes us to over look complexity, how our perception of it changes over time and what we can do about it?
In this session we will break down the meaning of complexity and simplicity and measure the application of those means against the common software development dogma. Looking at common development trends and pressures, we'll discuss where simplify does and doesn't help. We will examine areas of development which at first glance seem to be simple (such as the creation of an equals method in Java), that end up being difficult or impossible based on normal constraints. We will example the drivers of complexity with some discussion on what you can do about it. This session will finish with a discussion around several challenges to high scale software architectures and how to keep it simple.
Google “MongoDB is Web Scale” and prepare to laugh your tail off. With such satire, it easy to pass off MongoDB as a passing joke… but that would be a mistake. The humor is in the fact there seems to be no end to those who parrot the MongoDB benefits without a clue. This session is about getting a clue.
Get past the hype and hyperbole associated with NoSQL. This session will introduce MongoDB through live working sessions demonstrating the pros and cons of MongoDB development. The session will then focus on a recent short project focused on large scale. We’ll discuss database design to support high scale read access. Throughout this case study we will discuss the consequences of the MongoDB choice. The session will finish with a review of the production topology to support growth in scale.
The net has cracks and crackers are among us. With all the news of security failures, it can be a challenge to know what is FUD and what is really at risk and to what extent. This session isn’t about hacking an application together nor is it about coding a solution. It is about looking at the network and network infrastructure and understanding some of its weaknesses. This workshop is a 50% mix of lecture / discussion and hands on attacking in order to best understand the challenges.
The labs will require the use of: - a virtual machine with BackTrack 5 - a wifi adaptor - and a laptop.
We will have ISO installations of BackTrack 5 for you to install on your VM. It is best if you have this pre-installed, it can be downloaded at http://www.backtrack-linux.org/ . In order to run backtrack, you will want to install this to a virtual machine, if this is new to you, pick up virtualbox or vmware.
The wifi adaptor needed is an Alfa AWUS036H or Alfa AWUS036NHA. You will need 1 of these external adaptors. There are ~ $30 at amazon.
Through the labs we will: - Disassociate wireless traffic - Crack a WEP key - Learn to break through a WPA device - Scan for open ports
The net has cracks and crackers are among us. With all the news of security failures, it can be a challenge to know what is FUD and what is really at risk and to what extent. This session isn’t about hacking an application together nor is it about coding a solution. It is about looking at the network and network infrastructure and understanding some of its weaknesses. This workshop is a 50% mix of lecture / discussion and hands on attacking in order to best understand the challenges.
The labs will require the use of: - a virtual machine with BackTrack 5 - a wifi adaptor - and a laptop.
We will have ISO installations of BackTrack 5 for you to install on your VM. It is best if you have this pre-installed, it can be downloaded at http://www.backtrack-linux.org/ . In order to run backtrack, you will want to install this to a virtual machine, if this is new to you, pick up virtualbox or vmware.
The wifi adaptor needed is an Alfa AWUS036H or Alfa AWUS036NHA. You will need 1 of these external adaptors. There are ~ $30 at amazon.
Through the labs we will: - Disassociate wireless traffic - Crack a WEP key - Learn to break through a WPA device - Scan for open ports
Whether you are just getting started, or you’ve made an attempt and well… it could be better… a lot better, this session is for you. Ken has been working on Agile projects as a coach and mentor for a number of years. Come discover the common reasons teams fail to get it right. Bring your own challenges and lets discuss. This is set to be an engaging and illuminating discussion.
This can be a dynamic discussion where challenges facing attendees may have us to focus on some areas and tips of agile development. We will certainly talk about how team or management choices to deviate from core agile practices add risk to a project with suggestions on how to resolve many of these challenges.
The agile focus of software development puts heavy focus on user requirements through user stories. However we can not lose sight of the non-functional requirements as well. The software could be written to the exact specification and desire of the user, however if it takes 5 minutes for a request response, or it only supports 2 users or it isn't secure, then we still haven't done our jobs as developers.
This session will focus on the non-functional requirements of software development, namely: Performance, Scalability, Security, and Software Monitoring and Management. Each subject area discussion will include, goals, design practices, tools, and where it fits in the software development life-cycle.
When it comes to cross cutting software concerns, we expect to have or build a common framework or utility to solve this problem. This concept is represented well in the Java world with the loj4j framework, which abstracts the concern of logging, where it logs and the management of logging. The one cross cutting software concern which seems for most applications to be piecemeal is that of security. Security concerns include certification generation, SSL, protection from SQL Injection, protection from XSS, user authorization and authentication. Each of these separate concerns tend to have there own standards and libraries and leaves it as an exercise for the development team to cobble together a solution which includes multiple needs.... until now... Enterprise Security API library from OWASP.
This session will look at a number of security concerns and how the ESAPI library provides a unified solution for security. This includes authorization, authentication of services, encoding, encrypting, and validation. This session will discuss a number of issues which can be solved through standardizing on the open source Enterprise Security API.
We are far from the early days of ugly HTML. We have sophisticated visualization tools available to us now to help our users consume complex data in attractive and informative ways.
Come hear how you can adopt these visualization systems (calling them libraries is inappropriate) today.
This talk will introduce:
The premise of Nicholas Carr's "Does IT Matter?" book was that if everyone uses the same tools, processes, products, etc., is there any competitive advantage to be had from the average IT organization?
NetKernel represents a fundamentally different approach to building systems. It takes what we like about Unix, REST and SOA and mixes it together. It inexplicably changes everything while allowing you to reuse existing code, services and libraries. Not only can it make building the kinds of systems you are building today easier, it does it more efficiently, with less code and a far more scalable runway to allow you to take advantage of the emerging multi-core, multi-CPU hardware that is coming our way.
This workshop will be a deeper dive into Resource-Oriented Computing with NetKernel. We will explore:
It is rare that a technology comes along that is both revolutionary and lets you reuse what you already know. All it takes is a bit of different thinking and a little courage to try something new.
The premise of Nicholas Carr's "Does IT Matter?" book was that if everyone uses the same tools, processes, products, etc., is there any competitive advantage to be had from the average IT organization?
NetKernel represents a fundamentally different approach to building systems. It takes what we like about Unix, REST and SOA and mixes it together. It inexplicably changes everything while allowing you to reuse existing code, services and libraries. Not only can it make building the kinds of systems you are building today easier, it does it more efficiently, with less code and a far more scalable runway to allow you to take advantage of the emerging multi-core, multi-CPU hardware that is coming our way.
This workshop will be a deeper dive into Resource-Oriented Computing with NetKernel. We will explore:
It is rare that a technology comes along that is both revolutionary and lets you reuse what you already know. All it takes is a bit of different thinking and a little courage to try something new.
The Web is changing faster than you can imagine and it is going to continue to do so. 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.
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 provide you with the understanding of a technological tidal wave that is heading in your direction.
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, DOAP Query RDF and non-RDF datastores with the SPARQL query language Model and Do Inference with the Web Ontology Language (OWL)
Bring your laptops. This is a hands-on workshop.
The Web is changing faster than you can imagine and it is going to continue to do so. 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.
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 provide you with the understanding of a technological tidal wave that is heading in your direction.
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, DOAP Query RDF and non-RDF datastores with the SPARQL query language Model and Do Inference with the Web Ontology Language (OWL)
Bring your laptops. This is a hands-on workshop.
In this session, Grails core developer Jeff Brown will deliver an update on the latest and greats features of the Grails framework - a dynamic, web application framework based on the Groovy language and designed for Spring.
Jeff will cover all the new features of Grails 2.0 including agent-based reloading, unit testing mixins, really powerful new ways to express GORM queries and more. Attendees will gain key knowledge of the latest techniques for building Grails applications on the Spring platform.
Grails represents technology that offers great flexibility and power without the complexity introduced by other Java web application frameworks. Custom tag libraries are a snap. GSP Templates provide a simple mechanism for reusing UI elements. Sitemesh is integrated to help provide a consistent presentation across the entire application. GORM is super powerful ORM. Grails provides simple mechanisms for leveraging the power of Ajax.
This session will cover all of the fundamentals of the framework and will serve as a thorough introduction to developers not familiar with the framework and also include a number of tips and tricks for developers who do have experience with the framework.
Grails represents technology that offers great flexibility and power without the complexity introduced by other Java web application frameworks. Custom tag libraries are a snap. GSP Templates provide a simple mechanism for reusing UI elements. Sitemesh is integrated to help provide a consistent presentation across the entire application. GORM is super powerful ORM. Grails provides simple mechanisms for leveraging the power of Ajax.
This session will cover all of the fundamentals of the framework and will serve as a thorough introduction to developers not familiar with the framework and also include a number of tips and tricks for developers who do have experience with the framework.
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.
.
Scala is a statically typed, fully OO, hybrid functional language that provides highly expressive syntax on the JVM. It is great for pattern matching, concurrency, and simply writing concise code for everyday tasks. If you're a Java programmer intrigued by this language and are interested in exploring further, this section is for you.
We will go through a rapid overview of the language, look at its key strengths and capabilities, and see how you can use this language for your day-to-day programming. This session will be coding intensive, so be ready for some serious Scala syntax and idioms.
I call the JDK concurrency API as the synchronize and suffer model. Fortunately, you don't have to endure that today. You have some nice options, brought to prominence on the JVM by Scala and Clojure.
In this workshop, learn how to program with Actors and STM using Akka, a powerful and popular library created using Scala but usable from any language on the JVM. You have a choice to pick the language you like in this workshop, and learn how to use these powerful concurrency models.
I call the JDK concurrency API as the synchronize and suffer model. Fortunately, you don't have to endure that today. You have some nice options, brought to prominence on the JVM by Scala and Clojure.
In this workshop, learn how to program with Actors and STM using Akka, a powerful and popular library created using Scala but usable from any language on the JVM. You have a choice to pick the language you like in this workshop, and learn how to use these powerful concurrency models.
You can program higher order functions in Groovy quite easily using closures. But the benefits of closures go far beyond that. Groovy has a variety of capabilities hidden in closures.
In this presentation, we will unlock that treasure and explore ways in which we can design applications using Groovy closures, to apply different design patterns, to create fluent interfaces, and even program asynchrony.
JavaScript is one of those very powerful languages that is often misunderstood and underutilized. It's quite popular, yet there's so much more we can do with it.
In this presentation we'll deep dive into the capabilities and strengths of this prominent language of the web.
Programmers often complain that it is hard to automate unit and acceptance tests for JavaScript. Testability is a design issue and with some discipline and careful design we can realize good automated tests.
In this presentation we'll learn how to automate the testing of JavaScript using both TDD and BDD tools.
Domain Specific Languages have two main characteristics, fluency and context. Creating external DSLs has the advantage of good validation. However, we have to struggle with parsers. Internal DSLs offer the benefit of using the language as the host and its compiler as the parser. For a language to be a host, it needs two important characteristics: low-ceremony and metaprogramming.
In this workshop you will learn how to create internal DSLs using Groovy metaprogramming and scripting techniques. We will start with a short warmup of metaprogramming techniques and then dive into creating DSLs.
Domain Specific Languages have two main characteristics, fluency and context. Creating external DSLs has the advantage of good validation. However, we have to struggle with parsers. Internal DSLs offer the benefit of using the language as the host and its compiler as the parser. For a language to be a host, it needs two important characteristics: low-ceremony and metaprogramming.
In this workshop you will learn how to create internal DSLs using Groovy metaprogramming and scripting techniques. We will start with a short warmup of metaprogramming techniques and then dive into creating DSLs.
After 9 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 start with a poorly written Spring application and work our way through it, bringing it up to speed with the techniques encouraged by the most recent versions of the Spring Framework and other Spring projects.
After 9 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 start with a poorly written Spring application and work our way through it, bringing it up to speed with the techniques encouraged by the most recent versions of the Spring Framework and other Spring projects.
Web security is nothing new. As users of the web, we're all accustomed to entering our usernames and fumbling to recall our passwords when trying to access private data on one of the many online services we use. But while traditionally web security could be described as a two-party process between a web application and a user, the modern web involves applications that seek to access other applications on behalf of their users. This presents some new challenges in keeping a user's sensitive data secure while still allowing a the third party application to access it.
OAuth is an open standard for authorization, supported by many online services, that allows one application to access a user's data in another application, all while giving the user control of what information is shared.
In this session, we'll look at OAuth, focusing on OAuth 2, from the perspective of an application that consumes an OAuth-secured API as well as see how to use OAuth to secure your own APIs.
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 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.
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.
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.
In this session, we'll start with an empty directory and use Spine.js to create an interactive client-side web application. Then we'll leverage what we learned to build a mobile web application with a native feel that can be deployed either through a phone's web browser or via native wrapper frameworks such as Apache Cordova (aka, PhoneGap).
Model View Controller (MVC) is often thought of in terms of server-side frameworks such as Spring MVC and Struts. But as web applications become more interactive, it becomes important to apply the same principles in the client. Roll-your-own MVC in JavaScript is possible, but as was the case with server-side MVC frameworks, it can get messy and is often better to seek out help from established frameworks.
Recently, several JavaScript-based microframeworks have emerged to address these concerns in the browser. Spine.js is one such framework that brings MVC to the client-side of web development. Based in CoffeeScript, Spine.js stands out due to its simplicity and a programming model resembling that of Rails and Grails. Also, unlike many other client-side MVC frameworks, Spine.js has a clear and well-paved path to mobile application development.
We have seen quite a few larger projects for which a naive practice of early integration between the components lead to constant breakages. Thus they were not capable to successfully build a new version of the software stack for days or even weeks. Obviously the problem of that is dramatic as no regular manual testing and capacity testing is taking place. Not only is this a massive waste of testing resources, it also leads to very long and therefore expensive feedback cycles that severely affect your time-to-market of new features. It also a likely source of conflict between the CI team and software development, as with no other means at hand, there is a desire to create stability by not adding new features or doing important refactoring.
We will present patterns on how to integrate as early as possible but at the same time keep the delivery pipeline of new features flowing. Obviously automation can't solve all the problems of software development. But it can for example help to shield against pockets of problematic pieces of software. With a good reporting it can also give valuable insights into potential organizational problems.
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.
How many times have you wanted to start a new project in Java, 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 EE." Well, it is!
JBoss Forge can take you from 0 to Java web application 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 Tools for development, Arquillian for testing, and JBoss AS 7 for local deployment and OpenShift for cloud deployment. You can even switch seamlessly between Forge and the Eclipse-based JBoss Developer Studio. Together, let's build a real application, test it, extend it, and deploy it locally and to the cloud!
Our industry is at a major turning point; moving away from waterfall-style development methodologies and toward lighter-weight, Lean-Agile development. This brings great promise. However, it also creates interesting questions. What is the role of design in an Agile process? How much design is enough, and how much is over-design? Are patterns still relevant, with TDD and refactoring gaining momentum throughout the industry?
Emergent Design is an integration of patterns, testing, and refactoring that enables the strong synergy of these disciplines to empower teams to be more effective in a responsive, agile environment. This seminar will be given by the author of the book “Emergent Design”, Scott Bain.
Test-Driven Development has gained a strong foothold among many development teams, but as popular as it has often become, many organizations struggle to keep the testing effort sustainable over a long period of time. As test suites become large, they tend to become significantly difficult and time consuming to maintain, which is required to keep the TDD effort alive. Similarly, disciplined refactoring skills have become, for many, an essential part of a development team's toolkit, especially when confronted with large amounts of legacy code. However, the effort it can take to refactor a system can be difficult to weigh against the business value of new development; spending time on one would seem to limit the time spent on the other.
The purpose of this presentation is to create a context for TDD and refactoring focusing on those specific elements that allow them to be conducted in a sustainable way. Much of this seminar is based on the work being described at Sustainable Test-Driven Development.
The key to User Stories is making sure your related practices are just enough, just in time.
We'll discuss the different levels of the User Story life cycle, as well as the entrance and exit criteria for each level. More importantly, we'll discuss which levels are totally optional(many of them are) and which are absolutely vital to maximizing User Story value. We'll also follow an example story through the entire life cycle as it progresses from the request level to an epic, to themes, and finally to the legacy lifecycle level.
Acceptance Testing, also known as Story Testing, is a practice that can be applied to any software project, Agile or not. However, to achieve the Agile vision of "working software over comprehensive documentation," it's very important that acceptance tests are easily automated, resulting in a phenomenon you may have heard of, called the "Agile Specification."
In this presentation, we'll discuss eight different patterns of expressing acceptance tests so that they are easy to execute and automate. We'll talk about popular patterns like Given/When/Then and Specification by Example, as well other patterns you've probably never seen. Along with delving into the mechanics of each pattern and showing examples, we'll also discuss the most appropriate situations and team contexts to apply each pattern. Attendees will participate in interactive exercises that will teach them how to utilize the patterns, as well as how to pick the patterns most appropriate for the type of requirement being tested.Expressing Acceptance Tests up front, before development begins, is a vital part of Acceptance Driven Development and the executable Agile Specification.
Some years ago "alternative" programming languages for the JVM lived mostly in research labs and garages, industry knew about some of them, sometimes even used them, but never produced them. Recently, the trend has changed: new languages are backed by industrial vendors. To put it another way: the time has come for a new JVM language, and there are a few projects competing in this field. One of them is Kotlin, backed by JetBrains, a leading IDE vendor.
Kotlin is a modern statically typed language targeting JVM and JavaScript and intended for industrial use. The main goal behind this project is to create a language that would be a good tool for developers, i.e. will be safe, concise, flexible, 100% Java-compatible and well-supported by IDE and other tooling. Kotlin is an open-source project started developed JetBrains with the help of the community.
This session demonstrates the key features of Kotlin and provides a comparison to other "alternative" JVM languages.
Among others things, it covers * Static null-safety * Extension functions * Higher-order functions and type-safe builders * Smart casts: Kotlin's lightweight pattern matching * Making Java APIs better with Kotlin * Developing mixed Kotlin/Java projects
To find out more about Kotlin, please refer to http://kotlin.jetbrains.org
You may have heard about cloud storage offerings such as Amazon S3, OpenStack or Microsoft Azure. While conceptually similar, these offerings have different apis and behaviour that place the "write once (run|test) anywhere" mantra at risk. The jclouds open source java and clojure library aims to eliminate cloud vendor lock-in, exposing easy to use, portable, and powerful APIs. Bring your laptop, armed with latest revs of Eclipse, git, and maven, and we'll walk through getting you setup to hack jclouds java or clojure BlobStore applications in a collaborative fashion.
During this workshop, you'll discover the value and key gotchas of cloud storage providers first hand. By the end of this session, you'll be writing testable code that creates and manages containers and blobs, and understand how cloud storage can fit into your architecture.
You may have heard about cloud storage offerings such as Amazon S3, OpenStack or Microsoft Azure. While conceptually similar, these offerings have different apis and behaviour that place the "write once (run|test) anywhere" mantra at risk. The jclouds open source java and clojure library aims to eliminate cloud vendor lock-in, exposing easy to use, portable, and powerful APIs. Bring your laptop, armed with latest revs of Eclipse, git, and maven, and we'll walk through getting you setup to hack jclouds java or clojure BlobStore applications in a collaborative fashion.
During this workshop, you'll discover the value and key gotchas of cloud storage providers first hand. By the end of this session, you'll be writing testable code that creates and manages containers and blobs, and understand how cloud storage can fit into your architecture.
Key/value stores are the most common storage offerings in the cloud today. While conceptually similar, BlobStores present different programming models and consistency models that must be considered in application design. After this session, you'll understand these differences, and know how to use jclouds to avoid cloud lock-in and increase testability without restricting access to cloud-specific features.
We'll start by comparing public cloud services like Amazon S3 or Microsoft Azure and private cloud software like OpenStack Swift or Eucalyptus Walrus from a feature and code/API level. We'll then review java and clojure calls to the open source jclouds BlobStore API, abstracting away these differences. We'll finish with a review of integration patterns in production today you can consider while designing your cloud architecture.
Whether it's HBase, Cassandra or one of the many others, you've probably already heard about NoSQL. Perhaps you have a continuous test flow dependency, yet are concerned about learning curve or infrastructure required for the NoSQL store you need.
During this talk, you'll see how you can transform infrastructure clouds such as Amazon EC2 or GoGrid into your data cluster using Apache Whirr.
We'll start by reviewing cloud provisioning and how Whirr adds service management to the underlying jclouds ComputeService API. You'll then learn whirr syntax and how to use it from the commandline or via a Java API. Finally, we'll discuss patterns for workflow integration. When you leave, you'll know how to setup and use NoSQL stores with a lot less work.
One of Gradle's attractive features is that plugins are extremely simple to write and can do anything. Gradle plugins can add new functionality, enhance existing functionality or even remove undesired functionality. If you've ever wanted to write a Gradle plugin, or are interested in the deep details of plugins, then this session is for you.
In this session we'll explore some fundamental concepts that can be used as guidelines when developing plugins and new Gradle functionality, and the role of plugins and how they can be used.
We'll look at issues such as; how to implement flexible tasks, how to support convention over configuration while maintaining flexibility, how to structure plugin stacks, building and distributing plugins and testing your plugins. We'll be developing a sample plugin during the session and discussing other real world example plugins.
So you already know and love Spock, the Enterprise ready testing framework, but want to know how to make the most of it and take your testing to the next level? Then this talk is for you. Even if you're new to Spock, but are interested in making your testing more effective this talk is for you.
Spock has many hidden gems which we'll be going through in this session. We'll also be looking at some of the upcoming features in Spock 0.7 including; functionality and contract mixins, improved configurability, and several new lumps of syntax sugar.
JavaScript is playing an ever increasing role in modern web applications. This is having an impact on the way be automate the building of our applications as JavaScript introduces new challenges such as magnification, unification and even compilation of languages such as CoffeeScript.
In this session we'll look at how the Gradle build tool can help you test your JavaScript and transform your raw assets into optimised, deployment ready, units.
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 go beyond an introduction and explore how to take advantage of Geb's advanced features to functionally test modern rich, dynamic, web applications. We'll also explore some common patterns and best practices for Page Object modelling that lead to robust tests with a high level of reuse. Finally we'll discuss cross browser testing strategies and explore the options for testing mobile device targeted sites. A basic understanding of Geb is required for this session.
Real world applications, there is more to SOA and scaling systems than just dropping some XML files into a file area and applying XSLT style-sheets, you still need some old-fashioned engineering.
When you start building complex SOA applications, there will be a few key factors that you’ll see in larger systems, they are usually not addressed in current texts or documentation, they are complicated; but to really win with asynchronous solutions, you need to be able to
· Build State Machines · Have Conversational patterns · Realize how you can cluster aggregations and complex patterns · Know when to transact and where it really doesn’t matter.
No matter what you plan to do in your enterprise integrations efforts, it is likely you'll at the very least peak at an ESB solution. To really achieve results while using an ESB you need to start building
Imagine you are the new CTO for virtualtourist.com and just been acquired by Tripadvisor. You are given 4 mid level software engineers 8 million monthly unique visitors, and the following running environment: No automated deployment, PHP batch jobs, PHP forum, Java servlet based home grown framework, WebObjects server talking to JBOSS EJB (Entity Beans {CMP}), and everyone writes and tests code on the "staging" server. Now what?
In this session I will walk through the various enterprise and application architectural decisions that we faced and the give the audience the chance to make choices for themselves.
How do you handle 9 million monthly unique visitors with Grails? Build pages using concurrency, SOLR, SQUID, and RESTful services on Grails, that's how!
In this session we will cover cutting edge use of Grails in a SOA environment to serve sub-second page delivery, best practices and lessons learned so far at Virtualtourist.com
Java/J2EE looking for something better but not sure if you can sell paying the price of a new language/framework? Not sure if Grails will work in YOUR environment?
In this session we will talk about real world application of grails in an enterprise, lessons learned and best practices.
Do you want to learn more about Mockito framework directly from the founder? Join the workshop and get up to speed with: - principles of interaction testing - using test spies to drive the design and high quality production code - getting most of the test spy pattern to produce readable and maintainable tests - solutions to typical unit testing challenges with regards to mocking - Mockito features and patterns along with the use cases when they are most useful
See you at the workshop! Please take your laptop so that you can code the exercises in your own, most friendly environment.
Do you want to learn more about Mockito framework directly from the founder? Join the workshop and get up to speed with: - principles of interaction testing - using test spies to drive the design and high quality production code - getting most of the test spy pattern to produce readable and maintainable tests - solutions to typical unit testing challenges with regards to mocking - Mockito features and patterns along with the use cases when they are most useful
See you at the workshop! Please take your laptop so that you can code the exercises in your own, most friendly environment.
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.
The last decade has seen an explosion in the number of languages targeting the Java runtime. Amongst these, one of the (arguably) strong contenders is JRuby - a 100% Java port of the Ruby language. Ruby aims to make programmers "happy", and with JRuby you can find happiness without having to leave your favorite runtime! JRuby also provides deep integration with Java, allowing you to leverage existing Java libraries while writing code that is succinct, elegant and beautiful.
In this hands-on workshop we will talk about JRuby the language, explore it's syntax and constructs like classes and modules. We will discuss advanced topics like meta-programming and domain specific languages, see how we can write Java applications without writing Java code, and some potential gotchas.
Feel a sense of elation? Already rubbing your hands in glee? Well look no further than this workshop - with lot's of examples and practice code (read: bring a laptop) to work with, you will certainly walk away feeling a sense of euphoria.
The last decade has seen an explosion in the number of languages targeting the Java runtime. Amongst these, one of the (arguably) strong contenders is JRuby - a 100% Java port of the Ruby language. Ruby aims to make programmers "happy", and with JRuby you can find happiness without having to leave your favorite runtime! JRuby also provides deep integration with Java, allowing you to leverage existing Java libraries while writing code that is succinct, elegant and beautiful.
In this hands-on workshop we will talk about JRuby the language, explore it's syntax and constructs like classes and modules. We will discuss advanced topics like meta-programming and domain specific languages, see how we can write Java applications without writing Java code, and some potential gotchas.
Feel a sense of elation? Already rubbing your hands in glee? Well look no further than this workshop - with lot's of examples and practice code (read: bring a laptop) to work with, you will certainly walk away feeling a sense of euphoria.
Whether its an ESB, JavaEE, or an eventing system, Messaging is becoming the foundation for many mission critical development efforts and a common platform for many architectures. Implementing a MQ may seem simple enough, but once it runs in production, you may find that the container is unstable with seizing queues, out of memory problems, slow performance, and messages that just seem to get stuck. 75% of the time this is due to misconfiguration, and 25% its due to poor implementation and architecture.
In this session Jeff will share advanced tips, which he runs into with many of his clients that can apply to just about any MQ, but will have an emphasis on the most widely used, ActiveMQ. He will cover:
• Common problems
• Implementation tips
• Architecture design principals for both producers and consumers
• Designs for high load systems
Vagrant is “virtualized development made easy.” If you’re looking to lower development setup time, minimize manual configuration and setup and eliminate the “it works on my machine” excuse, Vagrant is for you.
Vagrant leverages Oracle’s VirtualBox to create virtual machines that are configured via Puppet or Chef. You can use it to create reproducible and stable environments to deploy and test your application without hassle. Don’t hack up your development workstation to try and approximate your deployment config - use Vagrant to mimic the real thing.
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.
We all know that a career in software can be challenging. Keeping up with the latest trends, mapping out career choices and knowing how to stay marketable are critical skills. The speaker, using his own 20+ year career as an example, will talk about techniques he’s used to survive economic downturns, government contracts, technology shifts and even going from engineering to management and back - twice!
Strategies for succeeding in your current organization to positioning yourself for the next will be covered. Participation is encouraged! - We’ll save time for other to share their own experiences and ideas about how to thrive in any environment.
Bring the power of Ruby and Rails to your enterprise! Interested in harnessing the power of Ruby on Rails but not sure how to incorporate it into your existing Java/J2EE/Spring word? In this session, we’ll talk about real-world experiences, lessons learned and best practices for developing a new Ruby on Rails using JRuby.
You’ll learn about how to set up a Rails application using JRuby and deploy it using the industry standard JBoss application server. We’ll use many of the familiar tools and technologies Java developers are used to, such as MySQL and Maven. Also covered will be using JNDI for database connectivity, integrating with custom and 3rd party Java libraries and the use of servlet filters. We'll even dive in to how you can use Liquibase instead of ActiveRecord for database migrations.
Drawing on a real-world Rails/JRuby/JBoss deployment for a major SaaS company, we’ll discuss practical strategies for fitting your new application into existing operational procedures and talk about ways to overcome organizational challenges regarding adoption.
The technology industry has been swept up in many historical waves. In 1980 the widespread adoption of the PC, fifteen years later in 1995 the browser became widespread and in 2010 with the introduction of the iPhone, the smart phone wave began. Don't miss out. Grab your surfboard and learn how to ride the coming wave of smart phone development with Android.
Spend a day learning how to do development on the most popular smartphone platform available. Android is a Java platform - you can leverage your existing Java skills. You'll get hands on experience developing an Android app that will use all the major components of Android applications.
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. Grab your board and ride the Android wave!
Apache Solr serves search requests at enterprises and the largest companies around the world. Built on top of the top-notch Apache Lucene library, Solr makes indexing and searching integration into your applications straightforward. This talk will introduce Solr's capabilities with live demonstrations.
Solr provides faceted navigation, spell checking, highlighting, clustering, grouping, and other search features. Solr can index rich documents such as PDF, Word, HTML, and other file types. Query volume scales with replication and collection size with distributed capabilities including the power of the new SolrCloud near-real-time distributed indexing.
Solr Recipes provides quick and easy steps for common use cases with Apache Solr. Bite-sized recipes will be presented for data ingestion, textual analysis, client integration, and each of Solr’s features including faceting, more-like-this, spell checking/suggest, and others.
Quick and easy steps for common Apache Solr use cases
Ingesting recipes: CSV, relational databases, file system, web crawls, API
Analysis recipes: copyField, character mapping, tokenizing and filtering, configuring for suggest, data exploration
Faceting recipes: field, date and numeric range, pivot, and query faceting
Integration recipes: prototyping user interactions, working with Solr from PHP, Rails, Java, Ajax, and other environments
Other featured recipes: more like this, spell checking/suggest, grouping, clustering
Prerequisite: Java JDK 1.6 and a current version of Ant is recommended to run the examples.
Solr Recipes provides quick and easy steps for common use cases with Apache Solr. Bite-sized recipes will be presented for data ingestion, textual analysis, client integration, and each of Solr’s features including faceting, more-like-this, spell checking/suggest, and others.
Quick and easy steps for common Apache Solr use cases
Ingesting recipes: CSV, relational databases, file system, web crawls, API
Analysis recipes: copyField, character mapping, tokenizing and filtering, configuring for suggest, data exploration
Faceting recipes: field, date and numeric range, pivot, and query faceting
Integration recipes: prototyping user interactions, working with Solr from PHP, Rails, Java, Ajax, and other environments
Other featured recipes: more like this, spell checking/suggest, grouping, clustering
Prerequisite: Java JDK 1.6 and a current version of Ant is recommended to run the examples.
Make the most out of Solr by leveraging these tips and tricks to increase performance, scale Solr to your needs, and tune search results. This talk will discuss Solr architecture decisions, performance and scaling best practices, and considerations and techniques for adjusting search results for your application.
Solr can generally handle your "big data" needs, if deployed and utilized properly. But there are some devilish details to scale up and out. We'll discuss Solr's caches and general best practices for configuring the, how Solr's distributed architecture works and how it's being deployed in production environments, and we'll delve into the voodoo of Lucene search result scoring and how to incorporate application/domain-specific factors.
Prerequisite: Introduction to Solr (or equivalent experience)
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.
In this session attendees will learn about the different levels of concern within SOA and where to implement different frameworks within enterprise architectures. Tips and tricks that can only be learn through the school of hard knocks are presented here to give the attendee a big leap ahead in architected their systems. It will also point out commons trouble spots often encountered in large-scale systems. These are advanced system integration concepts with a focus on high availability using open source frameworks in a service-orientated architecture.
This talk will cover best practice tips for implementing/architecting ESB, mediation router, and messaging in infrastructures needing large scale, high transaction capabilities.
Learn how your organization can fall prey to malicious attackers. Using real-world case studies you'll see exactly how hackers exploited and embarrassed several well-known companies. Analyzing these events provides enormous insight into what works and what doesn't when building, maintaining, and defending your app.
Hearing these stories will plant a security seed in your mind that may change everything.
Learn how to use the latest HTTP headers to prevent attacks like Clickjacking, Cross-Site Scripting (XSS), and Session Hijacking. To address security defects developers typically resort to fixing architectural issues and security bugs directly in the code. A few use security related HTTP headers to mitigate the risks posed by malicious attackers. Some developers might even pray that security issues will be fixed automagically by the browser.
Come learn how a combination of these techniques can help you develop more secure Java web applications.
This half-day 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.
This half-day 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 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.
This session shows you how to use some of the hottest technologies today to build a webapp, an API and a mobile application to track fitness workouts. Using HTML5 technologies (specifically geo and local storage), I’ll show you how you can track the time, distance and music you listened to while exercising. Play with Scala is used for the backend and services, while CoffeeScript and Jade are used for the front-end templating and Ajax communication.
This session will explain limitations encountered with HTML5 and discuss when native apps might work better.
In this session, Matt and James will develop two apps that do the same thing. One will be written in Grails and one will be written in Play. We'll deploying them to Heroku and hammer them to see how they both perform under load. Afterward, we'll compare performance, lines of code, etc. Who will be declared the winner?!
Who will be declared the winner?!
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.
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.
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.
This presentation seeks to provide a solid introduction to the fundamentals of DDD. Learn why modeling a complex business domain in software is so advantageous to your business and ways in which your team can go about delivering software models to give your business a competitive edge.
The philosophy of domain-driven design (DDD) – first described by Eric Evans in his book [of the same name – is about placing our attention at the heart of the application, focusing on the complexity that is intrinsic to the business domain itself. We also distinguish the core domain (unique to the business) from the supporting sub-domains (typically generic in nature, such as money or time), and place appropriately more of our design efforts on the core.
Domain-driven design consists of a set of patterns for building enterprise applications from the domain model out. In your software career you may well have encountered many of these ideas already, especially if you are a seasoned developer in an OO language. But applying them together will allow you to build systems that genuinely meet the needs of the business.
The premise of domain-driven design is two-fold:
Domain-driven design is not a technology or a methodology. It is a way of thinking and a set of priorities, aimed at accelerating software projects that have to deal with complicated domains.
Note: Laptops are not required - there is no hands-on coding for this workshop.
Not every part of a software system will be well-designed. How do you know where to put the time and effort to refine the design, or refactor existing code? Learn how strategic Domain-Driven Design (DDD) patterns can show you how to know which parts of your system matter most to your business and how to focus your team's design efforts most effectively.
Context mapping and Core Domain are key concepts in DDD, providing valuable techniques and insights into where to focus your design attention, yet most developers have never heard of them. This session will introduce the tools of strategic DDD and show you how they can shine a light on your design challenges.
Come on a guided tour of how applying Domain-Driven Design (DDD) building block patterns can make your code cleaner, more expressive, and more amenable to change. We cover examples of DDD patterns such as entities, value objects, closure of operations and side-effect-free functions. We will focus particularly on how implementing value objects can lead to more supple design.
When good design really matters, DDD building block patterns enable your design to model the business domain you are working with more richly. They allow you to collaborate with domain experts to build deep, useful models of the domain in your code that solve difficult business problems with elegance and simplicity.
This is a highly interactive modeling session which walks through diagrams and code samples to demonstrate how the application of these patterns to modeling can make writing and reading coding fun again, while improving the effectiveness of the code you write. Come prepared to think, ask and answer questions, and learn how to write the best code where it matters most.
Many of the problems encountered in scaling, parallelizing and distributing systems that tend to be addressed in ad-hoc ways are actually deeply connected with the manner in which the business domain has been modeled. Domain-Driven Design (DDD) has rich modeling resources for tackling concurrency, transactional and distribution boundary issues within the domain model itself, enabling teams to be more effective in dealing with business complexity and change.
Learn about how aggregates can enrich your domain models, improve system performance and loosely couple your systems. We will give examples of how aggregate design choices are manifested in NoSQL data schemas, focusing particularly on MongoDB, and the consequences of making these choices for domain modeling, performance, and scaling.
This session will teach you best practices and patterns for doing Continuous Delivery / Continuous Deployment in Cloud environments. You will learn how to handle schema migrations, maintain dev/prod parity, manage configuration and scaling.
This session will use Heroku as an example platform but the patterns could be implemented anywhere.
Heroku is a Polyglot Cloud Application Platform that makes it easy to deploy Java, Play! and Scala apps on the cloud. Deployment is as simple as doing a "git push".
This session will teach you how to instantly deploy and scale Java, Play! and Scala apps on Heroku.
Ever wanted to send a realtime "push" message from a server to a client running in a browser? Send messages from one client to another? Write realtime games and other demanding applications using JavaScript?
One of the most exciting new additions to the suite of technology collectively known as "HTML 5" is an official WebSocket standard. This finally allows full duplex bi-directional communication between a client and server over TCP.
However, the technology is still new and rapidly changing. In this talk, Johnny will explain what a WebSocket is, how it works, how to implement it on browsers that don't natively support it, and how it relates to other technologies and platforms such as HTTP long polling, Comet, Flash Sockets, mobile, and JSONP. He'll also discuss the different types of server implementations, scaling strategies, and how a it can be integrated into an existing application.
Using the same techniques we've learned over the last decade of Java and other OO languages, find out how to think about and organize a large JavaScript code base intelligently.
It often only took one or two lines of JavaScript to implement that site counter we were all so proud to show off a decade ago. Now, creating advanced web applications requires literally thousands of lines of complex JavaScript and, with the popularity of Node.js, the server side is equally daunting.
We know how to handle big projects in Java, Ruby, Python, and the like. We know how to organize our code and use frameworks to help the process. But how do we apply that knowledge to JavaScript?
In this talk, Johnny will explain and demonstrate tools, practices, frameworks, and patterns that work to making large JavaScript applications understandable, maintainable and fun!
"Cloud" is forcing a fundamental shift in enterprise application architecture towards a highly distributed, highly parallelized, horizontal scale-out services model. Traditional means of scale-out based on the RPC and JEE deployment model are showing their limitations when it comes to the "cloud". Over the past several years, with the emergence of simple J2SE-based frameworks, open TCP and non-blocking-I/O-based messaging/eventing middleware, and noSQL data stores, it is easier than ever to deliver simple and cost-effective solutions that enable the flexible distribution and parallelization of your business applications in the cloud. This new breed of middleware allows you to base your cloud application architecture on distributed light-weight Java-based components that use simple, open messaging and eventing for inter-process collaboration.
In this very hands-on presentation Oleg will build a case for the importance of Messaging architecture in the world of the cloud and show how the use of open technologies such as Spring Integration, NodeJS, RabbitMq etc., will allow you to quickly build reliable, highly available, scalable and portable systems with predictable and consistent throughput and latency. This session consists of 35% slide-ware and 65% live coding.
In this workshop Oleg will give a short overview of the Enterprise Integration Patterns (EIP) as catalogued in the highly influential book of the same name and Spring Integration (SI) framework. As one of the core developers of the Spring Integration(SI) framework, Oleg will provide a quick introduction of Spring Integration, its API and will demonstrate how SI enables the development of Message and Event based systems. Along the way, you will see how SI builds upon familiar Spring idioms such as interceptors, templates, strategy and other patterns. You will also see how SI maximizes reuse of the integration support available in the Spring Framework core for everything from remoting, JMS/AMQP, data, transactions, task execution and others flattening the learning curve considerably for those already familiar with Spring framework.
After attending this workshop, you will be able to start applying these patterns immediately within your Spring-based applications to solve many of the challenges of enterprise integration. This session consists of 30% slide-ware and 70% live coding.
In this workshop Oleg will give a short overview of the Enterprise Integration Patterns (EIP) as catalogued in the highly influential book of the same name and Spring Integration (SI) framework. As one of the core developers of the Spring Integration(SI) framework, Oleg will provide a quick introduction of Spring Integration, its API and will demonstrate how SI enables the development of Message and Event based systems. Along the way, you will see how SI builds upon familiar Spring idioms such as interceptors, templates, strategy and other patterns. You will also see how SI maximizes reuse of the integration support available in the Spring Framework core for everything from remoting, JMS/AMQP, data, transactions, task execution and others flattening the learning curve considerably for those already familiar with Spring framework.
After attending this workshop, you will be able to start applying these patterns immediately within your Spring-based applications to solve many of the challenges of enterprise integration. This session consists of 30% slide-ware and 70% live coding.
Many years ago, I started a job as a contract manager, and it became clear I had a big problem. I had developers who knew one area of the code well. I had testers who knew not much of any area of the code well, even though they had worked for the organi
We told you about Kara Web Framework a while ago. It is written in Kotlin and relies on type-safe builders. It doesn’t have to be the only web framework for Kotlin, but the general principles seem good, so I wrote an article about these principles
Several years ago I tried to discuss the need for Lean when Scrum was being used on projects with more than one team. Ken Schwaber didn’t want to hear this and eventually threw me off the Scrum Development Yahoo discussions group. I admit, I was talk
I gave a talk last week at Better Software/Agile Development, called Exploding Management Myths. This is my first talk based on some of my management myths. Yes, the ones I’ve been writing for the last 18 month
This week I’m speaking at GeekOUT Tallin, and my colleagues Mikhail Vink and Sergey Karashevich are holding a 15-minute DEMO on Thursday, telling you about cool stuff in JetBrains’ IDEs. The topic of my talk is “Language Design Trade-O
As many folks know, Net Objectives does both Scrum and Kanban. Admittedly, our Scrum is very much like Scrumban (or Scrum done under the context of Lean) but it is still an implementation of Scrum. Scrum, as it normally manifests itself, has several c
Since lean comes from manufacturing, many question its validity for software developers. Our own experience is that Lean in software is very important. This blog covers three areas: The essential paradigm shift of lean and why it applies even more to
