Left unattended software can expand into a complex, brittle maintenance nightmare. But don't despair! This session teaches strategies for modernizing even the most horrid code swamps, examining incremental refactorings and the dos and don'ts of testing legacy code. We'll also tackle the harder, cultural issues: how to inspire your co-workers and keep your moral high even on the dirtiest jobs.
Left unattended software can expand into a complex, brittle maintenance nightmare. But don't despair! This session teaches strategies for modernizing even the most horrid code swamps, examining incremental refactorings and the dos and don'ts of testing legacy code. We'll also tackle the harder, cultural issues: how to inspire your co-workers and keep your moral high even on the dirtiest jobs.
The first 1h30 will introduce the value proposition of continuous delivery, and present the deployment pipeline, the key pattern at the heart of continuous delivery.
The second 1h30 will discuss creating and maintaining automated tests, and continuous integration and patterns for developing on mainline such as feature toggles and dark launching.
Getting software released to users is often a painful, risky, and time-consuming process. This tutorial 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 tutorial 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. There will be interactive exercises where the audience practices using these techniques for themselves. At the heart of the tutorial 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 tutorial introducing this pattern, and discussing how to incrementally automate the build, test and deployment process, culminating in continuous deployment.
The first 1h30 will introduce the value proposition of continuous delivery, and present the deployment pipeline, the key pattern at the heart of continuous delivery.
The second 1h30 will discuss creating and maintaining automated tests, and continuous integration and patterns for developing on mainline such as feature toggles and dark launching.
Getting software released to users is often a painful, risky, and time-consuming process. This tutorial 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 tutorial 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. There will be interactive exercises where the audience practices using these techniques for themselves. At the heart of the tutorial 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 tutorial introducing this pattern, and discussing how to incrementally automate the build, test and deployment process, culminating in continuous deployment.
In the 3rd 1h30, we will discuss componentised or service architectures, patterns for low-risk releases, and agile infrastructure management.
In the 4th 1h30, I cover data management and organizational transformation. If there's time, there will be a bonus session on architectural patterns.
Getting software released to users is often a painful, risky, and time-consuming process. This tutorial 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 tutorial, 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.
In the 3rd 1h30, we will discuss componentised or service architectures, patterns for low-risk releases, and agile infrastructure management.
In the 4th 1h30, I cover data management and organizational transformation. If there's time, there will be a bonus session on architectural patterns.
Getting software released to users is often a painful, risky, and time-consuming process. This tutorial 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 tutorial, 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.
Behavior-Driven Development (BDD) employs the approach of specification by example. Cucumber is such an amazing BDD tool because it’s so good at mapping stories and acceptance criteria to automated functional tests. This is a hands-on workshop using Cucumber-JVM that will have you writing and automating acceptance tests on your own laptop by the conclusion of the session.
This workshop will cover:
This is a hands-on 90 minute workshop with Cucumber-JVM using Java, you will need a laptop running the JDK and a text editor (doesn't have to be an IDE). Class tools, materials and code exercises will be provided.
you will need a laptop running the JDK and a text editor (doesn't have to be an IDE).
Behavior-Driven Development (BDD) employs the approach of specification by example. Cucumber is such an amazing BDD tool because it’s so good at mapping stories and acceptance criteria to automated functional tests. This is a hands-on workshop using Cucumber-JVM that will have you writing and automating acceptance tests on your own laptop by the conclusion of the session.
This workshop will cover:
This is a hands-on 90 minute workshop with Cucumber-JVM using Java, you will need a laptop running the JDK and a text editor (doesn't have to be an IDE). Class tools, materials and code exercises will be provided.
you will need a laptop running the JDK and a text editor (doesn't have to be an IDE).
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.
git is on your PATH (in the environment variable list of paths)Ever been to a conference, get inspired, try to bring what you learned back to the office, only to be stymied by co-workers who aren't interested in rocking the status quo? It turns out that people tend to resist change in patterns, and like any pattern they can be overcome by using other people's experiences with those skeptics. This session will teach you how to identify the skeptics, how to counter them, and give you a strategic framework to convince your whole office.
This session will go into detail in the patterns and techniques of Driving Technical Change including:
skeptic types, countering techniques, and master strategy using those techniques to achieve change in your organization.
Back in 2004 there wasn't much in the world of test driven development for javascript… you just had jsunit. Since then there has been an explosion of frameworks for javascript and it is almost to the point
where it is difficult to choose the right one.
Come find out about a handful of some of the most popular ones and a comparison of their pros, cons, support within other frameworks, and much more. Also covered will be some tips and tricks for handling difficult to describe code and hooking tests up to run through a CI server.
You might have heard a bit about nodejs, now it's time to get fully immersed in it and not just learn it in detail but gear up to start becoming an active member of the nodejs development community.
We'll show you how to get started at creating your own node modules and how to package them up for distribution. This will be a hands on lab to get all the essential tools setup and at the end you will have a
package that anyone can install via npm (thing of ruby gem for nodejs) and start using right away.
Since node.js currently doesn't work on plain windows, you will need a laptop with BSD, Linux, OSX or if you have windows you will need cygwin installed with common development tools (g++, python, make, etc).
You might have heard a bit about nodejs, now it's time to get fully immersed in it and not just learn it in detail but gear up to start becoming an active member of the nodejs development community.
We'll show you how to get started at creating your own node modules and how to package them up for distribution. This will be a hands on lab to get all the essential tools setup and at the end you will have a
package that anyone can install via npm (thing of ruby gem for nodejs) and start using right away.
Since node.js currently doesn't work on plain windows, you will need a laptop with BSD, Linux, OSX or if you have windows you will need cygwin installed with common development tools (g++, python, make, etc).
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:
WebGL brought hardware accelerated 3D Graphics to the Web on the back of OpenGL ES 2.0. Now, in response to changes in API design in the 3D world, the Vulcan APIs are taking over*.
*Except on macOS.
We looked forward to the emergence of hardware accelerated 3D graphics on the Web and finally got it a few years ago in the form of WebGL. While it is creeping into more and more uses, the world of 3D graphics has changed. We have begun to see new approaches to API design such as Apple's Metal. In response to the a desire to have a modern, high-performance, low overhead, concurrency-friendly cross platform standard, the Khronos Group has created a new standard that is designed to be higher performance with lower energy consumption.
It is also serving as the basis of a new unified API for 3D Graphics and high performance computing. This talk will introduce you to the past and future of cross platform 3D graphics.
People are confused about the status of HTML 5. Is it ready? Is it not? What is part of the spec and what isn't? We'll talk about the situation in the “HTML 5 and the Kitchen Sink” discussion, but as always, the proof is in the pudding. We will introduce the most exciting new features of HTML 5 and its related technologies and build examples that use them.
We will work with real code covering:
The new input elements
Editable content
Canvas Element and its related 2D APIs for drawing and animation
Audio and Video elements and how to use fallbacks for codec coverage
Browser native drag and drop
Local storage
Web Workers
Websockets
The Geolocation API
Web DB (SQL in the browser!)
This workshop will assume no special knowledge of HTML 5 and should be accessible to any web developers.
Bring your laptops. This is a hands-on workshop.
People are confused about the status of HTML 5. Is it ready? Is it not? What is part of the spec and what isn't? We'll talk about the situation in the “HTML 5 and the Kitchen Sink” discussion, but as always, the proof is in the pudding. We will introduce the most exciting new features of HTML 5 and its related technologies and build examples that use them.
We will work with real code covering:
The new input elements
Editable content
Canvas Element and its related 2D APIs for drawing and animation
Audio and Video elements and how to use fallbacks for codec coverage
Browser native drag and drop
Local storage
Web Workers
Websockets
The Geolocation API
Web DB (SQL in the browser!)
This workshop will assume no special knowledge of HTML 5 and should be accessible to any web developers.
Bring your laptops. This is a hands-on workshop.
First there was iPod. Then iPhone. Then iPad. And with each new release, the mobile device market grew hotter and hotter. Now, as Google’s entry into this race, the Android system, begins to hit its stride as a competitor platform to the iOS, as a Java developer you’re intrigued—it’s Java (well, assuming you ask anybody except Oracle), and it’s a mobile device, and it’s open source, and…. What’s not to love?
In this all-day workshop, we’re going to turn you into a journeyman Android developer. This is a Java-based platform, so we’ll have a leg up on those other “Java-free” environments where you’ll have to spend half the day just learning how to count from 1 to 10 and print it to the console all over again. We’ll start by looking at the Android toolchain and how it integrates with your existing toolchain (Eclipse or otherwise). We’ll get your hands dirty writing some code to the Android emulator, then (for those of you who have Android devices handy) push it to a device. We’ll write some unit-tests for testing an Android application. We’ll look at how to store data to the device, both in a SQLite database as well as to a straight file. We’ll look at how to make Internet calls to remote services, and when all is said and done, we’ll have an application that Really Works ™. Bring a laptop, your Java skills, an Android device if you’ve got one, and buckle in, because it’s going to be a straight-from-the-firehose kind of workshop.
Graph databases are an esoteric but powerful member of the NoSQL family. For highly connected data, graph databases can be thousands of times faster than relational databases, making Neo4j popular for managing complex data across many domains, from finance to social, telecoms to geospatial.
This tutorial covers the core functionality from the Neo4j graph database, providing a mixture of theory and accompanying practical sessions to demonstrate the capabilities of graph data and the Neo4j database. Specifically, you'll learn about:
Each session (apart from the fundamentals and architecture) will be a mixture of a small amount of theory combined with a set of practical exercises designed to reinforce how to achieve sophisticated goals with Neo4j. The practical parts of the tutorial consist of Koan-style lessons where a specific aspect of the Neo4j stack is presented as a set of failing unit tests which participants will work to fix, gradually becoming more challenging until the attendees are capable of implementing sophisticated graph operations against Neo4j.
Attendees won't need any previous experience with Neo4j or NoSQL databases, but will require some fluency in Java, a little familiarity with a modern IDE, and a basic understanding of JUnit to help complete the lab tasks.
Graph databases are an esoteric but powerful member of the NoSQL family. For highly connected data, graph databases can be thousands of times faster than relational databases, making Neo4j popular for managing complex data across many domains, from finance to social, telecoms to geospatial.
This tutorial covers the core functionality from the Neo4j graph database, providing a mixture of theory and accompanying practical sessions to demonstrate the capabilities of graph data and the Neo4j database. Specifically, you'll learn about:
Each session (apart from the fundamentals and architecture) will be a mixture of a small amount of theory combined with a set of practical exercises designed to reinforce how to achieve sophisticated goals with Neo4j. The practical parts of the tutorial consist of Koan-style lessons where a specific aspect of the Neo4j stack is presented as a set of failing unit tests which participants will work to fix, gradually becoming more challenging until the attendees are capable of implementing sophisticated graph operations against Neo4j.
Attendees won't need any previous experience with Neo4j or NoSQL databases, but will require some fluency in Java, a little familiarity with a modern IDE, and a basic understanding of JUnit to help complete the lab tasks.
Graph databases are an esoteric but powerful member of the NoSQL family. For highly connected data, graph databases can be thousands of times faster than relational databases, making Neo4j popular for managing complex data across many domains, from finance to social, telecoms to geospatial.
This tutorial covers the core functionality from the Neo4j graph database, providing a mixture of theory and accompanying practical sessions to demonstrate the capabilities of graph data and the Neo4j database. Specifically, you'll learn about:
Each session (apart from the fundamentals and architecture) will be a mixture of a small amount of theory combined with a set of practical exercises designed to reinforce how to achieve sophisticated goals with Neo4j. The practical parts of the tutorial consist of Koan-style lessons where a specific aspect of the Neo4j stack is presented as a set of failing unit tests which participants will work to fix, gradually becoming more challenging until the attendees are capable of implementing sophisticated graph operations against Neo4j.
Attendees won't need any previous experience with Neo4j or NoSQL databases, but will require some fluency in Java, a little familiarity with a modern IDE, and a basic understanding of JUnit to help complete the lab tasks.
Come to this workshop for an in depth understanding of the fundamentals of developing applications on the iOS platform for iPhone and iPad devices.
The intent of this session is not to teach you the click and run techniques. The intent is to hone in the under the covers event handling mechanism, the organization of the application, and its deployment configuration. While you will learn how to develop Apps, you will
also leave with confidence to debug and to improve the performance of your Apps.
The Web is fast becoming a serious competitor to traditional enterprise architecture approaches. This full day workshop will provide an introduction to RESTful Web Service techniques, both from a theoretical and practical perspectives.
This full day workshop is broken down as follows:
Participants should be comfortable with distributed computing concepts, but won't need any particular integration or middleware experience
The Web is fast becoming a serious competitor to traditional enterprise architecture approaches. This full day workshop will provide an introduction to RESTful Web Service techniques, both from a theoretical and practical perspectives.
This full day workshop is broken down as follows:
Participants should be comfortable with distributed computing concepts, but won't need any particular integration or middleware experience
The Web is fast becoming a serious competitor to traditional enterprise architecture approaches. This full day workshop will provide an introduction to RESTful Web Service techniques, both from a theoretical and practical perspectives.
This full day workshop is broken down as follows:
Participants should be comfortable with distributed computing concepts, but won't need any particular integration or middleware experience
The Web is fast becoming a serious competitor to traditional enterprise architecture approaches. This full day workshop will provide an introduction to RESTful Web Service techniques, both from a theoretical and practical perspectives.
This full day workshop is broken down as follows:
Participants should be comfortable with distributed computing concepts, but won't need any particular integration or middleware experience
Graph databases are an esoteric but powerful member of the NoSQL family. For highly connected data, graph databases can be thousands of times faster than relational databases, making Neo4j popular for managing complex data across many domains, from finance to social, telecoms to geospatial.
This tutorial covers the core functionality from the Neo4j graph database, providing a mixture of theory and accompanying practical sessions to demonstrate the capabilities of graph data and the Neo4j database. Specifically, you'll learn about:
Each session (apart from the fundamentals and architecture) will be a mixture of a small amount of theory combined with a set of practical exercises designed to reinforce how to achieve sophisticated goals with Neo4j. The practical parts of the tutorial consist of Koan-style lessons where a specific aspect of the Neo4j stack is presented as a set of failing unit tests which participants will work to fix, gradually becoming more challenging until the attendees are capable of implementing sophisticated graph operations against Neo4j.
Attendees won't need any previous experience with Neo4j or NoSQL databases, but will require some fluency in Java, a little familiarity with a modern IDE, and a basic understanding of JUnit to help complete the lab tasks.
A Technology Radar is a tool that forces you to organize and think about near term future technology decisions, both for you and your company. This talk discusses using the radar for personal breadth development, architectural guidance, and governance.
ThoughtWorks Technical Advisory Board creates a “technology radar” twice a year, a working document that helps the company make decisions about interesting technologies and where we spend our time. ThoughtWorks then started conducting radar-building exercises for our clients, which provides a great medium for technologists company-wide to express their opinions about the technologies they use every day. For companies, creating a radar helps you document your technology decisions in a standard format, evaluate technology decisions in an actionable way, and create cross-silo discussions about suitable technology choices. This session describes the radar visualization and how to conduct a radar building session for yourself. After a brief introduction, the bulk of the workshop consists of attendees building a radar for the group, following the same procedure you'll use when you do this exercise at your company. At the end, we'll have created a unique Radar for this event and practiced doing it for yourself.
Building an application is not the straightforward exercise it used to be. Decisions regarding which architectural approaches to take (n-tier, client/server), which user interface approaches to take (Smart/rich client, thin client, Ajax), even how to communicate between processes (Web services, distributed objects, REST)… it's enough to drive the most dedicated designer nuts. This talk discusses the goals of an application architecture and why developers should concern themselves with architecture in the first place. Then, it dives into the meat of the various architectural considerations available; the pros and cons of JavaWebStart, ClickOnce, SWT, Swing, JavaFX, GWT, Ajax, RMI, JAX-WS, , JMS, MSMQ, transactional processing, and more.
After that, the basic architectural discussion from the first part is, with the aid of the audience in a more interactive workshop style, applied to a real-world problem, discussing the performance and scalability ramifications of the various communication options, user interface options, and more.
Fred Brooks said, “How do we get great designers? Great designers design, of course.” So how do we get great architects? Great architects architect. But architecting a software system is a rare opportunity for the non-architect.
The kata is an ancient tradition, born of the martial arts, designed to give the student the opportunity to practice more than basics in a semi-realistic way. The coding kata, created by Dave Thomas, is an opportunity for the developer to try a language or tool to solve a problem slightly more complex than “Hello world”. The architectural kata, like the coding kata, is an opportunity for the student-architect to practice architecting a software system.
In this session, attendees will be split into small groups and given a “real world” business problem (the kata). Attendees will be expected to formulate an architectural vision for the project, asking questions (of the instructor) as necessary to better understand the requirements, then defend questions (posed by both the instructor and their fellow attendees) about their choice in technology and approach, and then evaluate others' efforts in a similar fashion. No equipment is necessary to participate–the great architect has no need of tools, just their mind and the customers' participation and feedback.
CoffeeScript is a little language that compiles into JavaScript. Underneath all of those embarrassing braces and semicolons, JavaScript has always had a gorgeous object model at its heart. CoffeeScript is an attempt to expose the good parts of JavaScript in a simple way.
The golden rule of CoffeeScript is: “It's just JavaScript”. The code compiles one-to-one into the equivalent JS, and there is no interpretation at runtime. You can use any existing JavaScript library seamlessly (and vice-versa). The compiled output is readable and pretty-printed, passes through JavaScript Lint without warnings, and runs in every JavaScript implementation.
In this session we will look at Coffescript, write some coffeescript code, and analyze the generated Javascript. We will look at how we can use it in our existing web development stack, seamlessly compiling the coffeescript into Javascript so it works in our development environment. We will also look at seamlessly using existing Javascript libraries like Prototype, Scriptaculous, and JQuery.
Git is an innovative version control system that is taking the development world by storm. With that innovation comes new opportunities to leverage Git for more agile and productive workflows. This presentation steps up a level of abstraction from Git syntax and instead showcases the incredible team, branch and workflow dynamics that are easily accomplished with Git.
This presentation is suited to managers, team leads, and developers who want to understand how the easy branching and simple sharing of Git repositories can lead to “social coding” even amongst team members purely inside an enterprise.
Many development shops have made the leap from RCS, Perforce, ClearCase, PVCS, CVS, BitKeeper or SourceSafe to the modern Subversion (SVN) version control system. But why not take the next massive stride in productivity and get on board with Git, a distributed version control system (DVCS). Jump ahead of the masses staying on Subversion, and increase your team's productivity, debugging effectiveness, flexibility in cutting releases, and repository redundancy at $0 cost. Understand how distributed version control systems are game-changers and pick up the lingo that will become standard in the next few years.
In this talk, we discuss the team changes that liberate you from the central server, but still conform to the corporate expectation that there's a central master repository. You'll get a cheat sheet for Git, and a trail-map from someone who's actually experienced the Subversion to Git transition.
Lastly, we'll even expose how you can leverage 75% of Git's features against a Subversion repository without ever telling your bosses you are using it. Be forewarned that they may start to wonder why you are so much more effective in your checkins than other members of your team.
Like hamburger & fries and turkey & dressing, JRuby allows you to harness the awesome power of Ruby in your Java projects. This workshop describes the origins, capabilities, and limitations of JRuby, the 100% pure-Java implementation of the Ruby programming language. This workshop also demonstrates some areas where it makes sense to mixin Ruby and Java code: building swing applications, testing, and dynamic programming.
This workshop includes tons of examples, including side-by-side comparisons of Java and equivalent JRuby code. It also covers some more advanced topics like building domain specific languages, meta-programming (including real uses!), and more.
Like hamburger & fries and turkey & dressing, JRuby allows you to harness the awesome power of Ruby in your Java projects. This workshop describes the origins, capabilities, and limitations of JRuby, the 100% pure-Java implementation of the Ruby programming language. This workshop also demonstrates some areas where it makes sense to mixin Ruby and Java code: building swing applications, testing, and dynamic programming.
This workshop includes tons of examples, including side-by-side comparisons of Java and equivalent JRuby code. It also covers some more advanced topics like building domain specific languages, meta-programming (including real uses!), and more.
Starting threads is easy, benefiting from them without being burnt is hard. The multithreading API in Java has evolved quite a bit since the early stages. There are three options for concurrency in pure Java today: the modern JDK API, the Software Transaction Memory, and the actor based concurrency. In this workshop, using practical examples—all in pure Java, you will dive deep into all three of these options, learn how to use these, learn their pros and cons, and clearly understand which option to pick when.
In this workshop, using practical examples—all in pure Java, you will dive deep into all three of these options, learn how to use these, learn their pros and cons, and clearly understand which option to pick when.
Starting threads is easy, benefiting from them without being burnt is hard. The multithreading API in Java has evolved quite a bit since the early stages. There are three options for concurrency in pure Java today: the modern JDK API, the Software Transaction Memory, and the actor based concurrency. In this workshop, using practical examples—all in pure Java, you will dive deep into all three of these options, learn how to use these, learn their pros and cons, and clearly understand which option to pick when.
In this workshop, using practical examples—all in pure Java, you will dive deep into all three of these options, learn how to use these, learn their pros and cons, and clearly understand which option to pick when.
Starting threads is easy, benefiting from them without being burnt is hard. The multithreading API in Java has evolved quite a bit since the early stages. There are three options for concurrency in pure Java today: the modern JDK API, the Software Transaction Memory, and the actor based concurrency. In this workshop, using practical examples—all in pure Java, you will dive deep into all three of these options, learn how to use these, learn their pros and cons, and clearly understand which option to pick when.
In this workshop, using practical examples—all in pure Java, you will dive deep into all three of these options, learn how to use these, learn their pros and cons, and clearly understand which option to pick when.
Starting threads is easy, benefiting from them without being burnt is hard. The multithreading API in Java has evolved quite a bit since the early stages. There are three options for concurrency in pure Java today: the modern JDK API, the Software Transaction Memory, and the actor based concurrency. In this workshop, using practical examples—all in pure Java, you will dive deep into all three of these options, learn how to use these, learn their pros and cons, and clearly understand which option to pick when.
In this workshop, using practical examples—all in pure Java, you will dive deep into all three of these options, learn how to use these, learn their pros and cons, and clearly understand which option to pick when.
HTML5 wants to make some major changes to the way we deliver media over the web and the way we mark up our pages, but it also gives us a bunch of new stuff in the browser's programming model. To ignore these new JavaScript APIs is to give up on a richer browser UI and a lot of fun.
In this session, we'll cover the geolocation API, local storage, the client-side SQL database, support for offline applications, in-browser threading, web sockets, and more. We'll look at the real, working code for as many features as we can manage, and discuss cross-browser compatibility issues as well. HTML5 is not an optional skill for web developers in 2011. Don't miss it!
You've read that the relational model is old and busted, and there are newer, faster, web-scale ways to store your application's data. You've heard that NoSQL databases are the future! Well, what is all this NoSQL stuff about? Is it time to ditch Oracle, MySQL, and SQL Server in favor of the new guard? To be able to make that call, there's a lot you'll have to learn.
In this session, we'll take a whirlwind tour of several representative non-relational data stores, including Cassandra, MongoDB, and Neo4J. We'll learn the very different ways they represent data, and we'll see their unique strengths and weaknesses in various kinds of applications. Along the way, we'll learn why new technologies must be introduced to address today's scaling challenges, and what compromises we'll have to make if we want to abandon the databases of our youth. We'll review what ACID means, think about query idioms, and talk about the CAP theorem. It's an exciting time to be storing and retrieving data, and the opportunity is now before us to learn things we could ignore just a few years ago. Come to this session for a solid introduction to a growing field.
The full title of this talk reveals its grand aims: Game Theory and Software Development: Explaining Brinksmanship, Irrationality, and Other Selfish Sins
Once in a while, a topic, seemingly orthogonal to software development, presents a great opportunity to showcase how engineering can benefit from knowledge of seemingly more social disciplines. In this talk, the fundamental principles of economics' Game Theory are compared to often inexplicable behaviors and decisions we frequently observe in programming projects.
Then, with a good Game Theory vocabulary under your belt, several standard games are studied in a manner that will allow you to better manipulate the inputs. These games are present in web framework choices, project planning and estimation, and even team decisions on which bug to solve first. With a good understanding of Game Theory, you'll be able to understand and influence what you previously labeled 'irrational behavior.' It turns out to be far from irrational when examined in the context of self-preservation. Once these behaviors are understood, you will be able to ethically influence the outcomes to your personal and corporate advantage.
Stonepath is a workflow modeling methodology with its roots in a long-running Java project at the U.S. State Department. Starting with techniques for deriving requirements/user stories from your users, user interface patterns, state-and-task based workflow modeling, and some domain modeling ideas, you can build comprehensive 'Enterprise' applications for managing aspects of workflow and group coordination.
In this session we will look at the elements of StonePath. We will work through an example application, modeling the flow of various kinds of work through an example 'back office' application, and look at several real-world applications based on these ideas.
“That's really useful, but it looks like it was designed by a developer.”
Ever heard that? Want to fix it? Think you don't have design ability?
Here's a dirty little secret, design is a skill, it can be learned. This session will take you through the basics of design theory for applications. By the end you should be on your way to building not just useful apps that people have to use, but awesome apps that people love to use.
Topics to include:
In this workshop we will take some common everyday tasks and learn how to program it using Scala.
There will be short (ten to fifteen minutes) lecture sessions followed by hands-on exercises where the
attendees will pair up to implement tasks and in the process learn the strength, expressiveness, conciseness, and the power of Scala.
In this workshop we will take some common everyday tasks and learn how to program it using Scala.
There will be short (ten to fifteen minutes) lecture sessions followed by hands-on exercises where the
attendees will pair up to implement tasks and in the process learn the strength, expressiveness, conciseness, and the power of Scala.
In this session, you'll learn how to implement authentication in your Java web applications using Spring Security, Apache Shiro and good ol' Java EE 6 Container Managed Authentication. You'll also learn how to secure your REST API with OAuth and lock it down with SSL.
After learning how to develop authentication, I'll introduce you to OWASP, the OWASP Top 10, its Testing Guide and its Code Review Guide. From there, I'll discuss using Zed Attack Proxy to verify your app is secure and commercial tools like webapp firewalls and accelerators.
A chance for experience agile developers to learn and share state of the art tips for improving requirements gathering and project estimation.
You've been doing agile for a while and use story cards and burn down charts on a regular basis, but you'd still like to improve the quality of the applications you build and your ability to estimate the scope of those applications and manage business stakeholder expectations.
A combination of presentation and open discussion, this will be a chance to discuss and debate best practices in requirements gathering, estimating and expectation management with your peers, sharing best practices from projects large and small around the world.
“The Google Guava project contains a host of new features/classes for use by the Java programmer. Intended as a drop-in supplement for the standard JDK APIs, Guava provides features like immutable and forwarding collections, some concurrency utilities, more support for primitives, and so on.
In this session, we'll go over the Guava library, looking at what it provides, when you might seek to use it, and what the overheads and consequences of using it would be.”
n 2007, OSGi was heralded as a contender for most important technology of the decade. Today, most developers have heard of OSGi, but few are using it to develop their enterprise software applications. OSGi might be the most heralded technology that nobody is using. Is OSGi failing? Who is using it? And what exactly are its benefits? Is it really too complex for the average enterprise developer?
In this session, we'll explain the benefits of OSGi, and show that it's not just for the middleware vendor. We'll learn how you can use OSGi without making significant changes to how you write your software applications. We'll explore the OSGi ecosystem, including platforms that support OSGi. Through code examination, we'll see how the Spring framework allows us to leverage OSGi in a non-invasive way. We'll discover how OSGi encourages Polyglot programming on the Java platform. And we'll take a brief glimpse into the future of modularity on the Java platform. You'll walk away with a much better understanding of OSGi, its strengths and benefits, how to use it effectively, as well as the myths surrounding its use.
Modularity is coming to the Java platform! But contrary to popular belief, you don't need a framework or a new runtime to start building modular software applications. You can start today. Learn how!
In this session, we'll examine what it means to develop modular software on the Java platform. We'll examine the goals and benefits of modular software, and explore the patterns of modular architecture that help us develop modular software systems. With just a few easy steps, we'll see how to transform our software from a huge monolith to an extensible system of collaborating software modules. By examining an existing software system, we'll see first hand how we can increase software modularity with minimal disruption. You'll walk away not just with a much deeper understanding of the benefits of modular software, but also a migration roadmap for refactoring existing applications to increase their modularity. In other words, you'll see how to get ready today for the application platform of tomorrow.
Modularity is coming to the Java platform! But contrary to popular belief, you don't need a framework or a new runtime to start building modular software applications. You can start today. Learn how!
In this session, we'll examine what it means to develop modular software on the Java platform. We'll examine the goals and benefits of modular software, and explore the patterns of modular architecture that help us develop modular software systems. With just a few easy steps, we'll see how to transform our software from a huge monolith to an extensible system of collaborating software modules. By examining an existing software system, we'll see first hand how we can increase software modularity with minimal disruption. You'll walk away not just with a much deeper understanding of the benefits of modular software, but also a migration roadmap for refactoring existing applications to increase their modularity. In other words, you'll see how to get ready today for the application platform of tomorrow.
Agile methods are proven on small teams. But really…almost any process works with a team of one. As team size increases, however, challenges mount. How do we organize the team? How do I manage Sprints across the teams? Is it possible to conduct effective code reviews? What are the essential practices that maintain team unity?
In this session, we'll focus on proven practices that help large software development teams in excess of 100 developers maintain their agility. We'll explore the importance of automation, dealing with geographically dispersed teams, and the need for transparency. You'll walk away with actionable advice and a better understanding of what it takes to create a development process that scales to large teams and is sustainable long-term.
The GOF design patterns were quite centered around OOP languages. Now that we have dynamic and functional languages on the JVM, there are quite a few other patterns that come in handy with these capabilities.
In this presentation we will explore patterns that allow us to make better use of closures and functional style of programming.
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.
Emergent design is a big topic in the agile architecture and design community. This session covers the theory behind emergent design and shows examples of how you can implement this important concept.
This session describes the current thinking about emergent design, discovering design in code. The hazard of Big Design Up Front in software is that you don't yet know what you don't know, and design decisions made too early are just speculations without facts. Emergent design techniques allow you to wait until the last responsible moment to make design decisions. This talk covers four areas: emergent design enablers, battling things that make emergent design hard, finding idiomatic patterns, and how to leverage the patterns you find. It includes both proactive (test-driven development) and reactive (refactoring, metrics, visualizations, tests) approaches to discovering design, and discusses the use of custom attributes, DSLs, and other techniques for utilizing them. The goal of this talk is to provide nomenclature, strategies, and techniques for allowing design to emerge from projects as they proceed, keeping you code in sync with the problem domain. This talk shows lots of examples of how to make this concept work in your environment.
Successful software development is about building the right product at the right time for your customers. This means focusing attention on the right places in the portfolio of projects and products that your company provides, and optimizing the entire value stream from “concept to cash” for your customers and the development teams.
Agility is more than just adopting Scrum or some other agile process framework; it involves adopting a new set of Lean-Agile values, principles and practices through the entire software development lifecycle and beyond in order to provide value to customers earlier and more often.
Lean-Agile software development consists of frequent feedback loops, intense team collaboration, continuous improvement, business and customer involvement, baking quality in and consistent delivery of valuable software. Learn how these Lean principles and practices transform software development and the radical difference it can make in your development work and wider organization.
This presentation explores the nature of motivation and the place of metrics and measurement in software development, and how lean software development principles and practices shed light on motivation and metrics and how they can be used to support deep organizational improvement.
We will examine the nature of motivation in terms of the four intrinsic rewards that drive positive engagement, and also how certain approaches to measuring and managing performance lead to organizational dysfunction. We will also show how the application of lean principles such as building quality into the product, respect for people and optimizing the whole enable more effective approaches to motivation and metrics in software development.
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.
Want to go deep on a popular NoSQL database? Cassandra is a scalable, highly available, column-oriented data store in use at Netflix, Twitter, Reddit, Rackspace, and other web-scale operations. It offers a compelling combination of a rich data model, a robust deployment track record, and a sound architecture, making it a good choice of NoSQL databases to study first.
In this session, we'll talk about Cassandra's data model, look at its query idioms, talk about how to deploy it, and look at use cases in which it is an appropriate data storage solution. We'll study its origins in the Amazon Dynamo project and Google's BigTable, and learn how its architecture helps us achieve the gold standard of scalability: horizontal scalability on commodity hardware. You'll leave prepared to begin experimenting with Cassandra immediately and planning its adoption in your next project.
The goal of this hands-on tutorial is to get started and get productive with Grails. We’ll do this by jumping right in and building an application, from design to deployment.
Rather than try to learn Grails feature by feature, we’ll let it unfold as we build the application. We’ll begin with a simple application structure that runs right out of the box, then we’ll gradually build our application while building our knowledge of Grails. Bring your laptop and be ready to code.
We will be using Grails 1.3.5 for the exercises.
In Part II of this session, we will continue the build out process with the Grails application.
When we’re done, you’ll have learned about:
This is an introduction, but it is also a deep dive. So bring your laptop and be ready to code.
We will be using Grails 1.3.5 for the exercises.
JodaTime is Java Date/Time and Calendering done right. There are many problems with the original Date/Time API that came prepackaged in the early Java days. There are even
One of the obvious issues is that Calendar is mutable and can unintentionally be changed. Another issue is that constructing Calendars in Java involves setting certain fields at certain times during coding, but not always getting the expected result. Joda Time repairs those issues and offers a robust and immutable date, time, and duration API.
In Joda Time and a Brief History of the World, I provide a quick rundown of calendaring throughout the centuries, describe UTC, compare UTC to GMT, discuss how time is calculated, and then dive into Joda Time in every popular JVM language. The end result provides the audience with compelling proof that Joda Time should always be their Date Time API of choice.
Does your application transmit customer information? Are there fields of sensitive customer data stored in your DB? Can your application be used on insecure networks? If so, you need a working knowledge of encryption and how to leverage Open Source APIs and libraries to make securing your data as easy as possible. Cryptography is quickly becoming a developer's new frontier of responsibility in many data-centric applications.
In today's data-sensitive and news-sensationalizing world, don't become the next headline by an inadvertent release of private customer or company data. Secure your persisted, transmitted and in-memory data and learn the terminology you'll need to navigate the ecosystem of symmetric and public/private key cryptography.
Cryptography at first seems like a daunting topic. But after a basic intro and the leverage of the Java Cryptography Extension (JCE), it seems downright feasible to add encryption and decryption capabilities to your application.
Developers weren't satisfied with just the JCE and its plug-in concepts though. Over the last few years, framework architects have made strides in either wrapping or re-writing the approachable JCE in more convenient APIs and fluent interfaces that make effective and accurate crypto down right simple.
Explore three of these libraries – Jasypt, BouncyCastle and KeyCzar – and how they can be leveraged to make your next Java cryptography and data security effort a simple exercise and not a tribulation.
Jasypt, BouncyCastle and KeyCzar are three open source frameworks that bring unique new crypto algorithms such as elliptic curve cryptography to the enterprise developer, remove repetitive ceremonious setup and tear down coding, and add high level adapters to the Spring and Hibernate frameworks.
This session will quickly introduce the Cascading open-source project and how it was used in various projects to overcome problems and bottlenecks particular to large data analytics.
This presentation will cover five different high profile Hadoop and Cascading projects and the lessons learned from them. Then identify the common architectural components across them. We will then present a summary of Hadoop and its architecture to show why Hadoop was a key technology for these projects and the design decisions architects should consider when beginning a new Hadoop project.
You love Groovy and you're a believer in cloud computing. For a larger project you might choose Grails and hosting on Amazon EC2, but what if you want to take advantage of the nearly massless deployments of a cloud provider like the Google App Engine? You could make Grails work, but it's not always the best fit. Enter Gaelyk.
Gaelyk is a lightweight Groovy web application framework built specifically for the Google App Engine. In this session, we'll talk through the simple abstractions it offers, then show how easy it is to code and deploy a useful application to the cloud.
Once you've been introduced to Gaelyk and the Groovy way it wraps the services the Google App Engine, it's time to write some code. Bring your laptop for a hands-on Gaelyk hack session in which we build a working Gaelyk app utilizing as many of the GAE services as we can pack into a 180 minutes of coding!
Workshop attendees should have a laptop with the following: JDK 5+, an IDE or editor capable of editing Groovy code and HTML, the Google App Engine SDK already downloaded and installed (http://code.google.com/appengine/downloads.html#Google_App_Engine_SDK_for_Java), and the current version of the Gaelyk project template (https://github.com/glaforge/gaelyk/downloads).
“Effective Java” by Joshua Bloch is the gold standard for how to write correct and idiomatic Java code. Wouldn't it be great if the same thing existed for Groovy? Well here it is. This interactive, live coding session discusses what separates good Groovy code from the bad, what makes some code great, and how best to use the many available libraries. We'll also look at several static analysis tools for Groovy that aid in these pursuits. This session appeals to both those with a Java knowledge looking to learn Groovy and advanced Groovy programmers looking to learn more.
“Effective Java” by Joshua Bloch is the gold standard for how to write correct and idiomatic Java code. Wouldn't it be great if the same thing existed for Groovy? Well here it is. This interactive, live coding session discusses what separates good Groovy code from the bad, what makes some code great, and how best to use the many available libraries. We'll also look at several static analysis tools for Groovy that aid in these pursuits. This session appeals to both those with a Java knowledge looking to learn Groovy and advanced Groovy programmers looking to learn more.
You've probably heard about Groovy, the dynamic language for the JVM. You may have heard that Groovy is what Java would have been if it had been written in the 21st century. Maybe you've even seen some demos of the seemingly magical things that you can do with Groovy. Well, now it's time to download the bits and experience the fun and productivity for yourself.
In this hands-on tutorial, we'll highlight some of the key features of Groovy by working through some real-world assignments. In Part 1, we'll work with Groovy Objects, GStrings, Closures, and Groovy Collections. Then in Part 2, we'll see how Groovy can make things like XML, JDBC, and even Swing easier than ever.
This is a hands-on workshop; please bring a laptop with JDK 5 or higher installed.
You've probably heard about Groovy, the dynamic language for the JVM. You may have heard that Groovy is what Java would have been if it had been written in the 21st century. Maybe you've even seen some demos of the seemingly magical things that you can do with Groovy. Well, now it's time to download the bits and experience the fun and productivity for yourself.
In this hands-on tutorial, we'll highlight some of the key features of Groovy by working through some real-world assignments. In Part 1, we'll work with Groovy Objects, GStrings, Closures, and Groovy Collections. Then in Part 2, we'll see how Groovy can make things like XML, JDBC, and even Swing easier than ever.
This is a hands-on workshop; please bring a laptop with JDK 5 or higher installed.
This workshop is aimed at Java and Java EE developers looking to understand and apply a Rule Engine to solve problems typically and painfully addressed with traditional programming techniques.
In this workshop you will learn how to build lean applications using Test-Driven Development Techniques in conjunction with jBoss’ Drools Rule Engine to streamline, simplify and minimize the maintenance burden of a growing application in a rapidly changing business environment
Eclipse IDE - Juno
The Drools IDE is part of the JBoss Tools family of plugins
Select “Help” » “Install New Software…”
Next to the “Work with:” field, select “Add…”
Enter:
http://download.jboss.org/drools/release/5.4.0.Final/org.drools.updatesite/
with a name like “JBoss Tools”
Code samples are hosted on Git. A Git Enable Eclipse installation is preferred but we can always use git from the command line
This workshop is aimed at Java and Java EE developers looking to understand and apply a Rule Engine to solve problems typically and painfully addressed with traditional programming techniques.
In this workshop you will learn how to build lean applications using Test-Driven Development Techniques in conjunction with jBoss’ Drools Rule Engine to streamline, simplify and minimize the maintenance burden of a growing application in a rapidly changing business environment
Eclipse IDE - Juno
The Drools IDE is part of the JBoss Tools family of plugins
Select “Help” » “Install New Software…”
Next to the “Work with:” field, select “Add…”
Enter:
http://download.jboss.org/drools/release/5.4.0.Final/org.drools.updatesite/
with a name like “JBoss Tools”
Code samples are hosted on Git. A Git Enable Eclipse installation is preferred but we can always use git from the command line
REST is ready for the enterprise. Imagine an information platform that is open and available to systems throughout the enterprise estate. A platform that eschews integration in favour of composition, connected data over siloed databases. A networked data structure with the power to implement valuable business behaviours: a distributed, hypermedia-driven application platform.
In this session you'll learn how to design and implement RESTful services to support complex business processes. With a detailed example, I show how to model business processes as domain application protocols; implement them in terms of resource lifecycles; and advertise and execute them using HTTP idioms, media types and link relation values.
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 talk will show you Sonar from the ground up and explain 10 critical metrics that affect your code's flexibility, stability, and durability.
The team dynamics and agile process revolution of the last several years has taught us that continuous integration (CI) is a necessary part of a healthy agile team. Jenkins (formerly Hudson) is the idea and footprint leader in the CI space. A recent survey stated that over 70% of all CI installations have Jenkins in their DNA. What's so awesome about this particular CI tool?
Get on board with a ground-up survey of how to install, apply, upgrade, and leverage the free an open source Jenkins Continuous Integration server for your build, whether it be Ant, Maven, Gradle, JavaScript, Rake, or just shell scripts.
In this presentation, you'll learn how to add plugins for additional build and analysis phases, how to cluster Jenkins on a subnet for a swarm of CI servers that automatically load balance and collate reports, and lastly, how to manage Jenkins on a disparate set of OSes to natively test your unit and integration tests on all your supporter platforms.
The team dynamics and agile process revolution of the last several years has taught us that continuous integration (CI) is a necessary part of a healthy agile team. Jenkins (formerly Hudson) is the idea and footprint leader in the CI space. A recent survey stated that over 70% of all CI installations have Jenkins in their DNA. What's so awesome about this particular CI tool?
Get on board with a ground-up survey of how to install, apply, upgrade, and leverage the free an open source Jenkins Continuous Integration server for your build, whether it be Ant, Maven, Gradle, JavaScript, Rake, or just shell scripts.
In this presentation, you'll learn how to add plugins for additional build and analysis phases, how to cluster Jenkins on a subnet for a swarm of CI servers that automatically load balance and collate reports, and lastly, how to manage Jenkins on a disparate set of OSes to natively test your unit and integration tests on all your supporter platforms.
Most teams manage database change using an ad-hoc system of SQL migration scripts manually applied to various development, staging, and production servers. Some even contrive automated processes, but rarely does this surplus build engineering deliver value directly to the customer. We should be writing applications, not build tools.
In this session, we'll take a look at a ready-to-use, open-source database refactoring tool called Liquibase. Liquibase enables developers to make database changes with confidence, share those changes in a predictable way with other team members, and apply them to automated QA builds, staging servers, and production environments. It provides a credible path to agile database development, and it integrates well into popular build tools. It's a key enabler of the culture of database responsibility that most teams are missing.
Take one ugly legacy schema, a toolbox full of simple database refactorings, and a world-class schema refactoring tool, and you've got 90 minutes of workshop that will equip you to bring a culture of database responsibility to your team.
In this workshop, we'll start with a live schema in need of some help, and slowly improve it in a controlled fashion using Liquibase. We'll see how to create and alter tables, add constraints, drop columns, control changes in stored procedures, and more. You should come away with a solid understanding of how to use the tool and how to integrate it into your team's development, build, and deployment processes.
Attendees should already have a conversational understanding of Liquibase, or have attended Scripting the Schema with Liquibase session. Please bring a laptop or be prepared to pair with a friend.
In this session, I'll lead a guided tour through the latest that Spring has to offer. Whether you're a Spring veteran or a Spring newbie, there will be something new for nearly everyone.
It's been 8 years since Spring 1.0 was released. In that time it has gone from a modest open-source project to being a de facto standard Java application framework. Now, as Spring enters its 8th year, it continues its attack on Java complexity, packed with many new features such as:
In this session, I'll lead a guided tour through the latest that Spring has to offer. Whether you're a Spring veteran or a Spring newbie, there will be something new for nearly everyone.
Learn how to exploit security vulnerabilities that are commonly found in the arsenal of malicious attackers. We won't simply talk about issues like Cross Site Scripting (XSS) and Cross Site Request Forgery (CSRF), but will show how hackers abuse these potentially devastating defects by finding and exploiting vulnerabilities in real world open source web applications built in Java. We will proceed to walk through the source code and actually fix these issues using secure coding techniques. We will also discuss best practices that can be used to build security into your SDLC.
Java developers and architects will learn how to find and fix security issues in their applications before hackers do.
This session covers
How do you spot bad code? How do you turn it into good code? We'll be looking at code examples from real applications. We'll start by identifying the problem with the code: things like maintainability, clarity, and testability. Then we'll look for ways to improve that code: perhaps introducing base classes, perhaps other refactorings based on Gang of Four Patterns.
We'll examine a number of common patterns including Builder, Visitor, Chain of Responsibility, Proxy, and Strategy. This session will offer insight into how to spot the problem how to select the solution, and how to apply the changes to get your code nice and shiny!
It’s not easy to build the right product. People sometimes don’t know exactly what they need, want things that won’t help, and don’t imagine what’s possible. Agile project capture requirements on cards that contain a statement of want and benefit and notes on how to confirm the need is met. The intention isn’t to fully document the requirement on the card, but to make a note and create a reminder for a conversation with the customer. Whether you are using agile methods or traditional requirements, valuable products start with understanding the customers context, their problems, what they want, and how they use a product. However, most people aren’t born with the ability to speak naturally in user stories or fully formed requirements statements. So we must learn how to ask the right questions, draw out pertinent information and understand the customer’s world in those conversations.
In this session, you’ll learn about different types of questions, and when to use them to learn about how the customer currently uses a product, the problems they experience with the product, and problems that new features in the product might solve. Then, we’ll put that to work in practice interviews.
In this workshop you will learn how to design, develop and deploy Java and Groovy applications on the Cloud. Learn about GAE (Google App Engine) and Amazon EC2 (Elastic Compute Cloud)
In this workshop you will learn how to design, develop and deploy Java and Groovy applications on the Cloud. Learn about GAE (Google App Engine) and Amazon EC2 (Elastic Compute Cloud)
In this workshop you will learn how to design, develop and deploy Java and Groovy applications on the Cloud. Learn about GAE (Google App Engine) and Amazon EC2 (Elastic Compute Cloud)
In this workshop you will learn how to design, develop and deploy Java and Groovy applications on the Cloud. Learn about GAE (Google App Engine) and Amazon EC2 (Elastic Compute Cloud)
With the rise of the NoSQL movement, a whole new crop of different ways to store data suddenly became available to the Java developer. Unfortunately,what didn't come with them was an owner's manual. CouchDB, for example, was the first of the NoSQL databases to be named as such, and offers features not found in the traditional RDBMS: A distributed, robust, incremental replication document-oriented database server with bi-directional conflict detection and management, accessible via a RESTful JSON API, stored ad-hoc and schema-free with a flat address space, that is both query-able and index-able, featuring a table oriented reporting engine that uses JavaScript as a query language. (With a list of buzzwords like that, what's not to love?)
In this session, we'll look at CouchDB, how to set it up, store data to it, retrieve data from it, and in general figure out where it fits within your next project.
For as long as there has been a Spring Framework, there has been Spring MVC, a web framework built around the principals of Spring. Although it was originally designed around a deep hierarchy of controller classes and focused on HTML-oriented views, Spring MVC has evolved in the past few years to embrace an annotation-oriented model and RESTful web development.
In this workshop, we'll use Spring MVC to build the web front-end of an application. We'll start with the essentials and work our way up to try out the latest Spring MVC features in Spring 3.1. We'll explore the following Spring MVC topics:
Whether you're a Spring newbie or a long-time Spring veteran, this is your chance to get a hands-on experience with everything Spring MVC can do.
IMPORTANT!!! PRE-WORKSHOP SETUP INSTRUCTIONS!!!
In order to ensure a successful workshop, it is imperative that you arrive with the following installed on your computer:
Also, before arriving, it will save time if you have already verified this setup. As part of the verification, perform the following steps:
We will not have time during the workshop to setup your environment, so please arrive having performed these setup steps. If you need any help getting started, feel free to email craig-mvcws@habuma.com and I'll do my best to help out.
For as long as there has been a Spring Framework, there has been Spring MVC, a web framework built around the principals of Spring. Although it was originally designed around a deep hierarchy of controller classes and focused on HTML-oriented views, Spring MVC has evolved in the past few years to embrace an annotation-oriented model and RESTful web development.
In this workshop, we'll use Spring MVC to build the web front-end of an application. We'll start with the essentials and work our way up to try out the latest Spring MVC features in Spring 3.1. We'll explore the following Spring MVC topics:
Whether you're a Spring newbie or a long-time Spring veteran, this is your chance to get a hands-on experience with everything Spring MVC can do.
IMPORTANT!!! PRE-WORKSHOP SETUP INSTRUCTIONS!!!
In order to ensure a successful workshop, it is imperative that you arrive with the following installed on your computer:
Also, before arriving, it will save time if you have already verified this setup. As part of the verification, perform the following steps:
We will not have time during the workshop to setup your environment, so please arrive having performed these setup steps. If you need any help getting started, feel free to email craig-mvcws@habuma.com and I'll do my best to help out.
JUnit is the de facto standard in Java testing. Yet many advanced JUnit features are little known and poorly understood. This session reviews some lesser-known features of JUnit, along with a few associated libraries, that can make your unit tests more powerful, expressive, and fun. The session is intended for Java developers, lead developers, and architects trying to introduce good testing practices into their teams.
Attendees will learn about the latest JUnit tips and tricks, including:
Clojure is a new dynamic programming language for the Java Virtual Machine. Clojure introduces innovative ideas around state management and concurrency, while inheriting the best ideas from the long history of Lisp-like languages. It is a language designed to solve real problems, some of which are so pervasive in current programming practice that we don't even recognize them as problems.
This talk will provide an introduction to Clojure's syntax and key concepts, with examples of how they can make a real impact in large, complex systems.
What is the Expression Problem? The question is far from academic: any programmer working in mainstream object-oriented languages is bound encounter it. As a young language on the JVM, Clojure has the opportunity to step back from mainstream approaches to object-oriented design, and get back to core concepts like type and polymorphism. Clojure, while not an object-oriented language itself, offers features that can achieve the same goals as OOP with greater flexibility.
This talk will explain what the expression problem is, why it matters, and how Clojure's Multimethods, Protocols, and Datatypes can help solve it.
In 2006, Columbia law professor Tim Wu asked the question, “Why isn't legal research as easy as searching the web?” Out of that question came AltLaw, a free, open-source search engine for federal court decisions. With a nonexistent budget and only one full-time programmer, AltLaw built a search engine for over 700,000 documents by leveraging a powerful new programming language, Clojure, in conjunction with Hadoop for data processing, Solr/Lucene for search, and Amazon Web Services for infrastructure.
This is the story of AltLaw's four-year existence and the technical challenges that had to be overcome, including lessons learned by making mistakes along the way.
In this presentation, we'll explore all of the ways to do bean wiring in Spring We'll take a pragmatic view of each style, evaluating their strengths, weaknesses, and applicability to varying circumstances.
Over 10 years ago, Spring entered the enterprise Java scene, bringing a simpler development model rooted in dependency injection, the notion of assembling application components in a loosely-coupled way. With it, however, came a flood of XML configuration, required to declare how those components were to be assembled.
For a variety of reasons, XML has fallen out of favor with much of the development community. Now that there are other frameworks that offer dependency injection without all of the XML, some are suggesting that Spring's heavy use of XML has it destined for the scrap heap.
They don't know Spring.
Although XML-based Spring configuration is still available and still has a place in many Spring applications, it is no longer the only way to do dependency injection in Spring. The past few releases of Spring have brought us new ways of assembling our application objects, including annotation-driven options such as Spring's @Autowired and JSR-330's @Inject and Java-based configuration with Spring JavaConfig. There's even a way to express Spring configuration in Groovy.
Spring greatly simplifies JMS messaging by handling common scenarios for you by providing facilities for both synchronous and asynchronous messaging. This dramatically lowers the barrier to building
message-driven applications. Apache ActiveMQ is an open source JMS message broker that provides client access from many different languages and offers many advanced features necessary for enterprise
level messaging.
This session examines the use of Spring JMS and ActiveMQ to easily build message-driven applications.
Why does ActiveMQ just stop sending messages and hang? What's the best way to build a JMS consumer and producer? What configuration should I use for connection pooling? How can I query ActiveMQ for the message I need? Should I cluster ActiveMQ or group clients across brokers? If you use ActiveMQ, chances are you have run into some questions that are easily answered with a little knowledge.
This session examines the top five questions from developers using ActiveMQ.
Despite of all the buzz and hype around webapps over the last 8 years fact is that desktop applications are still found in many places, specially in the enterprise. However the legends are true: building desktop applications is a hard job. But it does not have to be. Enter Griffon.
Griffon aims to bring back the fun and productivity to desktop application development in the same way Grails did it (and continues to do so) on the web. Griffon is rooted in the JVM but has Grails in its DNA. This means you'll find yourself right at home if you're a Java veteran, same goes for all of you that made the jump to Grails.
In this session we'll cover the basics to get you started with Griffon. How applications are structured and built. Then we'll switch gears into high speed and cover topics like threading, testing, deploying, handling of legacy code and even network and database integration.
“The Pragmatic Programmer” admonished us all to “write code that writes code”: use code generators to increase productivity and avoid duplication. Today's language communities have clearly caught on, as more and more frameworks generate code at compile or runtime. This session covers Project Lombok, Cofoja, Spring Roo, GContracts, Groovy++, and more. We'll reviews the different approaches, including examples of how and why we'd want to do this. Come see how these frameworks are using things like Java and Groovy AST Transformations, AspectJ intertype definitions, and ASM bytecode generators. You'll get an in-depth look at language tools and production deployed AST Transforms and code generators. Audience: developers searching for cutting edge solutions to increasing team velocity.
“The Pragmatic Programmer” admonished us all to “write code that writes code”: use code generators to increase productivity and avoid duplication. Today's language communities have clearly caught on, as more and more frameworks generate code at compile or runtime. This session covers Project Lombok, Cofoja, Spring Roo, GContracts, Groovy++, and more. We'll reviews the different approaches, including examples of how and why we'd want to do this. Come see how these frameworks are using things like Java and Groovy AST Transformations, AspectJ intertype definitions, and ASM bytecode generators. You'll get an in-depth look at language tools and production deployed AST Transforms and code generators. Audience: developers searching for cutting edge solutions to increasing team velocity.
Some systems are too large to be understood entirely by any one human mind. They are composed of a diverse array of individual components capable of interacting with each other and adapting to a changing environment. As systems, they produce behavior that differs in kind from the behavior of their components. Complexity Theory is an emerging discipline that seeks to describe such phenomena previously encountered in biology, sociology, economics, and other disciplines.
Beyond new ways of looking at ant colonies, fashion trends, and national economies, complexity theory promises powerful insights to software development. The Internet—perhaps the most valuable piece of computing infrastructure of the present day—may fit the description of a complex system. Large corporate organizations in which developers are employed have complex characteristics. In this session, we'll explore what makes a complex system, what advantages complexity has to offer us, and how to harness these in the systems we build.
In this session we will explore the Java tools, techniques and algorithms that enable us to filter, classify, relate and discover patterns in our data that might not immediately obvious. With the emergence of social networking applications a great deal of data and hidden connections that can be leveraged to build better and smarter applications.
In this session we will explore the Java tools, techniques and algorithms that enable us to filter, classify, relate and discover patterns in our data that might not immediately obvious. With the emergence of social networking applications a great deal of data and hidden connections that can be leveraged to build better and smarter applications.
The session will explore:
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.
Geb is a next generation Functional Web Testing tool that removes the ceremony and tedium of traditional web testing, leaving you with a concise, pragmatic and productive environment in which to work. It combines the power of Groovy with the WebDriver/Selenium 2.0 browser automation library to provide a programmer's DSL for modeling pages (known as the PageObject Pattern) and easily automating real browsers such as Internet Explorer, FireFox and Chrome as well as the HTMLUnit library. Geb can be used standalone, or with testing frameworks such as Spock, JUnit, EasyB or Cucumber.
In this session, you will learn everything you need to know to start using Geb in your own projects. We will cover Geb's programming model, solve real-world testing challenges, and show how Geb integrates with your environment.
The Web is changing faster than you can imagine and it is going to continue to do so. Rather than starting over from scratch each time, it builds on what has succeeded already. Webs of Documents are giving way to machine-processable Webs of Information. We no longer care about data containers, we only care about data and how it connects to what we already know.
Roughly 25% of the Web is semantically marked up now and the search engines are indexing this information, enriching their knowledge graphs and rewarding you for providing them with this information.
In the past we had to try to convince developers to adopt new data models, storage engines, encoding schemes, etc. Now we no longer have to worry about that. Rich, reusable interface elements like Web Components can be built using Semantic Web technologies in ways that intermediate developers don’t have to understand but end users can still benefit from. Embedded JSON-LD now allows disparate organizations to communicate complex data sets of arbitrary information through documents without collaboration.
Perhaps the concepts of the Semantic Web initiative are new to you. Or perhaps you have been hearing for years how great technologies like RDF, SPARQL, SKOS and OWL are and have yet to see anything real come out of it.
Whether you are jazzed or jaded, this workshop will blow your mind and provide you with the understanding of a technological shift that is already upon us.
In this workshop, we will:
Explain the Web and Web architecture at a deeper level
Apply Web and Semantic Web technologies in the Enterprise and make them work together
Integrate structured and unstructured information
Create good, long-lived logical names (URIs) for information and services
Use the Resource Description Framework (RDF) to integrate documents, services and databases
Use popular RDF vocabularies such as Dublin Core, FOAF
Query RDF and non-RDF datastores with the SPARQL query language
Encode data in documents using RDFa and JSON-LD
Create self-describing, semantic Web Components
Model and use inferencing with the Web Ontology Language (OWL)
The Web is changing faster than you can imagine and it is going to continue to do so. Rather than starting over from scratch each time, it builds on what has succeeded already. Webs of Documents are giving way to machine-processable Webs of Information. We no longer care about data containers, we only care about data and how it connects to what we already know.
Roughly 25% of the Web is semantically marked up now and the search engines are indexing this information, enriching their knowledge graphs and rewarding you for providing them with this information.
In the past we had to try to convince developers to adopt new data models, storage engines, encoding schemes, etc. Now we no longer have to worry about that. Rich, reusable interface elements like Web Components can be built using Semantic Web technologies in ways that intermediate developers don’t have to understand but end users can still benefit from. Embedded JSON-LD now allows disparate organizations to communicate complex data sets of arbitrary information through documents without collaboration.
Perhaps the concepts of the Semantic Web initiative are new to you. Or perhaps you have been hearing for years how great technologies like RDF, SPARQL, SKOS and OWL are and have yet to see anything real come out of it.
Whether you are jazzed or jaded, this workshop will blow your mind and provide you with the understanding of a technological shift that is already upon us.
In this workshop, we will:
Explain the Web and Web architecture at a deeper level
Apply Web and Semantic Web technologies in the Enterprise and make them work together
Integrate structured and unstructured information
Create good, long-lived logical names (URIs) for information and services
Use the Resource Description Framework (RDF) to integrate documents, services and databases
Use popular RDF vocabularies such as Dublin Core, FOAF
Query RDF and non-RDF datastores with the SPARQL query language
Encode data in documents using RDFa and JSON-LD
Create self-describing, semantic Web Components
Model and use inferencing with the Web Ontology Language (OWL)
Even with the recent explosion in alternative languages for the JVM, the vast majority of us are still writing code in “Java the language” in order to put bread on the table. Proper craftsmanship demands that we write the best Java code that we can possibly write. Fortunately we have a guide in Joshua Bloch's Effective Java.
In his foreward to the first edition, Guy Steele writes about the importance of learning three aspects of any language: grammar, vocabulary, and idioms. Unfortunately many programmers stop learning after mastering the first two. Effective Java is your guide to understanding idiomatic Java programming.
Effective Java is organized into 78 standalone “items,” all of which will be impossible to cover in one session. Instead I've chosen a subset of the most important techniques and practices that are commonly missed by today's Java programmers. You'll pick from a menu and decide where we'll head. Regardless of the path we take, you'll leave this session thoroughly equipped to write better Java code tomorrow!
Learning the syntax of a new language is easy, but learning to think under a different paradigm is hard.
Learning the syntax of a new language is easy, but learning
to think under a different paradigm is hard. This session
helps you transition from a Java writing imperative programmer to a
functional programmer, using Java, Clojure and Scala for
examples. This session takes common
topics from imperative languages and looks at alternative ways of
solving those problems in functional languages. As a Java developer, you know how to achieve code-reuse
via mechanisms like inheritance and polymorphism. Code reuse is
possible in functional languages as well, using high-order
functions, composition, and multi-methods. I show examples from my book Functional Thinking of shifting your perspective on problems, ceding messy details to the language, working smarter, not harder, and how to deal with multiparadigm languages.
Ever been envious of how easily Python, Ruby and even JavaScript can “meta-program”? It’s like magic: seemingly simple or innocuous code takes over big responsibilities; new methods and behaviors appear out of thin air. Your code, your primary code, stays simple and easy to follow. Now, we know you can do that for scripting languages, but what do we do about Java? With the proper component-focused context, it is possible to emulate many of those same capabilities, by applying a simple set of code transformations at runtime.
In this session you’ll learn about meta-programming and how it can apply to traditional Java. You’ll learn about the techniques needed to transform classes at runtime, adding new behaviors and addressing cross-cutting concerns. The presentation will discuss a new framework for this specific purpose, but also draw examples from the Apache Tapestry web framework, which itself is rich in meta-programming constructs.
What's the point attending a conference unless you do something with the knowledge you gain? In this session we look at practical strategies for selecting new technologies and proven approaches for driving adoption back at the office.
From the technology adoption lifecycle and the importance of community to “the knowing doing gap” and technology adoption patterns, we'll look at a range of practical case studies that illustrate proven techniques for selecting and adopting new technologies for your team.
Groovy is the fastest growing JVM language out there. It might be because it is so easy for Java developers to pick it up, but also because there's an increasing number of projects and libraries that make use of Groovy as the starting point.
In this session we'll cover frameworks, tools and libraries rooted in the Groovy language that can make your daily work a much more enjoyable experience.
Most Spring-based applications utilize a design based on layering. When using the standard layered application approach, the service layer is commonly used to encapsulate reusable, business-specific
logic. Furthermore, communication between these services has taken place via synchronous method invocations. Spring also provides support for a message-driven communication and concurrent task
messaging and concurrency support in Spring for your applications.
TBA
Different integration scenarios require different types of application integration styles. Knowledge of these integration types will help you understand how to add integration to your applications using Spring.
This session discusses three styles of application integration, how they can affect your application design and how to implement each one using Spring.
In this example-driven session we'll see how to swiftly develop Spring applications using Spring Roo. We'll start with an empty directory and quickly work our way up to a fully functioning web application. You'll see how Roo handles a lot of heavy-lifting that you'd normally have to do yourself when working with Spring. And we'll stop at a few scenic points along the way to see how Roo accomplishes some of its magic.
In recent years, rapid application development frameworks such as Rails and Grails have earned a lot of attending. By employing code generation, convention-over-configuration, and the dynamic capabilities of their core languages (Ruby and Groovy) to offer unparalleled productivity, helping get projects off the ground quickly.
As awesome as these frameworks are, they do have one negative mark against them. Although developers love working with them, convincing the “boss” to build mission-critical applications in a relatively new development style based can be difficult. The mere mention of a word like “Groovy” conjures up images of tie-dye shirts and VW vans. Risk-averse project managers often think that free love may have been a big thing in the 70s, but it has no place in serious business.
If psychedelic frameworks are a tough-sell in your organization, then you can still feel much of the same productivity gains while developing Spring applications. Spring Roo mixes Spring and Java with a little code generation and a dash of compile-time AspectJ to achive a rapid development environment that resembles Rails and Grails. But instead of producing Ruby/Rails or Groovy/Grails code that may make your manager twitch, Roo produces Java-based projects that use the Spring Framework–which is already accepted in many organizations.
In this hands-on workshop, we'll work together developing a Spring application using Spring Roo.
To fully benefit from the workshop, you should bring your computer loaded with Java 6 and Spring Roo 1.1.0 and SpringSource ToolSuite 2.5.1.
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.
Do you know what your application's users are doing when they're not using your application? Odds are good that they're spending time on Facebook, Twitter, or any of the other social network sites that are so prevalent today. If only your application could somehow go with them into those sites, adding value to their experience in both places.
In this session, you will learn how to build rich web applications that interact with the major social networks. We will highlight the open source technology available for simplifying social media integration, and will show you how to add social features to your own applications.
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
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
You’re Solr powered, and needing to customize its capabilities. Apache Solr is flexibly architected, with practically everything pluggable. Under the hood, Solr is driven by the well-known Apache Lucene. Lucene for Solr Developers will guide you through the various ways in which Solr can be extended, customized, and enhanced with a bit of Lucene API know-how. We’ll delve into improving analysis with custom character mapping, tokenizing, and token filtering extensions; show why and how to implement specialized query parsing, and how to add your own search and update request handling.
Apache Solr uses Lucene under the hood for its searching power
How does Solr work with Lucene already?
Solr can be customized in amazingly powerful ways with some Lucene API know-how:
Monads are quite unheard of in imperative style of programming. Monads, however, play an interesting roll in a purely functional programming language.
Come to this session if you're heard of monads and wondered what in the world they were.
What are monads? Why care about them? Where you've used them before. Types of monads. Building your own monads.
Many managers ask me, “How can I motivate my team?” The zeroth step in boosting motivation is to stop doing things that demotivate people. But what is a manager to do after that? Prizes, treats, rewards, pep talks, and recognition events don’t cut it. Why? Many of the common attempts to improve motivation rely on an external source of motivation. That assumes that people need a carrot (or a stick) to keep them going. Research shows a contrary conclusion—that intrinsic motivation has more sustaining power.
In this session, we’ll explore the key elements of intrinsic motivation in the workplace—autonomy, mastery, and purpose. We’ll examine how common management practices either support or work against intrinsic motivation. Then we’ll do an check-up to see where you can tap into autonomy, mastery, and purpose to boost motivation and creativity in your group.
Time is very precious and is often threatened by phone calls, emails, co-workers, bosses, and most of all, yourself. The Pomodoro Technique reigns in unfocused time and gives your work the urgency and the attention it needs, and it's done with a kitchen timer.
In this presentation we discuss how to set up, estimate time, log time, deal with interruptions, and integrate with Agile as a team. We discuss timer software and even some of the great health benefits of the Pomodoro Technique.
The world abounds with complex theories and complex advice about complex adaptive systems. But most of them aren't very helpful when it comes to knowing what to do to make a system work better. In this interactive session, we'll explore three levers that you can use to influence patterns of behavior in complex adaptive systems…such as software development teams.
In this session, we'll simulate a small product company and examine the structures, exchanges, and differences that influence how the company worked. Then we'll look for similar levers within our workplaces and develop ideas on how you can use lessons from complexity science to help your team work more effectively.
Have you had the experience of watching smart people argue endlessly over which technology to use? Have you walked out of a meeting believing the group had agreed, only to find out that five different people thought they’d agreed to five different things?
People in our industry pride themselves on their brain power and ability to make good decisions. And most of us are good at thinking, learning, and deciding—on our own. When we work collaboratively on interdependent work, though, we need to think and decide as a group if we want to realize the benefits of the team effect.
In this session, we’ll experience a group decision. Then, we’ll look at the pieces and parts of the process to see what we can learn about how groups think and decide togther. We’ll tease out the techniques that will help you help groups take advantage of all their expertise, see other points of view, and arrive at high-quality decisions.
In this session, we’ll experience a group decision. Then, we’ll look at the pieces and parts of the process to see what we can learn about how groups think and decide togther. We’ll tease out the techniques that will help you help groups take advantage of all their expertise, see other points of view, and arrive at high-quality decisions.
Questions are powerful.
Presidential historians believe that the questions presidents ask and the way they ask those questions have huge ramifications. Questions asked and not asked influence policy initiatives, invasions, and trips to the moon.
Likewise, success or failure hangs on the questions managers and technical people ask when planning releases, making decisions, considering strategy alternatives or looking for improvements.
Yet we don’t often stop to consider the questions we ask. Every question contains assumptions and while the question opens one avenue of inquiry, it closes others.
In this session, we’ll consider the questions we do ask, the questions we don’t ask, the questions we could ask. We’ll look at what the questions people ask us reveal assumptions, who gets to ask questions, questions that mislead, and when its best not to ask questions, but rather to go and see.
In this session, we’ll consider the questions we do ask, the questions we don’t ask, the questions we could ask. We’ll look at what the questions people ask us reveal assumptions, who gets to ask questions, questions that mislead, and when its best not to ask questions, but rather to go and see.
Apache Tapestry is a fast, easy to use, high-performance, general purpose web framework. Tapestry eschews heavy XML configuration, base classes, and boilerplate code: instead it embraces convention-over-configuration, letting you build your application from simple, concise POJO (Plain Old Java) page and component classes. Tapestry is laser-focused on giving you maximum bang for your programming buck, and this shows up as a broad range of well-integrated features, including extensive Ajax support. Don't let unfamiliarity get in the way of learning this powerful, friendly tool.
Tapestry is different from traditional action-oriented frameworks, such as Struts and SpringMVC, because it is component-based: it organizes the overall application into pages, and builds pages from reusable components. Tapestry leverages this overall map of the application to take over many responsibilities normally tossed in the developer's lap, such as building and dispatching on URLs, and managing server-side state.
Tapestry is very easy to get started with: a few seconds using Maven and you'll have a template project ready to customize. In this session, we'll start with that template, add in some database support, and have a somewhat polished application that includes client-side and server-side input validation and basic Ajax support. Along the way we'll learn a bit about what Tapestry is doing under the covers to support you as a developer: obsessive attention to exception reporting, live reloading of classes, the ease with which reusable components can be created, and lots of meta-programming. We'll also touch on what makes Tapestry great in production: its terrific performance, its approach to organizing and deploying JavaScript, and how it exposes other assets to the client in a scalable, efficient way.
Most introductory programming books include a chapter on testing, seemingly as an afterthought. For the test-driven developer, that's a little too late. Some programmers approach a new programming language with a few test-cases to understand a concept. Others thrive under fire and want to hit the ground running in a new programming language by creating an application. Regardless of your profile, this presentation will help you get started with a Scala testing environment so you can concentrate on the finer points of the language.
This presentation will cover SBT (Scala Build Tool), Specs, ScalaTest, and Automatic Test Generation with ScalaCheck.
You've got your build automated using Ant/Maven/Gradle and you're building and running your unit test suite every time you check-in. That's easy. In fact, with Jenkins you can do this in under 5 minutes.
However, if we want to move beyond “mere” Continuous Integration to Continuous Delivery, there are many other areas in which we need to achieve “push button” automation. This talk will survey many of these areas and tie everything together with an integrated case study at the end.
In this talk, we'll look at:
One of the hallmarks of lean software development is the elimination of waste. Several of the key wastes in software development revolve around incomplete, incorrect, or obsolete documentation, especially documentation of requirements. One effective means of ensuring that your requirements documentation is complete, correct, and up-to-date is to make it executable. That sounds nice, but how do we get it done, especially in the world of modern, cross-browser web applications?
Executable web application specifications are within your reach through the combination of Spock, a testing and specification framework written for the JVM in Groovy, and Geb, an elegant Groovy wrapper around the powerful WebDriver browser automation framework. In this session we'll take a close look at Spock specifications for describing and verifying the behavior of our applications. We'll then examine how we can use Geb's implementation of the Page Object pattern and its “jQuery-ish” API for interacting with our web applications in WebDriver's range of supported browsers. Finally, by gluing these two technologies together via Geb's Spock integration, we'll automate the requirements specification for a simple web app.
Feature requests are steadily pouring in, but the team cannot respond to them. They are paralyzed. The codebase on which the company has “bet the business” is simply too hard to change. It's your job to clean up the mess and get things rolling again. Where do you begin? Your first task is to get the lay of the land by applying a family of techniques we'll call “Code Archaeology.”
In this session we will learn how to systematically explore a codebase. We'll look at what tools are available to help us out, slinging some wicked shell-fu along the way. We'll look at “code islands” and “code bridges,” and how to construct a “map of the code.” We'll also examine the wisdom that thought leaders like Michael Feathers and Dave Thomas have leant to this subject.
Once we've gained a thorough understanding of what we have in front of us, we'll learn approaches for getting the system under test and refactoring so that we can start to pick up the pace and respond to user requirements without making a bigger mess. You'll leave this session well prepared to tackle the next “big ball of mud” that gets dumped on your desk.
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.
Compass is a tool that can help you build cleaner, better structured, and less error-prone CSS. Semantic CSS is a technique where your CSS vocabulary describes WHAT things are on your page, rather than WHERE they are. Together, this tool and this concept can radically improve the structure of your html.
With compass, your CSS is written in a CSS superset called SCSS which can include variables, math, and method calls that evaluate to CSS. The end result is pure CSS - so you don't need to worry about anything 'funny' on the browser side. This lets us write cleaner CSS that documents the intent of our design, not just the 'end result'.
Even with the recent explosion in alternative languages for the JVM, the vast majority of us are still writing code in “Java the language” in order to put bread on the table. Proper craftsmanship demands that we write the best Java code that we can possibly write. Fortunately we have a guide in Joshua Bloch's Effective Java.
In his foreward to the first edition, Guy Steele writes about the importance of learning three aspects of any language: grammar, vocabulary, and idioms. Unfortunately many programmers stop learning after mastering the first two. Effective Java is your guide to understanding idiomatic Java programming.
Effective Java is organized into 78 standalone “items,” all of which will be impossible to cover in one session. Instead I've chosen a subset of the most important techniques and practices that are commonly missed by today's Java programmers. You'll pick from a menu and decide where we'll head. Regardless of the path we take, you'll leave this session thoroughly equipped to write better Java code tomorrow!
The presentation will cover different types of application configuration, their lifecycle and management. The audience will learn about approaches on how to separate the configuration API from consumption and provisioning. The benefits that can be achieved from a well defined API providing ease of development, nice IDE support, type handling and true data objects, while maintaining the flexibility of being able to retrieve configuration from different sources and in different formats. They will learn about supporting different data stores, such as CouchDB, flat files, remote services and file repositories, as well as supporting different file formats like XML, JSON, Protobuf binary, etc.
The talk will cover some aspects of data modeling and design to best describe the configuration domain and support its ongoing evolution. A code demo will demonstrate an example of a system with a defined configuration data model represented via Protocol Buffers Model API, using multiple data providers consisting of data fetched from CouchDB, local files and remote RESTful services and being stored in multiple formats (JSON, XML, Protobuf binary).
The audience will be presented with a number of open source technologies that would enable building different layers of a multi-tier system.
We would look at various choices of foundational technologies like Spring and Google Guice, explore various options for the Web application containers and MVC frameworks, caching and distributed data store (NoSQL) solutions and cover some aspects of application monitoring and deployment.
Object-oriented programming was formally introduced in the 1970's with the advent of Smalltalk. C++ took it mainstream in the 1980's, and Java carried it to the next level in the 1990's. Unfortunately, if you examine the vast majority of Java codebases, what you'll find is a bunch of C-style structs (a.k.a. JavaBeans) and functions. As these codebases grow, a number of design smells can potentially crop up, which in turn cripple our ability to respond to change. We need SOLID principles that we can apply to keep our software clean and malleable.
Robert C. “Uncle Bob” Martin identified several design smells in his book Agile Software Development: Principles, Patterns, and Practices:
We can reverse and in fact avoid these techniques by following the principles of SOLID software design:
You'll leave this session equipped to ferret out design smells and apply these principles on your next project.
This talk unveils the missing link in enterprise Java development: simple, portable integration tests. While development life is simple with unit tests and mocks, they only take you so far.
Arquillian, a container-oriented testing framework layered atop TestNG and JUnit, tears down this barrier. It brings your test to the runtime rather than requiring you to manage the runtime from your test. That means you can test real components that rely on real enterprise services in a real runtime.
Attend this talk to explore what the future holds for Java enterprise testing!
With the rise of multi-core processors, and their growing ubiquity (on client machines, to say nothing of the server machines on which Java applications most frequently execute), the need to “program concurrently” has risen from “nice-to-have” to “mandatory” requirement, and unfortunately the traditional threading-and-locking model is just too complicated for most Java developers–even the brightest of the lot–to keep track of with any degree of reliability. As a result, numerous new solutions are emerging, each of them with their own strengths and weaknesses, leaving the Java developer in a bit of a quandary as to which to examine.
In this presentation, we'll look at Akka, a framework/platform specifically aimed at building high-throughput, concurrency-friendly applications in either Java or Scala (or both), with a slew of additional add-on modules to handle issues like persistence, communication (pub-sub, REST, and more), and more. By the time we're done, you'll be able to start looking into using Akka on your own projects, and have a good feel for what your projects would look like when Akka-ized.
Fast, fast, fast. Blazing fast! No doubt, that's the main reason to love JBoss AS 7. This talk dispells a long-standing misconception that Java EE application servers are inherently slow. With JBoss AS 7, you get to keep more memory for your applications AND you experience a 10-fold reduction in startup time over previous revisions.
In this talk, we'll dive into how this performance boost has been achieved, how its modular design saves you from classloader hell and why it's such a pleasure to administer. It's everything you've wanted in an application server: blazing fast startup, a lightweight footprint, completely modular, elegant administration and multi-server management mode. Under all that is a server powered by first class components developed in the JBoss Community (JBoss Modules, Hibernate, Weld, RESTEasy, Infinispan, HornetQ, etc). It's even a (J)Ruby server!
Come get your cake and eat it too.
Acceptance Test Driven Development, or ATDD, has proven to be a very effective technique, both for driving and guiding development, and for enhancing communication between developers and other project stakeholders. But why stop there? Well designed Acceptance Tests can also act as a formidable documentation source and communication tool. Indeed, when written in a narrative, BDD-type style, Acceptance Tests have the potential to document in detail how the user interacts with the application.
In this talk we will look at the role of automated Acceptance Tests not only for testing, but also as part of the whole development lifecycle, from writing the user stories right through to deploying the application. We will also look at ways to make your automated acceptance tests more expressive and how to use them more effectively as a communication, reporting and documentation tool.
Finally, we will present and demonstrate a new open source library that helps developers and testers write automated acceptance tests for web applications using WebDriver/Selenium 2. This library also produces clean, narrative-style reports illustrated with screenshots that effectively describe the application's functionality and behaviour, as well as any regressions or pending features.
There are a lot of things we can measure about our source code, but what about the “project as a whole” and its overall health? Are there ways of measuring the effectiveness of our processes? Are there things we can measure that would point to project automation wins? Is there a way to measure team 'morale'?
While we can gather a lot of metrics from automated source inspection tools, those can make us focus on the wrong “problems to solve”… There are a lot of personal, team, and project-level things we can measure and tune that can lead to big wins. Using advice from an obsessive-compulsive numbers collector, the Personal Software Process, Scrum, the Pomodoro Time Management Technique, and Personal Kanban, we will discuss ways of effectively measuring aspects of our team and our productivity, and actions we might take based on what we learn.
Domain Specific Langauges seems like a cool idea, but where's the payoff? This talk provides an overview of how to build both internal and external DSLs (including the state of the art tools), stopping along the way to show how this is practical to your day job.
This talk defines of DSLs (Domain Specific Languages), distinguishes the types of DSLS (internal and external), and shows examples of building DSLs of several kinds. It shows how to utilize DSLs for externalizing configuration (which you're already doing, whether you realize it or not), how to make your code readable to humans, how DSLs make developer tools better (and how to use DSL techniques to build your own tools), and how DSLs can provide your users unprecedented flexibility and power, by building DSLs customized to their job. This talk provides a good foundation for the subject if you've never seen anything about it, but keeps the focus on practical goals.
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 decisionmaking 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.
“From Wikipedia: “A physics engine is computer software that provides an approximate simulation of certain simple physical systems, such as rigid body dynamics (including collision detection), soft body dynamics, and fluid dynamics, of use in the domains of computer graphics, video games and film.
Their main uses are in video games (typically as middleware), in which case the simulations are in real-time. The term is sometimes used more generally to describe any software system for simulating physical phenomena, such as high-performance scientific simulation.”
In this presentation, we'll look at some of the physics engines available, and how to use them from within Java for a variety of purposes (most of which will be game-oriented, but can easily be extrapolated into other, more business-focused, scenarios).
Games? What do games have to do with good business-oriented applications? Turns out, a lot of interesting little tidbits of user-interface, distribution, and emergence, found normally in the games we play, have direct implications on the way enterprise applications can (or should) be built.
Come to this session, find out some intriguing things about what’s going on in the game industry, but more importantly, how ideas from the gaming world can turn around and answer some thorny problems in the business world.
A successful application has to focus on three dimensions—value (business),
design (engineering) and usability. Usability is not only about the wow
factor. It is about making the application easier and intuitive to use.
In this presentation we will learn the fundamentals of creating a usable
application. We will look at some basic dos and don't. These will help you
move forward from being a programmer to a good application developer.
How do you tell a good App from a bad one?
Why bother about interfaces?
Practices to avoid
Focusing on creating good user experience.
In this session, I'll show you how to secure your Spring application with Spring Security 3.2. You'll see how to declare both request-oriented and method-oriented security constraints. And you'll see how SpEL can make simple work of expressing complex security rules.
Although we may invite guests into our homes and give someone a ride in our car, we locks and alarms on our homes and our cars to keep uninvited and malicious visitors out. Similarly, we allow people to use the applications that we develop, but we probably want to control the access that they have.
Security is an important aspect of any application. And while we could program security rules into the web controllers and methods in our application, we'd find ourselves cluttering our business logic with repetitive security code. Security is a cross-cutting concern–begging to be handled with aspect-oriented techniques.
Spring Security is an authentication and access-control framework based on Spring that provides security aspects. With Spring Security, you can declare who is allowed to access your application and what they're allowed to see, keeping your application logic focused and uncluttered with security details.
This talk will introduce the Hadoop MapReduce model and common patterns and algorithms implemented to solve common problems.
In this presentation we will introduce the MapReduce processing model and many of the common patterns implemented on top of MapReduce to achieve common processing functionality like joins and secondary sorting. Finally we will discuss a few optimizations and their tradeoffs developers can utilize when creating raw MapReduce applications.
Hadoop architecture with discussion on how the MapReduce model influenced it.
In this presentation we will go deep discussing the Hadoop architectural components and some of the early design decisions that architects and administrators should consider when deploying a Hadoop cluster. We will also touch on the Amazon Elastic MapReduce architecture and how that influences applications.
Agile has matured to the point of mainstream success. Even large companies have discovered that it helps them build better quality software faster. But the agile practices that are mainstream today have been around for a long time. What is the next wave of innovation in the Agile world going to bring?
Agile software development works because of feedback loops, and to
make it better (or repair what's broken), you identify missing
feedback loops, or replace broken ones. This talk uncovers two
feedback loops missing from most projects. The first uses Behavior
Driven Development & Cucumber to incorporate business
analysts, testers, subject matter experts, and developers one one
platform for requirements definition and verification. The other
anemic feedback loop in many organizations involves the last mile to
production: you have error prone, horrific manual releases that
everyone hates. Continuous Delivery delivers proven techniques
and tools to make “Done” better.
Spock is a developer testing framework for Java and Groovy applications. Even though it is fully JUnit-compatible on the outside, Spock isn't just another JUnit clone - its goal is to take developer testing to the next level! With its Groovy-powered and highly expressive testing language, Spock boosts productivity and brings back the fun to testing.
In the first part of this session, Spock's approach to state-based, data-driven, and behavior-based testing will be demonstrated. Next, we will explore some of Spock's extensions, in particular the Grails plugin and the Spring TestContext Framework integration. Finally, we will look under the covers of Spock and write our own extension. Along the way, expect to see lots of code and live demos.
In this talk we will cover many Gradle power features that are particularly helpful for the real heavy lifting often needed in enterprise builds.
We will start this session with the concept and advantages of autowiring the Task Dependency Graph based on the inputs and outputs. We will then talk in detail about the new dependency management features such as the new cache, customizable dynamic revision handling and customizable version conflict resolution. From there we'll explore the new extension mechanism for the Gradle DSL and introduce the Gradle daemon. We will also discuss our take on best practices for dealing with module dependencies in the enterprise and how this can be mapped with Gradle. Finally we will show how you can programatically customize the way the Gradle build model is mapped to the STS Gradle Eclipse plugin. All those features are presented in the context of our roadmap and what further improvement you can expect with future releases.
This two-part workshop provides a hands-on introduction to Gradle. You will learn the fundamentals of Gradle's build language, leverage some of its built-in tasks and plugins, use Gradle's Ant integration, learn how to manage dependencies with Gradle, and top it off with a multi-project build. Please bring your laptops! Familiarity with Java is assumed; familiarity with Groovy is a plus but not required.
n the Java build space, first there was Ant, which provided a reliable way to build without an IDE. Then there was Maven, which gave us standardization in build lifecycles and dependency management. Now… Enter the Gradle and find yourself immersed in a rich build language with the flexibility of Ant, the declarativeness of Maven, and a new level of sophistication that takes your builds further than ever before.
This two-part workshop provides a hands-on introduction to Gradle. You will learn the fundamentals of Gradle's build language, leverage some of its built-in tasks and plugins, use Gradle's Ant integration, learn how to manage dependencies with Gradle, and top it off with a multi-project build. Please bring your laptops! Familiarity with Java is assumed; familiarity with Groovy is a plus but not required.
This two-part workshop provides a hands-on introduction to Gradle. You will learn the fundamentals of Gradle's build language, leverage some of its built-in tasks and plugins, use Gradle's Ant integration, learn how to manage dependencies with Gradle, and top it off with a multi-project build. Please bring your laptops! Familiarity with Java is assumed; familiarity with Groovy is a plus but not required.
n the Java build space, first there was Ant, which provided a reliable way to build without an IDE. Then there was Maven, which gave us standardization in build lifecycles and dependency management. Now… Enter the Gradle and find yourself immersed in a rich build language with the flexibility of Ant, the declarativeness of Maven, and a new level of sophistication that takes your builds further than ever before.
This two-part workshop provides a hands-on introduction to Gradle. You will learn the fundamentals of Gradle's build language, leverage some of its built-in tasks and plugins, use Gradle's Ant integration, learn how to manage dependencies with Gradle, and top it off with a multi-project build. Please bring your laptops! Familiarity with Java is assumed; familiarity with Groovy is a plus but not required.