You've read that the relational model is old and busted, and there are newer, faster, web-scale ways to store your application's data. You've heard that NoSQL databases are the future! Well, what is all this NoSQL stuff about? Is it time to ditch Oracle, MySQL, and SQL Server in favor of the new guard? To be able to make that call, there's a lot you'll have to learn.
In this session, we'll take a whirlwind tour of several representative non-relational data stores, including Cassandra, MongoDB, and Neo4J. We'll learn the very different ways they represent data, and we'll see their unique strengths and weaknesses in various kinds of applications. Along the way, we'll learn why new technologies must be introduced to address today's scaling challenges, and what compromises we'll have to make if we want to abandon the databases of our youth. We'll review what ACID means, think about query idioms, and talk about the CAP theorem. It's an exciting time to be storing and retrieving data, and the opportunity is now before us to learn things we could ignore just a few years ago. Come to this session for a solid introduction to a growing field.
Hadoop is a MapReduce framework that has literally sprung into the vernacular of “big data” developers everywhere. But coding to the raw Hadoop APIs can be a real chore. Data analysts can express what they want in more English-like vocabularies, but it seems the Hadoop APIs require us to be the translator to a less comprehensible functional and data-centric DSL.
The Cascading framework gives developers a convenient higher level abstraction for querying and scheduling complex jobs on a Hadoop cluster. Programmers can think more holistically about the questions being asked of the data and the flow that such data will take without concern for the minutia.
We'll explore how to set up, code to, and leverage the Cascading API on top of a Hadoop sample or production cluster for a more effective way to code MapReduce applications all while being able to think in a more natural (less than fully MapReduce) way.
During this presentation, we'll also explore Cascading's Clojure-based derivative, Cascalog, and how functional programming paradigms and language syntax are emerging as the next important step in big-data thinking and processing.
Want to go deep on a popular NoSQL database? Cassandra is a scalable, highly available, column-oriented data store in use at Netflix, Twitter, Reddit, Rackspace, and other web-scale operations. It offers a compelling combination of a rich data model, a robust deployment track record, and a sound architecture, making it a good choice of NoSQL databases to study first.
In this session, we'll talk about Cassandra's data model, look at its query idioms, talk about how to deploy it, and look at use cases in which it is an appropriate data storage solution. We'll study its origins in the Amazon Dynamo project and Google's BigTable, and learn how its architecture helps us achieve the gold standard of scalability: horizontal scalability on commodity hardware. You'll leave prepared to begin experimenting with Cassandra immediately and planning its adoption in your next project.
You love Groovy and you're a believer in cloud computing. For a larger project you might choose Grails and hosting on Amazon EC2, but what if you want to take advantage of the nearly massless deployments of a cloud provider like the Google App Engine? You could make Grails work, but it's not always the best fit. Enter Gaelyk.
Gaelyk is a lightweight Groovy web application framework built specifically for the Google App Engine. In this session, we'll talk through the simple abstractions it offers, then show how easy it is to code and deploy a useful application to the cloud.
With the forthcoming release of Java7, a number of things come to fruition, both in the Java language and in the libraries, and it's important for Java developers to know what those features are, and how they change the game of writing Java code–or not.
In this presentation, we'll go over those changes, JSR by JSR, and discuss where and how they may affect your next project.
Programming concurrency has turned into a herculean task. I call the traditional approach as the synchronized and suffer model. Fortunately, there are other approaches to concurrency and you can reach out to those directly from your Java code.
In this presentation we will discuss the actor based concurrency and also the software transaction memory. We will then develop examples using AKKA and compare the power of these approaches in contrast to the traditional approach.
Traditional collections on the Java platform focused on providing thread-safety at the expense of performance or scalability. More modern data structures strive to provide performance without compromising thread-safety. Some of them require you to adopt to a different semantics or programming model. In this presentation we will explore some data structures that can help reach both thread-safety and reasonable performance.
Concurrent collections, immutable collections, operations on and performance of lists, blocking queues, and tries.
Most of the time when people talk about agile software development, they talk about project and planning practices and never mention actual development practices. This talk delves into best development practices for agile projects, covering all of its aspects.
Most of the time when people talk about agile software development, they talk about project and planning practices but never mention actual development, as if development where an afterthought when writing software. This talk bills into the real details of how to do agile development. I discuss best practices like continuous integration, pair programming, how developers should interact with story cards, how to handle enterprise concerns like integration with other software packages, and a slew of other topics related to agile software development.
“The Google Guava project contains a host of new features/classes for use by the Java programmer. Intended as a drop-in supplement for the standard JDK APIs, Guava provides features like immutable and forwarding collections, some concurrency utilities, more support for primitives, and so on.
In this session, we'll go over the Guava library, looking at what it provides, when you might seek to use it, and what the overheads and consequences of using it would be.”
Emergent design is a big topic in the agile architecture and design community. This session covers the theory behind emergent design and shows examples of how you can implement this important concept.
This session describes the current thinking about emergent design, discovering design in code. The hazard of Big Design Up Front in software is that you don't yet know what you don't know, and design decisions made too early are just speculations without facts. Emergent design techniques allow you to wait until the last responsible moment to make design decisions. This talk covers four areas: emergent design enablers, battling things that make emergent design hard, finding idiomatic patterns, and how to leverage the patterns you find. It includes both proactive (test-driven development) and reactive (refactoring, metrics, visualizations, tests) approaches to discovering design, and discusses the use of custom attributes, DSLs, and other techniques for utilizing them. The goal of this talk is to provide nomenclature, strategies, and techniques for allowing design to emerge from projects as they proceed, keeping you code in sync with the problem domain. This talk shows lots of examples of how to make this concept work in your environment.
Agile has matured to the point of mainstream success. Even large companies have discovered that it helps them build better quality software faster. But the agile practices that are mainstream today have been around for a long time. What is the next wave of innovation in the Agile world going to bring?
Agile software development works because of feedback loops, and to
make it better (or repair what's broken), you identify missing
feedback loops, or replace broken ones. This talk uncovers two
feedback loops missing from most projects. The first uses Behavior
Driven Development & Cucumber to incorporate business
analysts, testers, subject matter experts, and developers one one
platform for requirements definition and verification. The other
anemic feedback loop in many organizations involves the last mile to
production: you have error prone, horrific manual releases that
everyone hates. Continuous Delivery delivers proven techniques
and tools to make “Done” better.
You're serious about improving the quality of your code base, but with 10,000 lines of code, where do you start and how do you ensure the greatest ROI for the re-work your team members will perform?
Sonar is an open source tool that brings together the best of breed static and dynamic analysis of Java projects. The result is a unified view of problematic areas of your code on a time-line basis, allowing the team to attack the problems with the best ROI, and maintain a more watchful eye for positive and risky trends in the codebase in the future.
This talk will show you Sonar from the ground up and explain 10 critical metrics that affect your code's flexibility, stability, and durability.
Does your application transmit customer information? Are there fields of sensitive customer data stored in your DB? Can your application be used on insecure networks? If so, you need a working knowledge of encryption and how to leverage Open Source APIs and libraries to make securing your data as easy as possible. Cryptography is quickly becoming a developer's new frontier of responsibility in many data-centric applications.
In today's data-sensitive and news-sensationalizing world, don't become the next headline by an inadvertent release of private customer or company data. Secure your persisted, transmitted and in-memory data and learn the terminology you'll need to navigate the ecosystem of symmetric and public/private key cryptography.
Cryptography at first seems like a daunting topic. But after a basic intro and the leverage of the Java Cryptography Extension (JCE), it seems downright feasible to add encryption and decryption capabilities to your application.
Developers weren't satisfied with just the JCE and its plug-in concepts though. Over the last few years, framework architects have made strides in either wrapping or re-writing the approachable JCE in more convenient APIs and fluent interfaces that make effective and accurate crypto down right simple.
Explore three of these libraries – Jasypt, BouncyCastle and KeyCzar – and how they can be leveraged to make your next Java cryptography and data security effort a simple exercise and not a tribulation.
Jasypt, BouncyCastle and KeyCzar are three open source frameworks that bring unique new crypto algorithms such as elliptic curve cryptography to the enterprise developer, remove repetitive ceremonious setup and tear down coding, and add high level adapters to the Spring and Hibernate frameworks.
Building an application is not the straightforward exercise it used to be. Decisions regarding which architectural approaches to take (n-tier, client/server), which user interface approaches to take (Smart/rich client, thin client, Ajax), even how to communicate between processes (Web services, distributed objects, REST)… it's enough to drive the most dedicated designer nuts. This talk discusses the goals of an application architecture and why developers should concern themselves with architecture in the first place. Then, it dives into the meat of the various architectural considerations available; the pros and cons of JavaWebStart, ClickOnce, SWT, Swing, JavaFX, GWT, Ajax, RMI, JAX-WS, , JMS, MSMQ, transactional processing, and more.
After that, the basic architectural discussion from the first part is, with the aid of the audience in a more interactive workshop style, applied to a real-world problem, discussing the performance and scalability ramifications of the various communication options, user interface options, and more.
Fred Brooks said, “How do we get great designers? Great designers design, of course.” So how do we get great architects? Great architects architect. But architecting a software system is a rare opportunity for the non-architect.
The kata is an ancient tradition, born of the martial arts, designed to give the student the opportunity to practice more than basics in a semi-realistic way. The coding kata, created by Dave Thomas, is an opportunity for the developer to try a language or tool to solve a problem slightly more complex than “Hello world”. The architectural kata, like the coding kata, is an opportunity for the student-architect to practice architecting a software system.
In this session, attendees will be split into small groups and given a “real world” business problem (the kata). Attendees will be expected to formulate an architectural vision for the project, asking questions (of the instructor) as necessary to better understand the requirements, then defend questions (posed by both the instructor and their fellow attendees) about their choice in technology and approach, and then evaluate others' efforts in a similar fashion. No equipment is necessary to participate–the great architect has no need of tools, just their mind and the customers' participation and feedback.
A Technology Radar is a tool that forces you to organize and think about near term future technology decisions, both for you and your company. This talk discusses using the radar for personal breadth development, architectural guidance, and governance.
ThoughtWorks Technical Advisory Board creates a “technology radar” twice a year, a working document that helps the company make decisions about interesting technologies and where we spend our time. ThoughtWorks then started conducting radar-building exercises for our clients, which provides a great medium for technologists company-wide to express their opinions about the technologies they use every day. For companies, creating a radar helps you document your technology decisions in a standard format, evaluate technology decisions in an actionable way, and create cross-silo discussions about suitable technology choices. This session describes the radar visualization and how to conduct a radar building session for yourself. After a brief introduction, the bulk of the workshop consists of attendees building a radar for the group, following the same procedure you'll use when you do this exercise at your company. At the end, we'll have created a unique Radar for this event and practiced doing it for yourself.
Computer science is built on a shaky tower of abstractions, but we've been distracted by other things until we believe it is reality.
This talk teases apart some of the tangled abstractions that have become so common they are invisible yet impact important decisions. I cover languages, tools, platforms, and burrow all the way down to fundamental concepts. This wide-ranging keynote answers these questions and more:
* Which language should I learn next? And should I bother?
* Why is the iPad is the most revolutionary device in the last 30 years?
* Why do some people hate Maven so much?
* How can I choose technologies with long shelf lives?
* Is hiding always a good thing?
Oh, and some jokes too.
One of the hallmarks of lean software development is the elimination of waste. Several of the key wastes in software development revolve around incomplete, incorrect, or obsolete documentation, especially documentation of requirements. One effective means of ensuring that your requirements documentation is complete, correct, and up-to-date is to make it executable. That sounds nice, but how do we get it done, especially in the world of modern, cross-browser web applications?
Executable web application specifications are within your reach through the combination of Spock, a testing and specification framework written for the JVM in Groovy, and Geb, an elegant Groovy wrapper around the powerful WebDriver browser automation framework. In this session we'll take a close look at Spock specifications for describing and verifying the behavior of our applications. We'll then examine how we can use Geb's implementation of the Page Object pattern and its “jQuery-ish” API for interacting with our web applications in WebDriver's range of supported browsers. Finally, by gluing these two technologies together via Geb's Spock integration, we'll automate the requirements specification for a simple web app.
Quite a few languages have raised to prominence on the JVM. A frequently asked question is “How do I integrate my Java code with these?” This session answers that very specific question.
Learn how to integrate code written in Java, Clojure, Scala, and Groovy. We will discuss both language level integration and architectural boundaries.
Even with the recent explosion in alternative languages for the JVM, the vast majority of us are still writing code in “Java the language” in order to put bread on the table. Proper craftsmanship demands that we write the best Java code that we can possibly write. Fortunately we have a guide in Joshua Bloch's Effective Java.
In his foreward to the first edition, Guy Steele writes about the importance of learning three aspects of any language: grammar, vocabulary, and idioms. Unfortunately many programmers stop learning after mastering the first two. Effective Java is your guide to understanding idiomatic Java programming.
Effective Java is organized into 78 standalone “items,” all of which will be impossible to cover in one session. Instead I've chosen a subset of the most important techniques and practices that are commonly missed by today's Java programmers. You'll pick from a menu and decide where we'll head. Regardless of the path we take, you'll leave this session thoroughly equipped to write better Java code tomorrow!
Many development shops have made the leap from RCS, Perforce, ClearCase, PVCS, CVS, BitKeeper or SourceSafe to the modern Subversion (SVN) version control system. But why not take the next massive stride in productivity and get on board with Git, a distributed version control system (DVCS). Jump ahead of the masses staying on Subversion, and increase your team's productivity, debugging effectiveness, flexibility in cutting releases, and repository redundancy at $0 cost. Understand how distributed version control systems are game-changers and pick up the lingo that will become standard in the next few years.
In this talk, we discuss the team changes that liberate you from the central server, but still conform to the corporate expectation that there's a central master repository. You'll get a cheat sheet for Git, and a trail-map from someone who's actually experienced the Subversion to Git transition.
Lastly, we'll even expose how you can leverage 75% of Git's features against a Subversion repository without ever telling your bosses you are using it. Be forewarned that they may start to wonder why you are so much more effective in your checkins than other members of your team.
Git is a version control system you may have been hearing a bit about lately. But simply hearing more about it may not be enough to convince you of its value. Getting hands on experience is what really counts. In this workshop, you'll bring your Windows, Mac or Linux laptop and walk through downloading, installing, and using Git in a collaborative fashion.
The workshop style of this class will allow you to observe and discover the value of this new version control tool first hand. You'll be cloning, creating, commiting, and pushing repositories by the conclusion of this session.
git
is on your PATH
(in the environment variable list of paths)Object-oriented programming was formally introduced in the 1970's with the advent of Smalltalk. C++ took it mainstream in the 1980's, and Java carried it to the next level in the 1990's. Unfortunately, if you examine the vast majority of Java codebases, what you'll find is a bunch of C-style structs (a.k.a. JavaBeans) and functions. As these codebases grow, a number of design smells can potentially crop up, which in turn cripple our ability to respond to change. We need SOLID principles that we can apply to keep our software clean and malleable.
Robert C. “Uncle Bob” Martin identified several design smells in his book Agile Software Development: Principles, Patterns, and Practices:
We can reverse and in fact avoid these techniques by following the principles of SOLID software design:
You'll leave this session equipped to ferret out design smells and apply these principles on your next project.
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.
With the rise of multi-core processors, and their growing ubiquity (on client machines, to say nothing of the server machines on which Java applications most frequently execute), the need to “program concurrently” has risen from “nice-to-have” to “mandatory” requirement, and unfortunately the traditional threading-and-locking model is just too complicated for most Java developers–even the brightest of the lot–to keep track of with any degree of reliability. As a result, numerous new solutions are emerging, each of them with their own strengths and weaknesses, leaving the Java developer in a bit of a quandary as to which to examine.
In this presentation, we'll look at Akka, a framework/platform specifically aimed at building high-throughput, concurrency-friendly applications in either Java or Scala (or both), with a slew of additional add-on modules to handle issues like persistence, communication (pub-sub, REST, and more), and more. By the time we're done, you'll be able to start looking into using Akka on your own projects, and have a good feel for what your projects would look like when Akka-ized.
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.
The first in a series of talks that are part of an arc covering next-generation information-oriented, flexible, scalable architectures. The ideas presented apply to both external and internal-facing systems.
The REpresentational State Transfer (REST) architectural style has emerged as a winning strategy for building scalable, flexible, resilient systems that lead with an information focus. Far from being the simple “Web Services through URLs” idea many people have about them, REST-based systems require a new perspective, a fair amount of consideration and the discipline to look beyond simple point-to-point interactions.
The benefits are exciting and provide a gateway to a whole new world of information technology. This first talk will be an introductory session covering the basics of the REST architectural style.
The second in a series of talks that are part of an arc covering next-generation information-oriented, flexible, scalable architectures. The ideas presented apply to both external and internal-facing systems.
People already familiar with REST (or who have attended the first session) will be walked through the deeper topics of building Level 3 Hypermedia-based RESTful systems, security, content negotiation, etc.
The fourth of a series of talks that are part of an arc covering next-generation information-oriented, flexible, scalable architectures. The ideas presented apply to both external and internal-facing systems.
The Web of Documents we are so familiar with is being extended with the technologies of the Semantic Web. Information will be freed from its containers and connected regardless of where it comes from. Building on the concepts of REST services and the Web Architecture, we will introduce the Resource Description Framework (RDF) as the basis of a new collection of tools for information sharing and integration. Once the information is woven together, we will want to query it and produce new information resources with technologies like the SPARQL query language.
People already familiar with REST and the Web (or who have attended the REST sessions) will be given both conceptual and technical examples of how and why these technologies are laying the foundation of future information systems.
The fifth in a series of talks that are part of an arc covering next-generation information-oriented, flexible, scalable architectures. The ideas presented apply to both external and internal-facing systems.
Once we have a flexible and extensible data model like RDF, we will want to find ways to weave it into our documents to make them easier to organize, find and extract value from on the Web. This talk will highlight techniques for adopting RDFa but will also motivate attendees to dig deeper by showing them how it is already being used by the biggest names on the Web. Improve your search results and allow your customers to leverage relevant information for their own purposes.
You understand how important it is to be on the Web. Come learn how important it is to be on the Web of Data.
The sixth in a series of talks that are part of an arc covering next-generation information-oriented, flexible, scalable architectures. The ideas presented apply to both external and internal-facing systems.
This talk will wrap up the vision presented in the other sessions into an integrated service oriented architecture that yields results on the promises we were given a decade ago, even if we have to consider alternate technologies to get there.
We will walk through the adoption of new REST services, wrapping legacy systems, describing these services with metadata, documenting them, discovering them and binding to them in run time orchestrations.
Attendees should be familiar with the topics presented in the first four talks before attending this fifth one, although we will try to make it accessible on its face value.
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.
Groovy was never intended to replace Java. Instead, it expands Java capabilities and makes developers' lives easier. In this presentation, we'll survey many ways to make your Java systems easier by adding Groovy.
Among the topics we'll cover are: parsing and generating XML, simplifying your build, making testing easier, quick database access, working with Spring, and mixing Groovy and Java at the code level.
The Spock framework brings simple, elegant testing to Java and Groovy projects. It integrates cleanly with JUnit, so Spock tests can be integrated as part of an existing test suite. Spock also includes an embedded mocking framework that can be used right away.
In this presentation, we'll look at several examples of Spock tests and review most of its capabilities, including mock objects and integration with Spring.
Build processes are a pain point in most organizations. Ant is mature but very low level, Maven is powerful but hard to customize, and so on. The Gradle project brings the power and flexibility of Groovy to build files and processes.
Gradle makes it easy to do dependency management, build subprojects, incremental builds, and more. Custom tasks are easy to add, and basic Groovy capabilities like closures, parameterized strings, and builders are all available. Gradle also includes many plugins that make developing Java projects, Groovy projects, web projects, and more very easy.
Most teams manage database change using an ad-hoc system of SQL migration scripts manually applied to various development, staging, and production servers. Some even contrive automated processes, but rarely does this surplus build engineering deliver value directly to the customer. We should be writing applications, not build tools.
In this session, we'll take a look at a ready-to-use, open-source database refactoring tool called Liquibase. Liquibase enables developers to make database changes with confidence, share those changes in a predictable way with other team members, and apply them to automated QA builds, staging servers, and production environments. It provides a credible path to agile database development, and it integrates well into popular build tools. It's a key enabler of the culture of database responsibility that most teams are missing.
Automated functional testing is very critical to ensure the code we write is relevant and continues to provide direct business value as it evolves. Business analyst and customers can help develop these tests and programmers can help maintain these. Easyb is a great tool for creating such automated tests.
In this sessions we will explore the key features and strengths of Easyb and how you can use it to create automated tests of your user stories.
One of the first principles of lean software development is the elimination of waste. Shigeo Shingo identified seven types of manufacturing waste in his “A Study of the Toyota Production System.” Later, the Poppendieck's translated these to seven wastes of software development.
The seven wastes:
In this session, we'll examine each of these wastes and look at some of their common manifestations, both in our coding practices and in our development methodologies. We'll also examine strategies for eliminating each of these wastes from our development efforts.
Feature requests are steadily pouring in, but the team cannot respond to them. They are paralyzed. The codebase on which the company has “bet the business” is simply too hard to change. It's your job to clean up the mess and get things rolling again. Where do you begin? Your first task is to get the lay of the land by applying a family of techniques we'll call “Code Archaeology.”
In this session we will learn how to systematically explore a codebase. We'll look at what tools are available to help us out, slinging some wicked shell-fu along the way. We'll look at “code islands” and “code bridges,” and how to construct a “map of the code.” We'll also examine the wisdom that thought leaders like Michael Feathers and Dave Thomas have leant to this subject.
Once we've gained a thorough understanding of what we have in front of us, we'll learn approaches for getting the system under test and refactoring so that we can start to pick up the pace and respond to user requirements without making a bigger mess. You'll leave this session well prepared to tackle the next “big ball of mud” that gets dumped on your desk.
JavaScript is one of the most widely used languages around and yet its also one of the most misunderstood. With Ajaxified UIs becoming the norm, this humble language is once again at the forefront.
In this talk, we'll go beyond the basics of JavaScript delving into the mysteries of prototype inheritance, objects, language edge cases and the importance of testing.
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.
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.
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 session, 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 session, we'll take a look at:
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.
Alistair Cockburn has described software development as a game in which we choose among three moves: invent, decide, and communicate. Most of our time at No Fluff is spent learning how to be better at inventing. Beyond that, we understand the importance of good communication, and take steps to improve in that capacity. Rarely, however, do we acknowledge the role of decision making in the life of software teams, what can cause it to go wrong, and how to improve it.
In this talk, we will explore decision making pathologies and their remedies in individual, team, and organizational dimensions. We'll consider how our own cognitive limitations can lead us to to make bad decisions as individuals, and what we might do to compensate for those personal weaknesses. We'll learn how a team can fall into decisionmaking dysfunction, and what techniques a leader might employ to healthy functioning to an afflicted group. We'll also look at how organizational structure and culture can discourage quality decision making, and what leaders to swim against the tide.
Software teams spend a great deal of time making decisions that place enormous amounts of capital on the line. Team members and leaders owe it to themselves to learn how to make them well.
You've got your build automated using Ant/Maven/Gradle and you're building and running your unit test suite every time you check-in. That's easy. In fact, with Jenkins you can do this in under 5 minutes.
However, if we want to move beyond “mere” Continuous Integration to Continuous Delivery, there are many other areas in which we need to achieve “push button” automation. This talk will survey many of these areas and tie everything together with an integrated case study at the end.
In this talk, we'll look at:
Some developers assume that agility and usability are mutually exclusive - in reality, they are extremely complimentary; if you squint, you might have a hard time telling the difference between agile practices and good user interface design. This usability talk is aimed squarely at developers giving you the tools you need to develop UIs that won't make your users yack. We'll discuss the importance of observation, personas, paper prototyping, usability testing and the importance of good moderators. In addition, we'll map the various aspects of user interface design to a typical agile iteration.
Some developers assume that agility and usability are mutually exclusive - in reality, they are extremely complimentary; if you squint, you might have a hard time telling the difference between agile practices and good user interface design. This usability talk is aimed squarely at developers giving you the tools you need to develop UIs that won't make your users yack. We'll discuss the importance of observation, personas, paper prototyping, usability testing and the importance of good moderators. In addition, we'll map the various aspects of user interface design to a typical agile iteration.
Scala is a statically typed, fully OO, hybrid functional language that provides
highly expressive syntax on the JVM. It is great for pattern matching,
concurrency, and simply writing concise code for everyday tasks. If you're a
Java programmer intrigued by this language and are interested in exploring
further, this section is for you.
We will go through a rapid overview of the language, look at its key strengths and capabilities, and see how you can use this language for your day-to-day programming. This session will be coding intensive, so be ready for some serious Scala syntax and idioms.
This session will survey a wide range of tools across the Java space. We'll look at utilities such as VisualVM, jstatd, jps, jhat, jmap, Eclipse Memory Analyzer, jtracert, btrace and more.
Open Source is not just a suite of libraries you consume within your application, but now reaches into the space of tools to help you troubleshoot and improve your applications. The price of these tools eliminates barriers to their use and their open source nature allows you to mix and match them into compositions that work well for your application's unique debugging needs.
These tools will help you peel away layers of your application to expose bugs and performance ceilings. We'll interactively analyze the heap and garbage collection cycles of both local and remote applications, take snapshots of heap, query the heap for heavy usage, leaks and augment running code without a reboot and without breaking a sweat. After attending, you'll never look at Java debugging the same way again.
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.
Android is a new mobile development platform, based on the Java language and tool set, designed to allow developers to get up to speed writing mobile code on any of a number of handsets quickly. In this presentation, we'll go over the basic setup of the Android toolchain, how to deploy to a device, and basic constructs in the Android world.
Attendees should be intermediate to advanced Java developers, as no time will be spent on Java basics, just the Android parts. Attendees are encouraged to bring laptops to the session (and your Android-based device, if you have one) to fill out code as we go, but the limited time frame means a focus on fast delivery of content and example code; have your fingers warmed up (and the SDK downloaded!) before you get here. (Latest Android SDK will also be on a USB key for attendees' use, in case attendees haven't had a chance to download & install.)