Westin Fort Lauderdale Beach Resort
Session at The Rich Web Experience will go in-depth! This is your opportunity to go beyond the basics and master critical skills. We expect that you are a competent developer who is ready to solve problems using today's best tools and practices.
| 8:00 - 9:00 AM | EARLY REGISTRATION: iOS, ANDROID, Git, Web Security, jQuery, & Appcelerator WORKSHOPS ATTENDEES ONLY | |||||
| 9:00 - 6:00 PM |
|
|
|
|
|
|
| 5:00 - 6:30 PM | MAIN RICH WEB/PROJECT AUTOMATION REGISTRATION | |||||
| 6:30 - 8:30 PM | DINNER/KEYNOTE | |||||
| 7:30 - 8:30 PM | Keynote: Real Time, Real Fast by Dylan Schiemann | |||||
| 8:30 - 10:30 PM | OPENING NIGHT OUTDOOR RECEPTION - TERRACE | |||||
As our web applications become more interactive, frameworks like jQuery or dojo are "necessary but not sufficient".
In this session we'll do a whirlwind tour of the next generation of javascript frameworks - from backbone, sammy, and batman to Sencha touch and SproutCore. We'll look at the strengths and weaknesses of each and how you would choose between them for various desktop and mobile web applications.
Javascript on the server. OK, cool. So what? Node.js isn't about javascript any more than the web is about http headers. With node.js you can create asynchronous, non-blocking web servers than can easily handle thousands or even tens of thousands of connections - with a single thread.
If you're creating the next generation of interactive web and mobile applications which need to connect back to your server on a regular basis, node.js is a technology you can't afford to ignore.
Awesome acceptance testing with Cucumber can make your projects run more smoothly, your website have less bugs and your development process run more efficiently.
What we will cover is how to use Cucumber to get a clear executable definition of done for each of your stories to ensure that done is really done. We'll look at how to write cucumber tests that are meaningful and not brittle and how to get "just enough" coverage at the acceptance test level by creating a "testing pyramid". Whether you've heard about cucumber but don't know how or why you'd add it to your projects or you've had problems using cucumber in the past, we'll look how highly functioning project teams are using Cucumber to deliver software more quickly, effectively and enjoyably.
Native? Titanium? PhoneGap? How should you build a mobile app? What are the trade offs and the issues you run into? Does write one run anywhere really work, and when it doesn't, what do you have to do next?
In this session we'll look through the various alternatives for building mobile apps, providing a high level overview so you can then pick the sessions using technologies that will be most applicable to your use cases.
What is a graph database, why would you use it, and how do you get started? In this session we'll look at the kinds of problems that graph databases can solve and will run through the process of getting started with neo4j
By the end of this session you'll have all of the information required to get started with neo4j on your projects.
Grails is emerging as a standard JVM web framework in environments ranging from startups to the enterprise. It's a full-stack solution build on rock-solid components, fully relying on convention over configuration, and using the best application language the JVM has yet seen: Groovy. This is the place to be for web apps on the JVM.
In this introductory talk, we'll get a whirlwind introduction to Grails, visiting seven things you need to know about the framework to get started.
Programming in Groovy
Creating an app
Interacting with the database
Building your UI
Processing web requests
Tapping the huge plugin community
Deploying to production
If you've gotten your feet wet with Grails. You've talked to friends, you've done some reading, you've seen a presentation that sold you on the awesomness of the framework. What's next? Why, some hacking, of course!
Come to this 90-minute workshop ready to create a persistent domain model, build a scaffolded UI, modify page layouts, and maybe even build some Ajax into your new web app. See how quickly you can get started building robust, scalable web apps for the JVM.
Bring a laptop of be prepared to pair with a friend. Please have a current release of Grails (http://grails.org/Download) downloaded and unzipped.
Prerequisite: An introductory Grails session or thorough reading about Grails. No previous Grails coding experience is necessary.
Ratpack is a hyper-lightweight, Groovy-based web framework for developing and deploying simple apps in a hurry. Like its high-achieving cousin Gaelyk, it provides Groovy developers with a way to create web apps without days of iteration zero setup time.
In this talk, we'll look over Ratpack's very simple structure and live-code a small, practical example application. We'll look at how to evolve simple controller logic, how to manage templates, how to persist data, and how to deploy Ratpack applications to the web. The Java world needs ways to build small applications in a hurry, and Ratpack is the latest way to do it!
The only thing better than talking about Ratpack is hacking with Ratpack. Come to this workshop for 90 minutes of directed web development using the latest un-framework for Groovy-based web apps.
The instructor will lead you in coding features in a simple web app, but you are free to hack on your own ideas as well. You will leave the session having become famliar with Ratpack and ready to start building your own small apps with it.
Prerequisite: Ratpack: the Un-Framework for Groovy Web Apps
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.
A Technology Radar is a tool that forces you to organize and think about near term future technology decisions, both for you and your company.
ThoughtWorks' Technical Advisory Board creates a "technolgy radar" 3 or 4 times a year. It is a working document that helps the company as a whole make decisions about what technologies are interesting and where we should be spending our time. This is a useful exercise both for you and your company. This session describes the process we use and how to adapt it to both your company and, more importantly, yourself. For career risk mitigation, you must know what the next big thing is, or at least be able to narrow it to a reasonable list. Attendees will leave with tools that enhance your filtering mechanisms for new technology and help you (and your organization) develop a cogent strategy to ma
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.
You're a talented coder and you apply many agile practices to your daily workflow. Still, you are looking for that next boost to better keep track of information, manage your open applications, make working with the terminal more productive, recall information quickly, manage files rapidly, and produce documentation in a portable and effective manner.
This presentation will show you how to apply DevonThink, Delicious bookmarks, RSS feeds, Pinboard.in, Pomodoro, Things, LaunchBar, Bash profiles, mind maps, markdown files and spotlight filters to become a more productive developer that has a world of information sorted and accessible at a moment's notice.
This presentation focuses on developers using the Mac platform (though a few tips are portable) since Matthew has significant experience in productivity research on this platform.
Prerequisite: Very basic developer proficiency on the Mac.
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 SQLit
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.
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.
"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.
Bring your laptop! Use your JavaScript skills to build native iOS and Android apps! Learn from an Appcelerator Titan!
This is a full day workshop specifically designed to get you up and running with Titanium and build feature-rich applications! We'll install the latest Titanium Developer and iOS SDK - then create a project in Titanium Developer and run it in the simulator to verify your setup. Basic JavaScript experience is necessary for this session; please complete a basic JavaScript course or book before attending.
Titanium is an open-source development tool for producing cross-platform mobile applications by Appcelerator. Using Titanium, you develop your mobile application using Javascript coded against the Titanium API's. Titanium Studio, an IDE for your mobile apps, invokes their compiler and builder to take your Javascript and build a native application for iOS and Android.
This is a full day workshop intended to teach you the basics of Titanium. We'll work on several exercises as you build up a complete, feature-rich, mobile application that you can deploy on either Android or iOS. Topics we'll cover in this workshop:
* Titanium quickstart
* Titanium architecture and build process
* Titanium API's
** UI elements: Lists, Labels, Windows, Views, Buttons, etc
** Navigation
** Tabs
** Databases
** Network operations
* How to manage app upgrades
* Connecting to social media sites
* Debugging Titanium Applications
* Best Practices
* Turbo charging with Coffeescript
* Building maintainable code with platform specific plugins
CoffeeScript is a programming language that compiles to JavaScript. The language adds syntactic sugar inspired by Ruby and Python to enhance JavaScript's brevity and readability, as well as adding more sophisticated features like array comprehension and pattern matching. CoffeeScript compiles predictably to JavaScript, programs can be written with less code (typically 1/3 fewer lines) with no effect on runtime performance. In this session, you'll need your laptop as we code through Coffeescript basics. Please bring a laptop with either Chrome and Safari installed. The coding session can be done on Windows, Mac, or Linux.
In this session we'll look at different uses for Coffeescript in the development world. We'll look at how to use it with jQuery, for example, and also with an app framework like Titanium. We'll explore the language features, take a tour of using it in different environments, and write code to demonstrate its time-saving features.
We'll also spend some time looking at using it for unit-testing. Coffeescript's language features also lend it to write more maintainable code - a topic that we will discuss in detail. Finally, we'll see how Coffeescript is being wrapped into larger app frameworks like node.js and Rails 3.1.
Sure, Ajax might not be the hardest thing you'll have to do on your current project, but that doesn't mean we can't use a little help here and there. While there are a plethora of excellent choices in the Ajax library space, jQuery is fast becoming one of the most popular. In this talk, we'll see why. In addition to it's outstanding support for CSS selectors, dirt simple DOM manipulation, event handling and animations, jQuery also supports a rich ecosystem of plugins that provide an abundance of top notch widgets. Using various examples, this talk will help you understand what jQuery can do so you can see if it's right for your next project.
Once we've established a solid understanding of just what jQuery can do out of the box, we'll delve deeper into the plugin space. jQuery is designed to be extended and while odds are there's a plugin that meets your needs, sometimes only a homegrown solution fits. Starting with a couple of very simple examples, we'll work our way up to more full fledged widgets.
Sure, Ajax might not be the hardest thing you'll have to do on your current project, but that doesn't mean we can't use a little help here and there. While there are a plethora of excellent choices in the Ajax library space, jQuery is fast becoming one of the most popular. In this talk, we'll see why. In addition to it's outstanding support for CSS selectors, dirt simple DOM manipulation, event handling and animations, jQuery also supports a rich ecosystem of plugins that provide an abundance of top notch widgets. Using various examples, this talk will help you understand what jQuery can do so you can see if it's right for your next project.
Once we've established a solid understanding of just what jQuery can do out of the box, we'll delve deeper into the plugin space. jQuery is designed to be extended and while odds are there's a plugin that meets your needs, sometimes only a homegrown solution fits. Starting with a couple of very simple examples, we'll work our way up to more full fledged widgets.
The word just came down from the VP - you need a mobile app and you need it yesterday. It needs to be polished and have that design stuff too. Oh and it needs to be on all the major platforms in time for the big marketing push next month. After a moment of panic, you wonder if it's too late to become a plumber but don't worry, there's hope! More and more developers are falling in love with the "write less do more" library and for good reason; it simplifies the job of today's front end engineer. But did you know jQuery could also help you with your mobile needs as well? That's right, jQuery Mobile is a touch optimized framework designed to provide a common look and feel across a wide variety of today's mot popular platforms. In this workshop, we'll take a look at all that jQuery Mobile has to offer and we'll convert a native application to an HTML5, jQuery Mobile masterpiece.
In this workshop, we'll build a mobile app taking advantage of everything jQuery Mobile and HTML5 have to offer. In this session, we'll take a look at:
* pages
* toolbars
* buttons
* form elements
* list views
In the process of building out an app or two, we'll show you how jQuery Mobile simplifies the process of mobile app development.
The word just came down from the VP - you need a mobile app and you need it yesterday. It needs to be polished and have that design stuff too. Oh and it needs to be on all the major platforms in time for the big marketing push next month. After a moment of panic, you wonder if it's too late to become a plumber but don't worry, there's hope! More and more developers are falling in love with the "write less do more" library and for good reason; it simplifies the job of today's front end engineer. But did you know jQuery could also help you with your mobile needs as well? That's right, jQuery Mobile is a touch optimized framework designed to provide a common look and feel across a wide variety of today's mot popular platforms. In this workshop, we'll take a look at all that jQuery Mobile has to offer and we'll convert a native application to an HTML5, jQuery Mobile masterpiece.
In this workshop, we'll build a mobile app taking advantage of everything jQuery Mobile and HTML5 have to offer. In this session, we'll take a look at:
* pages
* toolbars
* buttons
* form elements
* list views
In the process of building out an app or two, we'll show you how jQuery Mobile simplifies the process of mobile app development.
The single most important tool in any developers toolbox isn't a fancy IDE or some spiffy new language - it's our brain. Despite ever faster processors with multiple cores and expanding amounts of RAM, we haven't yet created a computer to rival the ultra lightweight one we carry around in our skulls - in this session we'll learn how to make the most of it. We'll talk about why multitasking is a myth, the difference between the left and the right side of your brain, the importance of flow and why exercise is good for more than just your waist line.
The single most important tool in any developers toolbox isn't a fancy IDE or some spiffy new language - it's our brain. Despite ever faster processors with multiple cores and expanding amounts of RAM, we haven't yet created a computer to rival the ultra lightweight one we carry around in our skulls - in this session we'll learn how to make the most of it. We'll talk about why multitasking is a myth, the difference between the left and the right side of your brain, the importance of flow and why exercise is good for more than just your waist line.
Interested in HTML5? Want a change to play around with the latest and greatest in web app development? This workshop is for you! We'll cover feature detection, web forms, the new HTML elements, take a spin around the canvas, and we'll finish up with offline/local storage and web sockets.
Detecting 101
Before you can take advantage of a new HTML5 feature, you have to make sure a given browser can support it. This section will cover the basics of detection as well as getting the most out of rocking cool libraries like Modernizer. We'll also look at just what to do when a browser doesn't support a feature you're trying to leverage.
New elements
Along with a new human type-able doctype, HTML5 introduces several new semantic elements. Recognizing that nearly every website in existence has a header, a footer and some navigation divs, HTML5 gives us a header, a footer and a nav element along with a few others. HTML5 seeks to pave cowpaths, not force the web to bend to its ways...
Interested in HTML5? Want a change to play around with the latest and greatest in web app development? This workshop is for you! We'll cover feature detection, web forms, the new HTML elements, take a spin around the canvas, and we'll finish up with offline/local storage and web sockets.
Detecting 101
Before you can take advantage of a new HTML5 feature, you have to make sure a given browser can support it. This section will cover the basics of detection as well as getting the most out of rocking cool libraries like Modernizer. We'll also look at just what to do when a browser doesn't support a feature you're trying to leverage.
New elements
Along with a new human type-able doctype, HTML5 introduces several new semantic elements. Recognizing that nearly every website in existence has a header, a footer and some navigation divs, HTML5 gives us a header, a footer and a nav element along with a few others. HTML5 seeks to pave cowpaths, not force the web to bend to its ways...
Day in and day out we are subjected to poorly designed applications. From those we experience directly to the time we waste waiting on others who are struggling with systems that seem like they were built to hinder the user. It doesn't have to be like this and many users are waking up and demanding better applications. Are you prepared to deliver? After this workshop, you will be. When you're done, you'll have the tools you need to make sure your application helps your users kick ass!
Usa-what now?
While most developers are schooled in algorithms and programming languages, they often lack a grounding in the fundamentals of usability; we'll start by exploring what usability is dispelling many of the myths surrounding this misunderstood aspect of software. We'll show why usability matters and help you see how it can make the difference on your projects.
The who - developing pragmatic personas.
We can't build a great UI without knowing who we're building it for. Personas are a time tested technique to help teams understand their users and facilitate building the right interface. While personas are often backed by extensive ethnographic research, they don't require months a
Day in and day out we are subjected to poorly designed applications. From those we experience directly to the time we waste waiting on others who are struggling with systems that seem like they were built to hinder the user. It doesn't have to be like this and many users are waking up and demanding better applications. Are you prepared to deliver? After this workshop, you will be. When you're done, you'll have the tools you need to make sure your application helps your users kick ass!
Usa-what now?
While most developers are schooled in algorithms and programming languages, they often lack a grounding in the fundamentals of usability; we'll start by exploring what usability is dispelling many of the myths surrounding this misunderstood aspect of software. We'll show why usability matters and help you see how it can make the difference on your projects.
The who - developing pragmatic personas.
We can't build a great UI without knowing who we're building it for. Personas are a time tested technique to help teams understand their users and facilitate building the right interface. While personas are often backed by extensive ethnographic research, they don't require months a
As a web application developer, you want to just focus on the user stories producing business value for your company or clients. Increasingly however the world wide web is more like the wild web which is growing hostile environment for web applications. It is absolutely necessary for web application teams to have security knowledge, a security model and to leverage proper security tools.
This full day training workshop on security will provide an overview of the security landscape starting with the OWASP top ten security concerns with current real world examples of each of these attack vectors. The morning will consist of a demonstration and labs using hacker tools to get an understanding of how a hacker thinks.
The session will include a walk through of the ESAPI toolkit as an example of how to solve a number of these security concerns including hands-on labs using the OWASP example swingset.
The workshop will include:
- Details on encryption technologies and frameworks, with details on how to tighten security on a tomcat application server.
- Demonstrations and labs of
HTML 5 has introduced us to the Canvas API, 2D graphics and the pleasures of plugin-free video and audio playback. One of the next hurdles we will face is native support for 3D graphics for simulations, visualizations and games.
WebGL is an early look at supporting OpenGL ES 2.0 in the canvas in most modern browsers through JavaScript APIs.
This will be an example-driven workshop that will cover the basics of 3D graphics, OpenGL and where it is going on the Web.
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:
D3.js
RGraph
SVG in the Browser
Highcharts
Raphael
Reusable widgets from the Simile Project
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.
The Web is changing faster than you can imagine and it is going to continue to do so. Webs of Documents are giving way to machine-processable Webs of Information. We no longer care about data containers, we only care about data and how it connects to what we already know.
Perhaps the concepts of the Semantic Web initiative are new to you. Or perhaps you have been hearing for years how great technologies like RDF, SPARQL, SKOS and OWL are and have yet to see anything real come out of it.
Whether you are jazzed or jaded, this workshop will provide you with the understanding of a technological tidal wave that is heading in your direction.
In this workshop, we will:
Explain the Web and Web architecture at a deeper level
Apply Web and Semantic Web technologies in the Enterprise and make them work together
Integrate structured and unstructured information
Create good, long-lived logical names (URIs) for information and services
Use the Resource Description Framework (RDF) to integrate documents, services and databases
Use popular RDF vocabularies such as Dublin Core, FOAF, DOAP
Query RDF and non-RDF datastores with the SPARQL query language
Model and Do Inference with the Web Ontology Language (OWL)
Bring your laptops. This is a hands-on workshop.
The Web is changing faster than you can imagine and it is going to continue to do so. Webs of Documents are giving way to machine-processable Webs of Information. We no longer care about data containers, we only care about data and how it connects to what we already know.
Perhaps the concepts of the Semantic Web initiative are new to you. Or perhaps you have been hearing for years how great technologies like RDF, SPARQL, SKOS and OWL are and have yet to see anything real come out of it.
Whether you are jazzed or jaded, this workshop will provide you with the understanding of a technological tidal wave that is heading in your direction.
In this workshop, we will:
Explain the Web and Web architecture at a deeper level
Apply Web and Semantic Web technologies in the Enterprise and make them work together
Integrate structured and unstructured information
Create good, long-lived logical names (URIs) for information and services
Use the Resource Description Framework (RDF) to integrate documents, services and databases
Use popular RDF vocabularies such as Dublin Core, FOAF, DOAP
Query RDF and non-RDF datastores with the SPARQL query language
Model and Do Inference with the Web Ontology Language (OWL)
Bring your laptops. This is a hands-on workshop.
This focus of part one will be to introduce web developers and testers to the powerful WebDriver API that comes with the release of Selenium 2.0. In addition, we'll look at the differences found in WebDriver's API and architecture as compared to the classic Selenium 1.x, and demonstrate how we can gracefully migrate our test suites forward.
In this session you'll have an opportunity to build an automated test suite that will verify the behavior of a simple web application across multiple modern browsers. We'll start by recording and running tests within the Selenium IDE Firefox plugin. We'll then export our tests to Java JUnit tests and then leverage WebDriver's powerful support for the Page Object pattern, a mechanism for the separation of the orthogonal concerns of logical application functionality and DOM structure, to construct effective tests which read more like executable specifications than code.
By the end of the session we'll be reusing components developed in earlier tests to construct new ones, thus accelerating our capacity to grow our test suite.
Prerequisite: Familiarity with Java will be necessary for an effective student experience. Familiarity with JUnit and/or TestNG will be helpful.
This session builds on "Selenium 2.0 Workshop - Part I" by experimenting with some of the more advanced features of Selenium. We'll dig into WebDriver's new Advanced User Interactions API, which allows us to perform actions such as drag and drop or clicking multiple elements while holding down the Control key. We'll also look at Selenium 2.0's capabilities for testing mobile web applications on both the iOS and Android platforms.
Finally we'll parallelize our tests across a compute farm using TestNG and Selenium Grid.
Prerequisite: Selenium 2.0 Workshop - Part I
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.
JavaScript is one of those very powerful languages that is often misunderstood and underutilized. It's quite popular, yet there's so much more we can do with it.
In this presentation we'll deep dive into the capabilities and strengths of this prominent language of the web.
Programmers often complain that it is hard to automate unit and acceptance tests for JavaScript. Testability is a design issue and with some discipline and careful design we can realize good automated tests.
In this presentation we'll learn how to automate the testing of JavaScript using both TDD and BDD tools.
Spock is an awesome tool that exploits Groovy AST transformation to provide elegant, fluent syntax for writing automated tests.
In this presentation we will learn how to use Spock to test both Java and Groovy code. We will taken an example oriented approach to learning the strengths of this powerful testing tool.
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.
Distributed computing is one of those problems with great potential but huge risk. The API is often messy and requires extensive efforts. However, distributed computing and network programming are here to stay and with rich client applications and mobile devices, the demand is only rising.
In this workshop we will learn how to use Netty to create high performance applications that rely heavily on network protocols.
Distributed computing is one of those problems with great potential but huge risk. The API is often messy and requires extensive efforts. However, distributed computing and network programming are here to stay and with rich client applications and mobile devices, the demand is only rising.
In this workshop we will learn how to use Netty to create high performance applications that rely heavily on network protocols.
You see them everywhere: "Like" buttons, "Tweet" buttons, and now there are "+1" buttons. The social networks have extended their reach beyond their own websites and into almost every web site you visit. But did you know that these simple little buttons are just the tip of the iceberg when it comes to adding social features to your website?
Several of the popular social networks (including Facebook, Twitter, and LinkedIn) provide client-side APIs that enable you to build social capabilities into you application. With these APIs, your application can not only show a simple button for your users to express their opinion, but can also let you query information about their profile, friends, interests, and much more.
In this example-driven presentation, we'll examine the client-side APIs offered by Facebook, Twitter, and LinkedIn. We'll dig even deeper than the "Like" button as we see how the APIs can be used to build rich social applications.
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:
Spring MVC essentials (request mapping, controllers, and views)
Field formatting and validation
Spring's JSP tag libraries
Handling file uploads
Content negotiation and non-HTML views
Request and response body conversion
Advanced request mapping
And much more!
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!!!
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:
Spring MVC essentials (request mapping, controllers, and views)
Field formatting and validation
Spring's JSP tag libraries
Handling file uploads
Content negotiation and non-HTML views
Request and response body conversion
Advanced request mapping
And much more!
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 this workshop, you'll discover the missing link in enterprise Java development: simple, portable integration tests.
For many, developing with enterprise Java has long been an arduous undertaking because it's been a bear to test. Though development life is simple with unit tests and mocks, they only get you so far. Eventually, you need to validate that your components interact and operate properly in their intended environment--you real need integration tests.
The main obstacle is that your integration tests live in a different world than your application. We'll overcome this discrepency by adopting a component model for your tests, a service provided by Arquillian. This lab puts Arquillian in your toolbox. The goal is to allow you to make a smooth transition from unit to integration tests.
What's the secret? Arquillian, a container-oriented testing framework for TestNG and JUnit, makes testing enterprise Java applications easy by bringing your test to the runtime rather than requiring you to manage the runtime from your test. Picking up where unit tests leave off, Arquillian enables you to test real components that rely on real enterprise services in a real runtime.
We'll begin by introducing you to the fluent API provided by ShrinkWrap that is used to package a test archive, giving you fine-grained control over which resources are available to be tested. We'll work on examples that demonstrate how the test archive is deployed and executed inside standalone, embedded and remote containers. You'll work through tests that exercise a wide range of technologies, including CDI, EJB, JPA, Spring, JAX-RS, JSF, web UI tests and more.
You'll walk away confident that you can:
write integration tests just as you would a unit test,
run those tests in multiple environments (containers) and
have a tool in your toolbox for both testing and discovery
Join this lab to learn how simple and powerful Java enterprise testing can be.
In this workshop, you'll discover the missing link in enterprise Java development: simple, portable integration tests.
For many, developing with enterprise Java has long been an arduous undertaking because it's been a bear to test. Though development life is simple with unit tests and mocks, they only get you so far. Eventually, you need to validate that your components interact and operate properly in their intended environment--you real need integration tests.
The main obstacle is that your integration tests live in a different world than your application. We'll overcome this discrepency by adopting a component model for your tests, a service provided by Arquillian. This lab puts Arquillian in your toolbox. The goal is to allow you to make a smooth transition from unit to integration tests.
What's the secret? Arquillian, a container-oriented testing framework for TestNG and JUnit, makes testing enterprise Java applications easy by bringing your test to the runtime rather than requiring you to manage the runtime from your test. Picking up where unit tests leave off, Arquillian enables you to test real components that rely on real enterprise services in a real runtime.
We'll begin by introducing you to the fluent API provided by ShrinkWrap that is used to package a test archive, giving you fine-grained control over which resources are available to be tested. We'll work on examples that demonstrate how the test archive is deployed and executed inside standalone, embedded and remote containers. You'll work through tests that exercise a wide range of technologies, including CDI, EJB, JPA, Spring, JAX-RS, JSF, web UI tests and more.
You'll walk away confident that you can:
write integration tests just as you would a unit test,
run those tests in multiple environments (containers) and
have a tool in your toolbox for both testing and discovery
Join this lab to learn how simple and powerful Java enterprise testing can be.
End users now expect to be presented with real time data in a web application. But these rich experiences are complex to develop. Tools like GWT enable efficient development of high-performance, rich web applications by shielding developers from JavaScript, browser quirks and evolving markup languages. However, GWT only addresses the client-side environment. Developers need a similar abstraction for exchanging real time data with the server.
Errai, an open-source GWT extension framework, streams data asynchronously over a high-performance, bidirectional messaging bus. Errai's bus runs concurrently in the browser and on the server (inside a Java Servlet). Errai's push technology delivers data from the server to any connected browser simultaneously and in real time, while the method of communication is transparent to the developer.
Errai also brings CDI, the standard Java programming model, to the browser. What, CDI in the browser? Yep, in JavaScript. This means the developer can use a single programming model for both client and server-side development. To take it a step further, Errai hooks the CDI event notifications to its messaging bus, hiding the high-performance messaging behind CDI's declarative event model. Client or server, it's all just CDI programming.
Come learn how the GWT, Errai and CDI stack enable you to create rich applications that process real time data without all the complexity.
Mobile devices such as smartphones and tablets are rapidly becoming the primary Web clients for many users. Taking your existing skills from traditional Web application development and applying them to a mobile interface can be daunting. This session walks through best practices for building a mobile solution using a combination of JSF, CDI, JMS, data grid, HTML5, and CSS3 technologies.
Attendees will learn which front-end mobile frameworks work best with Java-based technologies and how they can be used to kick-start your own applications. The presentation begins with an overview of technologies used to create the demo and then jumps into the code for a step-by-step tutorial.
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.
TBA
TBA
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'.
TBA
TBA
The browser has become an increasingly important platform for enterprise development, and GWT has long appealed to developers looking to migrate desktop apps to the Web. There are still limitations of Web apps vs. desktop apps, but HTML 5 has addressed many of these.
This session will primarily cover HTML5 features of interest to mobile and enterprise developers, including the FileSystem API and desktop-like file handling, AppCache, local storage, GeoLocation, and determining device form factor. We'll also take a look at Maven integration and new features in the latest Google Plugin for Eclipse.
Modern Web apps are rich, snappy, and work offline and mobile, too. In this talk, we'll look at the frameworks and HTML5 features that make these possible and introduce DART, a new language for structured Web programming.
In particular, we'll take a look at the motivation for DART, language syntax and features, the DART Editor, using the dartc JS compiler, and improvements to the DOM. We'll also discuss DART in relation to JS and GWT.
So you already know and love Spock, the Enterprise ready testing framework, but want to know how to make the most of it and take your testing to the next level? Then this talk is for you. Even if you're new to Spock, but are interested in making your testing more effective this talk is for you.
We'll start with how the combination of Spock and the Groovy language makes it easy to bring the concept of “executable specifications” to the realm of unit testing, without the ceremony but with all of the benefits, and why this is so important to the health of your system.
From there we'll discuss extending Spock through its own Extension API and support for JUnit rules, which is one way to make your tests much more expressive and maintainable.
We'll close with Spock's seamless integration with Grails 2.0, and some hidden Spock treasures that help you get even more out of your testing.
Geb is a browser automation solution for Groovy. It brings together the power of WebDriver, the elegance of jQuery content selection, the robustness of Page Object modelling and the expressiveness of the Groovy language. Geb enables more expressive, more concise, and (very importantly) more maintainable web tests.
In this session we'll explore the foundations of Geb and illustrate how it uses the language features of Groovy to make web automation and testing productive and effective. After exploring the basics we'll explore Geb's rich Content DSL and discuss patterns for achieving maintainable tests. We'll also look at how it combines with Spock, the Enterprise ready testing framework, to enable low cost executable specifications that describe user behaviour, not browser details.
We will be going through a handful of strange and seemingly anomalous JavaScript programming puzzles in the style of Joshua Bloch's entertaining and enlightening game show.
The goal of the presentation is to highlight some of the less understood pieces of JavaScript in an engaging format. Understanding some of the subtle nuances of the language will allow developers to deliver cleaner, more bug-free code. Come to see how well you do at answering these puzzles.
Build a Web Bowling game using HTML5, CSS, accelerometer and gyroscope, web sockets, and Box2D physics.
Hey wii bowling fans, in this workshop you will learn how to build a mobile web client that utilizes the accelerometer and gyroscope data of your smartphone to build a control for throwing objects at a remote display. We will create a node websocket server for handling the communication between the controller and the display. On the display we dig into the fantastic JavaScript Box2d physics engine to create obstacles for our remote objects to crash into. Come see just how easy this is to do and build a souvenir to take home to your kids that they really will enjoy a lot more than that starfish you were thinking of buying.
Every developer has their favorite tools and today when it comes to which browsers to develop in we have a few choices.
In this session we will be looking at the different dev tools that can be used in each of the popular browsers and discover their strengths and weaknesses. We will be looking at how to inspect elements in the DOM, use the JavaScript console, analyze network requests, spot problematic performance issues, tweak css and much more. Knowing how to use these tools and what they each offer can greatly increase your productivity as a developer and help you quickly troubleshoot browser issues. We will be focusing on Chrome's developer tools, Safari, Firebug and IE.
Come test your knowledge of HTML5 in an interactive way as you battle others in the audience in a jeopardy style game built using open web technologies. Contestants will be able buzzin using there smart phones, web browser, or even a chat client. Afterwards we will dive in and explain the technologies that we used to build the app.
Technologies that will be demonstrated come from many open web standards like HTML5, CSS3, JavaScript and Android. More details to come...
We will be exploring the features and capabilities of native platforms and comparing them to what is available via the mobile browsers. The strengths and weaknesses of both native and web approaches will be demonstrated through example applications and code.
Comparisons and debate will include graphic acceleration, persistence, geolocation, orientation changes, offline support, camera, file system access, overall experience, etc. We will touch on industry trends, what development organizations are doing, and what technical research firms are predicting.
Just as the phone has evolved and changed the way we communicate, the TV is maturing from something that we simply watch to a device that we richly interact with. Google TV is bringing the same innovation that we have enjoy on our Android phones to the television set.
The TV is not just a big computer screen. We will discuss some of the common problems that affect all TV targeted applications such as the variety of TV sizes, color quality, capabilities, and resolutions. We will also look specifically at the Google TV platform and how to bring Android applications from the phone to the TV.
Apache Solr serves search requests at the 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.
Solr provides faceted navigation, spell checking, highlighting, clustering, grouping, and other search features. Solr also scales query volume with replication and collection size with distributed capabilities. Solr can index rich documents such as PDF, Word, HTML, and other file types.
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?
Standard query parsing differences
Filter and function queries
Caching
Replicated and distributed search
Solr can be customized in amazingly powerful ways with some Lucene API know-how:
Write your own analyzer components for character mapping, tokenizing, and filtering tokens
Customize query parsing
Add your own search-time request components
Hook into Solr startup, commit, and optimize events
Adapt Solr’s response writing to your needs
Node.js and Netty are both frameworks for building scalable network applications. While Node.js runs on Chrome's V8 JavaScript engine and Netty runs on the JVM, they both have a similar architecture for building event-driven network applications.
This presentation will compare each framework’s pros and cons and discuss their weaknesses and strengths.
In this half-day session, Molly will provide an overview of whereHTML5 is within the W3C process, what its originators at the WHAT-WG are thinking about, and then jump on in to the really interesting topics of the day. Continuing deeper, we'll look at HTML5 media elements and APIs including video, audio and canvas; we'll examinerelated technologies such as Scalable Vector Graphics (SVG) and its role within contemporary site and application design; and finally, wrap up with a variety of related work in geolocation and device-oriented standards such as is emerging via other standards bodies.
Takeaways include:
A better understanding of the origins, goals and current thinking in HTML5
Real-world techniques to implement HTML5 and related tech into current workflow
A look at how browsers are changing the way we work, for better or worse
Guidance as to how to manage open, emerging technologies based on individual and group skillets.
A solid foundation for determining next steps regarding emerging tech and your current development practices
In this half-day session, Molly will provide an overview of whereHTML5 is within the W3C process, what its originators at the WHAT-WG are thinking about, and then jump on in to the really interesting topics of the day. Continuing deeper, we'll look at HTML5 media elements and APIs including video, audio and canvas; we'll examinerelated technologies such as Scalable Vector Graphics (SVG) and its role within contemporary site and application design; and finally, wrap up with a variety of related work in geolocation and device-oriented standards such as is emerging via other standards bodies.
Takeaways include:
A better understanding of the origins, goals and current thinking in HTML5
Real-world techniques to implement HTML5 and related tech into current workflow
A look at how browsers are changing the way we work, for better or worse
Guidance as to how to manage open, emerging technologies based on individual and group skillets.
A solid foundation for determining next steps regarding emerging tech and your current development practices
We've been searching for layout techniques for a long time! In fact, since the days of tables, we've not found solutions to a wide range of layout problems within the presentation layer of front-end development. Part of this is due to delays in implementation, but there's a lot to look at as we move forward.
Topics covered include CSS3 Multicolumn Layout, Grids, CSS Regions and the Flexible Box
Model. Examples of these features and how they work will be provided, and resources for future study of these techniques and implementations round out the session.
We've been searching for layout techniques for a long time! In fact, since the days of tables, we've not found solutions to a wide range of layout problems within the presentation layer of front-end development. Part of this is due to delays in implementation, but there's a lot to look at as we move forward.
Topics covered include CSS3 Multicolumn Layout, Grids, CSS Regions and the Flexible Box
Model. Examples of these features and how they work will be provided, and resources for future study of these techniques and implementations round out the session.
We are at a critical nexus point in the history of web design: the web is finally coming of age with respect to increasing sophistication of the structure and presentation of visual information, the standardization of technologies to more easily create and display this information, physical devices that make this information easily accessible, and finally growing social connectivity. The confluence of these factors creates an improved platform and foundation upon which to start designing user interfaces that create user affinity by being beautiful, easy to use and delightful -- and responsive to various devices through which users access sites and applications.
In this session, we’ll explore just how far we’ve come since the beginning of the web and how leveraging newer technologies is changing the face of web design towards emotional, experience, and responsive design, and how the lastest platforms are redefining how we use and experience websites now, and what we will expect in the future. It’s time to examine what we consider the “standard” web or application user experience and discover ways to transform a good user interface and experience -- on any device -- into a great one.
Maybe you've wanted to dive in to CSS3, but have held back because you just didn't think it was ready. Don't be fooled, CSS3 isn't the future, it's the present, and is ripe for the pickin' and is ready to respond to display your sites in multiple devices right now.
This session will touch upon the gamut of CSS3 properties from colors, web fonts, and visual effects, to transitions, animations and the foundations of responsive design: flexible grids and images, and media queries. If you aren't yet using CSS3 and haven't wrapped your head around becoming responsive, this workshop will give you the inspiration and resources to go forth and implement the new properties and practices with confidence.
As web industry professionals, we rarely experience a shortage of creativity itself. What tends to be elusive and fleeting is inspiration - often when we need it the most for important projects. Wouldn't it be great to be able to have a reliable method to evoke and tap into creative inspiration at will to spur the process of ideation and production?
This talk will explore the concepts around the sources of inspiration and ideas and practices for eliminating blocks and accessing the spark when you need it to develop and execute great work.
This session is for students are have a good understanding of CSS, but who want to gain additional troubleshooting skills.
In this session, we’ll cover some advanced CSS investigative and problem-solving techniques, including tiny tidbits to lay the foundation for clean, informative markup; ways of dealing definitively with IE6, proactive coding practices for the “other” browsers’ bugs, new alternatives to using floats for layout, and creating and using the more esoteric css2 selectors and newer css3 selectors for true style targeting power.
In 2009, 20% of people said they would leave after waiting 5 seconds for a mobile site to load. Today, that number is 74%. In spite of hardware limitations, network connectivity and latency issues, mobile users expect a fast, responsive mobile experience. It will be the sites that can provide their users the content they need quickly and efficiently that will be rewarded with user loyalty.
In this session, we'll identify some of the unique performance bottlenecks that mobile presents. We'll take a look at some of the tools for identifying those issues as well as how we can go about fixing them. We'll explore the latest in mobile performance tools and techniques in order to arm ourselves with the information we will need to give our users the faster experience they want.
We are just now starting to understand and embrace the web for what it truly is—an inherently flexible and responsive medium. As the number of internet-connected devices explodes, we are forced to reassess how we create our sites and applications. We don't know for certain what device our users will be using or where they'll be using them from. All we know is that they will expect to see meaningful content in a design that is tailored to the constraints of the device, and that this content will be delivered to them quickly—no matter where they are.
This session what it means to embrace the inherent flexibility of the web. We will discuss where our current practices and tools fall short. We'll also take a look at how new techniques like responsive enhancement can help.
"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:
Design Dos and Don'ts
Planning a Design
Design Fundamentals
Layout
Typography
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.
In this course students will learn how to add interactivity and asynchronous behavior to web sites using Javascript via the jQuery library and its companion the jQuery UI library.
The workshop consists of:
Beginning jQuery
Advanced jQuery and jQueryUI
This is a hands on course for developers so bring your laptop and be prepared to write a lot of code!
In this session you'll learn about Jasmine, a behavior-driven development (BDD) framework for testing JavaScript code. Come and learn how to raise the bar for your client side testing using the BDD mindset.
In this session you'll learn:
A bit about BDD and how it will lead you to better software
How to test non-DOM-dependent JavaScript
How to Jasmine can ease you in-browser testing (DOM dependent)
How to run client-side tests from the command line and integrate them into your build/CI environment
Recently a emergence of lightweight Javascript Frameworks has brought structure to client side by providing MVC (Model-View-Controller) implementations. In this talk we'll examine two of the most prominent frameworks; BackBone.js and Spine and their implications on how we structure and design our applications
Recently a emergence of lightweight Javascript Frameworks has brought structure to client side by providing MVC (Model-View-Controller) implementations. In this talk we'll examine one of the most prominent up and coming frameworks; Spine.js and the effect on how we structure and design our applications
Spine is a lightweight framework for building JavaScript web applications. Spine gives you a MVC structure and then gets out of your way, allowing you to concentrate on the fun stuff, building awesome web applications.
In this session you'll learn 10 tried and true jQuery techniques/plugins/practice.
From this jQuery session, you will learn how to create responsive, clean and maintainable client side code.
As web applications continue to become more interactive and sophisticated, real-time messaging and updates are becoming increasingly prevalent. One of the hottest new APIs in HTML5 is WebSocket, which enables true duplex communication without the overhead, complexity, and extraneous latency of HTTP-based solutions. See how the WebSocket removes these barriers to create optimal real-time delivery of messages from servers to browsers, including mobile. Although WebSocket is an exciting new API, we can easily fallback to HTTP-based techniques when WebSocket is not available with Dojo?s Socket API. The server-side is equally important, and real-ti me messaging has pushed the need for asynchronous I/O in the server. The Tunguska library is one example of create scalable real-time applications using the Node.js platform that is so perfectly suited for Comet.
This presentation will also cover the use of streaming abstractions to minimize buffering, and will consider the performance implications of topic-based publish-subscribe distribution versus filtering techniques.
The Dojo Toolkit is one of the original Ajax toolkits, and has reinvented itself again through a series of improvements in modularity, performance, API improvements, adjustments for HTML5 and mobile platforms, and much more to provide a stellar platform for building web apps.
Learn how Dojo's adoption of CommonJS AMD makes it a perfect toolkit for including source code from other microtoolkits, to create the most extremely optimized JavaScript toolkit for your application, big or tiny. Learn about the wide variety of new features and approaches that are available now in Dojo, as well as the forthcoming Dojo 2.0 release.
The open web is quickly either replacing, diminishing, or lowing the barrier to entry for all native platform capabilities. Strategies for logically separating data and user experience concerns create web app architectures that are easy to modify to work anywhere.
We'll talk through engaging examples, and as an audience, make our predictions for when the web will be viable in emerging areas.
HTML 5 does more then add a couple new and nifty tags to the venerable HTML markup language. It has to be seen as part of the new dynamic web which no longer delivers static documents but dynamic applications that interact with backend web services.
This talk will discuss some of the more prominent and complex features of HTML and explore how a developer can use these features securely. We will demonstrate some attacks and walk through how different defenses mitigate these attacks. One of the focus areas will also be privacy and how the user data can be protected within HTML 5 applications.
About ten years ago, collecting firewall logs and aggregated analysis of rejected packets was a good measure of prevalent automated attacks originating from worms, and later bots. However, over time attacks moved up the stack and Firewall logs became less interesting. Currently, most attacks against servers use open ports and attack the applications listening on these ports. In some ways, web applications have become the new firewall, and collecting data about web application attacks has become an important research topic. However, collecting web application attack logs from live networks has proven itself to be a lot harder then collecting firewall logs. Privacy, log formats and data volume are just some of the topics that need to be considered.
We will discuss the different approaches used to collect web application attack data
and present some results from our new 404 project.
JavaScript popularity is exploding. There have been a ton of analysis, testing and reporting tools developed recently to help us keep our JS more maintainable. Those tools are of no use unless they're run regularly to keep us informed about our code health. That's where Jenkins comes in. You know it's a great CI tool for managing your JVM/Ruby/.NET projects, so let's take it a step further and extend these benefits to your JavaScript.
In this talk, we will review how to integrate JavaScript analysis and testing tools with a build, talk about how to setup Jenkins to run your build and then about the plugins and scripts that enable useful reporting on your JavaScript code. Having some familiarity with testing your JavaScript will help, but isn't required.
In this talk, we will learn how to write testable JavaScript code, explore different testing strategies and frameworks in code, and think about what types of solutions would be best for you.
Testing JavaScript is less straightforward than testing Java or C#. There are inconsistent implementations in different engines, a wide variety of structural patterns, and not many good examples of tested JavaScript to boot.
We will look at why the JavaScript community is so far behind in testing, patterns and practices that promote testability, and then explore different options we have for properly testing our JavaScript.
You might have heard of this hot new platform called Node.JS that puts JavaScript on the server, and now it's time to see how easy it is to be productive with tools like express and MongoDB.
After an introduction to the tools, you will build a non-trivial web application with express, jade, stylus, MongoDB, and mocha. Bring your laptop for some hands-on JavaScript hacking.
Attendees will need their own laptop with recent versions of node v0.6+ (http://nodejs.org/#download), npm v1.0+ (http://npmjs.org) and MongoDB (http://www.mongodb.org/) installed. They will benefit most if they have a basic understanding of JavaScript and aren't afraid of the command-line.
You might have heard of this hot new platform called Node.JS that puts JavaScript on the server, and now it's time to see how easy it is to be productive with tools like express and MongoDB.
After an introduction to the tools, you will build a non-trivial web application with express, jade, stylus, MongoDB, and mocha. Bring your laptop for some hands-on JavaScript hacking.
Attendees will need their own laptop with recent versions of node v0.6+ (http://nodejs.org/#download), npm v1.0+ (http://npmjs.org) and MongoDB (http://www.mongodb.org/) installed. They will benefit most if they have a basic understanding of JavaScript and aren't afraid of the command-line.
Ever wanted to send a realtime "push" message from a server to a client running in a browser? Send messages from one client to another? Write realtime games and other demanding applications using JavaScript?
One of the most exciting new additions to the suite of technology collectively known as "HTML 5" is an official WebSocket standard. This finally allows full duplex bi-directional communication between a client and server over TCP.
However, the technology is still new and rapidly changing. In this talk, Johnny will explain what a WebSocket is, how it works, how to implement it on browsers that don't natively support it, and how it relates to other technologies and platforms such as HTTP long polling, Comet, Flash Sockets, mobile, and JSONP. He'll also discuss the different types of server implementations, scaling strategies, and how a it can be integrated into an existing application.
Using the same techniques we've learned over the last decade of Java and other OO languages, find out how to think about and organize a large JavaScript code base intelligently.
It often only took one or two lines of JavaScript to implement that site counter we were all so proud to show off a decade ago. Now, creating advanced web applications requires literally thousands of lines of complex JavaScript and, with the popularity of Node.js, the server side is equally daunting.
We know how to handle big projects in Java, Ruby, Python, and the like. We know how to organize our code and use frameworks to help the process. But how do we apply that knowledge to JavaScript?
In this talk, Johnny will explain and demonstrate tools, practices, frameworks, and patterns that work to making large JavaScript applications understandable, maintainable and fun!
Ever wanted to use a single code base to run touch-enabled web applications that run on just about every smart phone and tablet around?
Sencha Touch is one of the best touch-enabled web frameworks available today. Based on the proven and popular Ext JS desktop application suite, the touch counterpart uses controls that feel native but run in a mobile browser.
In this talk, Johnny will introduce Sencha Touch framework, show samples of what can be done using the technology, and demonstrate the construction and packaging of a cutting edge HTML5 application that can be downloaded and executed from a website or placed into the Android Market or Apple App Store as a native application using PhoneGap.
Now that 'NoSQL' is firmly intrenched in our vocabulary, the next step is finding a solution that works for your project. CouchDB, a key / value JSON database, is an outstanding choice for many reasons and makes things like queries, JavaScript integration, and replication simple and straight forward.
In this presentation, Johnny will introduce CouchDB including the impressive replication options and scaling strategies. He'll show how to integrate CouchDB into your Java, Node, and / or JavaScript client application and show how powerful JSON and MapReduce can be in retrieving large sets of data quickly.
Improved browser support of CSS3 has allowed us to build a richer web with visual treatments like web fonts, animations, transformations, gradients, transparency and drop-shadows. But with great power comes great responsibility. Just because you can add a skewed animated rainbow with drop shadow to your site doesn't mean you should.
In this session we'll look at what's really cool (pun intended) in CSS3 by making snow with CSS3. Yes, we'll cover transitions, transforms, keyframes and more. You'll have to restrain yourself, though. But just because you can, doesn't mean you should.
HTML5 is the new buzz word. The HTML5 specifications may still be in draft form, but that hasn’t stopped browser developers from implementing many of the proposed features. Recruiters will soon be asking for 5 to 10 years of HTML5 experience. While we can’t give that to you, we can help you stay ahead of the game!
In this practical presentation you will learn what features are implementable and how to implement them. We’ll learn about the new HTML5 doctype and elements, HTML5 web form features that enable form validation without the use of JavaScript and we'll cover the new APIS that are part of and associated with HTML5, including offline applications, storage and geolocation.
Mobile browser performance is constrained by more than just bandwidth. You already know slow loading sites create a bad user experience. But even if you’ve resolved download speed, what happens to the user experience if a site is jumpy, choppy, or worse yet, non-responsive to basic interaction.
Yes, your site loads quickly even with low bandwidth. You’ve followed the 14 WOP tips. You’ve improved your sites performance, or so you think. Your app is loading quickly, but why is it not responding quickly?
In this session you’ll learn about what YSlow and Page Speed don’t cover. We’ll talk about images, HTML5, CSS3, JavaScript and the DOM. We’ll cover common trouble spots that lead to these poor user experiences as well as tips and techniques to prevent these trouble spots from arising.
HTML forms have been the bane of web developers for years. Not anymore!
With HTML5 you may learn to love forms. Imagine a day when you can validate a form without any JavaScript. Date pickers, place holder text, pattern matching, required fields, auto focus, error handling, all without JavaScript? That day is not as far off as you think.
In this session we’ll discuss new to HTML5 form input types and attributes. We can’t promise that you’ll love creating web forms, but you will gain a new, exciting appreciation.
We’ll learn all about creating dynamic web forms with form validation without the use of javascript. Topics covered include:
The new HTML5 input types
Controlling what keyboard types gets displayed on touch keyboards, including the iPad and iPhone,
Placeholder Attribute: Adding native placeholder text and clearing on focus
Native form validation: Error messages with no javascript
Date & time input types: The jQuery datepicker, without jQuery.
Providing focus to a form element, including focus on invalid input w
Gradle is being adopted by enterprises and open-source projects alike for its ease of use, flexibility, and compatibility with existing standards. However, Gradle's true strength shines not when it is viewed as a wrapper around standards, but as a toolkit for creating your own standards to reflect your build patterns and practices. It is extensible at every level, but most powerfully at the level of Gradle plugins.
In this session, you'll learn the Gradle APIs you need to know to develop a plugin, the different ways to organize and distribute plugins, and the way you should use plugins as a means of extending the Gradle DSL to describe your build domain in a concise and idiomatic way. Examples will use real code for a plugin written by Tim and Matthew that can be used in development and automated deployment settings.
Getting software released to users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers and operations, delivery teams can get changes released in a matter of hours–sometimes even minutes–no matter what the size of a project or the complexity of its code base.
In this workshop we take the unique approach of moving from release back through testing to development practices, analyzing at each stage how to improve collaboration and increase feedback so as to make the delivery process as fast and efficient as possible. At the heart of the workshop is a pattern called the deployment pipeline, which involves the creation of a living system that models your organization's value stream for delivering software. We spend the first half of the workshop introducing this pattern, and discussing how to incrementally automate the build, test and deployment process, culminating in continuous deployment.
Getting software released to users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers and operations, delivery teams can get changes released in a matter of hours–sometimes even minutes–no matter what the size of a project or the complexity of its code base.
In this workshop we take the unique approach of moving from release back through testing to development practices, analyzing at each stage how to improve collaboration and increase feedback so as to make the delivery process as fast and efficient as possible. At the heart of the workshop is a pattern called the deployment pipeline, which involves the creation of a living system that models your organization's value stream for delivering software. We spend the first half of the workshop introducing this pattern, and discussing how to incrementally automate the build, test and deployment process, culminating in continuous deployment.
Getting software released to users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers and operations, delivery teams can get changes released in a matter of hours–sometimes even minutes–no matter what the size of a project or the complexity of its code base.
In the second half of the workshop, we introduce agile infrastructure, including the use of Puppet to automate the management of testing and production environments. We'll discuss automating data management, including migrations. Development practices that enable incremental development and delivery will be covered at length, including a discussion of why branching is inimical to continuous delivery, and how practices such as branch by abstraction and componentization provide superior alternatives that enable large and distributed teams to deliver incrementally.
Getting software released to users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers and operations, delivery teams can get changes released in a matter of hours–sometimes even minutes–no matter what the size of a project or the complexity of its code base.
In the second half of the workshop, we introduce agile infrastructure, including the use of Puppet to automate the management of testing and production environments. We'll discuss automating data management, including migrations. Development practices that enable incremental development and delivery will be covered at length, including a discussion of why branching is inimical to continuous delivery, and how practices such as branch by abstraction and componentization provide superior alternatives that enable large and distributed teams to deliver incrementally.
Getting software released to users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers and operations, delivery teams can get changes released in a matter of hours–sometimes even minutes–no matter what the size of a project or the complexity of its code base.
In this workshop we take the unique approach of moving from release back through testing to development practices, analyzing at each stage how to improve collaboration and increase feedback so as to make the delivery process as fast and efficient as possible. At the heart of the workshop is a pattern called the deployment pipeline, which involves the creation of a living system that models your organization's value stream for delivering software. We spend the first half of the workshop introducing this pattern, and discussing how to incrementally automate the build, test and deployment process, culminating in continuous deployment.
Getting software released to users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers and operations, delivery teams can get changes released in a matter of hours–sometimes even minutes–no matter what the size of a project or the complexity of its code base.
In this workshop we take the unique approach of moving from release back through testing to development practices, analyzing at each stage how to improve collaboration and increase feedback so as to make the delivery process as fast and efficient as possible. At the heart of the workshop is a pattern called the deployment pipeline, which involves the creation of a living system that models your organization's value stream for delivering software. We spend the first half of the workshop introducing this pattern, and discussing how to incrementally automate the build, test and deployment process, culminating in continuous deployment.
Getting software released to users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers and operations, delivery teams can get changes released in a matter of hours–sometimes even minutes–no matter what the size of a project or the complexity of its code base.
In the second half of the workshop, we introduce agile infrastructure, including the use of Puppet to automate the management of testing and production environments. We'll discuss automating data management, including migrations. Development practices that enable incremental development and delivery will be covered at length, including a discussion of why branching is inimical to continuous delivery, and how practices such as branch by abstraction and componentization provide superior alternatives that enable large and distributed teams to deliver incrementally.
Getting software released to users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers and operations, delivery teams can get changes released in a matter of hours–sometimes even minutes–no matter what the size of a project or the complexity of its code base.
In the second half of the workshop, we introduce agile infrastructure, including the use of Puppet to automate the management of testing and production environments. We'll discuss automating data management, including migrations. Development practices that enable incremental development and delivery will be covered at length, including a discussion of why branching is inimical to continuous delivery, and how practices such as branch by abstraction and componentization provide superior alternatives that enable large and distributed teams to deliver incrementally.
Distributed version control is all the rage these days, but is it worth it? It has been transformative for the dozens of organizations and thousands of developers that I've mentored on the unique implementation called Git. But don't take my word for it. Discover the joy of a version control system that works for you, not against you, in a hands-on workshop. Bring a Windows, Mac, or Linux laptop and we'll install, set up, use and bend Git into workflows that weren't even possible with the version control systems of yesteryear. Be prepared to rethink how lightweight, fast, and refreshing source code control can be. After completing this workshop you'll be able to do practical work with Git for your day job or weekend OSS hobby
This full day workshop takes you from the ground up with Git. By the end of the day you'll be proficient enough to contribute to an open source project using Git or to leverage inside your corporate as the canonical version control system.
Prerequisite: Knowledge of a version control system, whether that be CVS, SVN, ClearCase, Perforce, StarTeam or Accurev.
You've heard about Sonar and are intrigued by its features. It can analyze code in both a static and dynamic manner making aggregated sense of the complex figures gathered by the underlying tools such as CPD, FindBugs, Cobertura, Checkstyle, and many more. You believe your team can benefit from using it to gather metrics and to facilitate code reviews. But how do you get started? The answer is easy. Through a hands on workshop that has you installing, running, and reviewing code.
This workshop is purely hands on and will give attendees first-hand experience of the setup, configuration, and use of Sonar to analyze Java and Groovy code. Attendees will install Maven, Gradle and then Sonar and proceed to analyze an open source project, all during the course of this three hour class.
Prerequisite: Motivation to analyze source code for team-wide improvement of coding techniques and architecture.
You've heard about Sonar and are intrigued by its features. It can analyze code in both a static and dynamic manner making aggregated sense of the complex figures gathered by the underlying tools such as CPD, FindBugs, Cobertura, Checkstyle, and many more. You believe your team can benefit from using it to gather metrics and to facilitate code reviews. But how do you get started? The answer is easy. Through a hands on workshop that has you installing, running, and reviewing code.
This workshop is purely hands on and will give attendees first-hand experience of the setup, configuration, and use of Sonar to analyze Java and Groovy code. Attendees will install Maven, Gradle and then Sonar and proceed to analyze an open source project, all during the course of this three hour class.
Prerequisite: Motivation to analyze source code for team-wide improvement of coding techniques and architecture.
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 workshop, 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 workshop, 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.
How does your team handle release weekend? Is it the whole weekend? Is everyone on call? Is there a way to reverse the decision mid-stream?... How long would it take your company or team to push a single line code fix from dev into production? Way too many organizations handle the production release through manual and tedious labor following a lengthy to-do check list. Way too many organizations have no way to reproduce their production environment... because they have manually changed or updated configurations without version control... or they have OS or application server paths that are not under proper management.
What if you could "test" your production release before production? One of the answers to the last mile of continuous delivery is GLU. GLU is an open source project for deployment automation. It was created by one of the co-founders of LinkedIn (Yan Pujante) for automation of LinkedIn's deployment automation.
This session is a basic tutorial, walking through the configuration of a deployment out to multiple services. We will work through serial and parallel deployments, ensuring consistency and detecting problems. This session should be a sufficient introduction to walking through: 1) installation, 2) configuration, 3) multi-server deployments 4) manual updates and 5) automated updat
One aspect of getting your continuous delivery pipeline right is the deployment pipeline. For "continuous" delivery you will need to have a way to automate the instantiation of the entire technology stack, as well as a quick and easy detection of what changed on a server. Glu is a open source tool for providing this capability through a the modeling of the deployment platform.
This workshop will go beyond a walk through of Glu's capabilities providing a hands-on tutorial style labs.
One aspect of getting your continuous delivery pipeline right is the deployment pipeline. For "continuous" delivery you will need to have a way to automate the instantiation of the entire technology stack, as well as a quick and easy detection of what changed on a server. Glu is a open source tool for providing this capability through a the modeling of the deployment platform.
This workshop will go beyond a walk through of Glu's capabilities providing a hands-on tutorial style labs.
Chef is a community-developed platform for automated provisioning, configuration, and integration of software infrastructure. It currently boasts 190+ individuals and 40+ companies (including parent company OpsCode) as contributors, and companies like EngineYard, ElectronicArts, GoTime, and Rhapsody as adopters.
Chef achieves fully automated infrastructure via three primary disciplines:
We'll dive deeply into Chef's architecture and features, including its idempotency, its thick client/thin server philosophy, its intentional lack of dependency management (preferring and order-based configuration), and its deep integration with other tools. We'll then leverage Chef to set up infrastructure of a typical JVM-based web development project with various OS, application server and datastore configurations. You'll leave a ready to get cooking with Chef on your next software delivery effort.
Puppet is a powerful framework for the automation of tasks typically performed by system administrators as part of software infrastructure provisioning and maintenance. Puppet adoption is rapidly increasing, boasting use by companies such as Google, RedHat, Constant Contact, Zynga, and Shopzilla.
Puppet is composed of three principle components:
We'll dive deeply into Puppet's architecture and features, including its idempotent configurations, cross-platform resource abstraction layer, and graph-based modeling of resources, resource providers, and resource relationships. We'll then leverage puppet to set up infrastructure of a typical JVM-based web development project with various OS, application server and datastore configurations. You'll leave a "Master of Puppet," ready to apply it on your next software delivery effort.
What is the DevOps movement? It a nutshell, it is the idea that the days of silos are over. Development, QA, and operations can no longer be thought of as separate warring divisons with their own "turfs." Instead, we must focus on the fact that we are all part of a single value stream for the customer. By collaboration and shared expertise, we can find real overlaps between our previously segregated areas of expertise and optimize that value stream.
We'll cover the following topics:
Death to Silos: developing an culture of collaborative software delivery
Developing communication and bridge-building skills
Understanding your business and its domain
The automated "infrastructure as code" revolution
Driving performance, process, and people improvements through metrics
The DevOps' Toolkit: Puppet, Chef, Flapjack, Vagrant, and friends
Have you ever wished that your local development sandbox could look exactly like production, but you've got a mismatch between your local OS and your production OS? And what about the age old "it works on my machine" excuse that quite often stems from differences between developer sandboxes? Many have turned to virtualization, creating a machine image that can be passed around the team. But who manages the template? How do you keep things in sync?
In this session, we'll explore Vagrant (http://www.vagrantup.com), an open source tool that allows you to easily create and manage virtual development environments that can be provisioned on demand and "thrown away" when no longer needed.
Our agenda will include:
Creating new base OS templates using the Vagrant Veewee plugin
Creating a new development box using Vagrant
Provisioning the box using Puppet
Provisioning the box using Chef
Deploying a simple web application to a multi-box development environment
Packaging and distributing the box within your team
Capistrano is the de-facto tool used to deploy Rails applications, but it is useful for so much more. In this talk we will publish a real website from scratch, with consideration for real world stuff like safeguarding passwords, turning on and off application monitoring, multiple machine deployments, and general system administration tasks.
In addition to a real deploy in-session, we will look at the real deploy scripts for several real-world, large websites involving multiple machine architectures, minimal (sub second) downtimes, and different server configurations.
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.
You may have heard about cloud storage offerings such as Amazon S3, OpenStack or Microsoft Azure. While conceptually similar, these offerings have different apis and behaviour that place the "write once (run|test) anywhere" mantra at risk. The jclouds open source java and clojure library aims to eliminate cloud vendor lock-in, exposing easy to use, portable, and powerful APIs. Bring your laptop, armed with latest revs of Eclipse, git, and maven, and we'll walk through getting you setup to hack jclouds java or clojure BlobStore applications in a collaborative fashion.
During this workshop, you'll discover the value and key gotchas of cloud storage providers first hand. By the end of this session, you'll be writing testable code that creates and manages containers and
blobs, and understand how cloud storage can fit into your architecture.
You may have heard about cloud storage offerings such as Amazon S3, OpenStack or Microsoft Azure. While conceptually similar, these offerings have different apis and behaviour that place the "write once (run|test) anywhere" mantra at risk. The jclouds open source java and clojure library aims to eliminate cloud vendor lock-in, exposing easy to use, portable, and powerful APIs. Bring your laptop, armed with latest revs of Eclipse, git, and maven, and we'll walk through getting you setup to hack jclouds java or clojure BlobStore applications in a collaborative fashion.
During this workshop, you'll discover the value and key gotchas of cloud storage providers first hand. By the end of this session, you'll be writing testable code that creates and manages containers and
blobs, and understand how cloud storage can fit into your architecture.
Key/value stores are the most common storage offerings in the cloud today. While conceptually similar, BlobStores present different programming models and consistency models that must be considered in application design. After this session, you'll understand these differences, and know how to use jclouds to avoid cloud lock-in and increase testability without restricting access to cloud-specific features.
We'll start by comparing public cloud services like Amazon S3 or Microsoft Azure and private cloud software like OpenStack Swift or Eucalyptus Walrus from a feature and code/API level. We'll then
review java and clojure calls to the open source jclouds BlobStore API, abstracting away these differences. We'll finish with a review of integration patterns in production today you can consider while
designing your cloud architecture.
Whether it's HBase, Cassandra or one of the many others, you've probably already heard about NoSQL. Perhaps you have a continuous test flow dependency, yet are concerned about learning curve or infrastructure required for the NoSQL store you need.
During this talk, you'll see how you can transform infrastructure clouds such as Amazon EC2 or GoGrid into your data cluster using Apache Whirr.
We'll start by reviewing cloud provisioning and how Whirr adds service management to the underlying jclouds ComputeService API. You'll then learn whirr syntax and how to use it from the commandline or via a Java API. Finally, we'll discuss patterns for workflow integration. When you leave, you'll know how to setup and use NoSQL stores with a lot less work.
This presentation introduces the audience to the power of Gradle through many real-world examples that are demonstrated live. By the end of the presentation, you'll understand how Gradle helps to elegantly solve the challenges that we face in our daily enterprise builds.
We'll go through such powerful concepts as: advantages of declarative over imperative build systems, convention over configuration without rigidity, task definitions and dependencies, the benefits of plugins, deep multi-project support, runtime optimizations through partial builds and harvesting existing functionality through Ant and Maven integration as well as strategies for migrating from these build tools. We will demonstrate some of the innovative goodies that come with Gradle out-of-the-box, like smart incremental builds, the Gradle Daemon and the Gradle Wrapper. We show also many of the new features like Eclipse integration, Sonar integration, Heroku integration, C/C++ support and oth
This presentation introduces the audience to the power of Gradle through many real-world examples that are demonstrated live. By the end of the presentation, you'll understand how Gradle helps to elegantly solve the challenges that we face in our daily enterprise builds.
We'll go through such powerful concepts as: advantages of declarative over imperative build systems, convention over configuration without rigidity, task definitions and dependencies, the benefits of plugins, deep multi-project support, runtime optimizations through partial builds and harvesting existing functionality through Ant and Maven integration as well as strategies for migrating from these build tools. We will demonstrate some of the innovative goodies that come with Gradle out-of-the-box, like smart incremental builds, the Gradle Daemon and the Gradle Wrapper. We show also many of the new features like Eclipse integration, Sonar integration, Heroku integration, C/C++ support and oth
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 t
Do you want to learn more about Mockito framework directly from the founder? Join the workshop and get up to speed with: - principles of interaction testing - using test spies to drive the design and high quality production code - getting most of the test spy pattern to produce readable and maintainable tests - solutions to typical unit testing challenges with regards to mocking - Mockito features and patterns along with the use cases when they are most useful
See you at the workshop! Please take your laptop so that you can code the exercises in your own, most friendly environment.
Maybe you have used Cucumber (or cuke4duke) to define and test the behaviors of your code, but what about the behaviors of the platform your code is running on. With the push towards 'infrastructure as code' shouldn't we test it as well?
In this session we will walk through defining the behaviors of our system, writing step definitions to test them, and adding those tests to a monitoring system.
"Is it Running Now? Good!" Too often the scope of monitoring is "the server returns 200" or "a string is present" but this is usually a small part of what our web applications do. If you ran Twitter would you want to know the number of tweets per second? If you ran Amazon would you want to know the number of orders per hour?
In this session we will discuss what to measure, how to measure it, and demonstrate using various techniques to expose our measurements to monitoring software.
The dynamic nature of services like Amazon's EC2 let us build our applications with the intent to scale horizontally if your business succeeds. Unfortunately the traditional way of managing servers just doesn't cut it when you need to add two more application servers in the next 20 minutes.
Chef is one of the rising stars of the "Infrastructure as Code" tools. In this session we will start with a blank Chef repository and build our configurations to deploy a WAR on multiple Tomcat instances behind Apache.
After seeing the possibilities of "Infrastructure as Code" with Chef you will have a chance to try it out. In this workshop we will start with a blank Chef repository and build our configurations to deploy a WAR on multiple Tomcat instances behind Apache.
For this workshop you will need a laptop and Oracle VirtualBox 4. Make sure you download the software before the session begins. A virtual machine will be distributed with the pieces you need to participate.
Prerequisite: Running in the Cloud with Chef
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)
Not ready to register yet? Enter your email here to receive update notifications about this event.
