Speakers
- Venkat Subramaniam
- Matt Stine
- Brian Sletten
- Ken Sipe
- Nathaniel Schutta
- Pratik Patel
- Matthew McCullough
- Neal Ford
- Tim Berglund
- Peter Bell
- Craig Walls
- Kris Zyp
- Nicholas C. Zakas
- Andrew Wirick
- Chris Wilson
- James Williams
- Greg Wilkins
- Mike Wilcox
- Dustin Whittle
- Estelle Weyl
- Johnny Wey
- Eric Wendelin
- Rich Waters
- David Verba
- Tom Valletta
- Johannes Ullrich
- Tenni Theurer
- Etienne Studer
- Steve Souders
- Deryk Sinotte
- Scott Shattuck
- Bill Scott
- Matt Schmidt
- Dylan Schiemann
- Christian Schalk
- Brian Sam-Bodden
- Terry Ryan
- Alex Russell
- Rob Rusher
- Rick Ross
- Tom Robinson
- Torrey Rice
- Aza Raskin
- Nandini Ramani
- Matt Raible
- Vic Patterson
- Noah Paci
- Aaron Newton
- Mark Murphy
- Rebecca Murphey
- William Morris
- Eric Miraglia
- Eric Miller
- Steffen Meschkat
- Dustin Machi
- Kevin Lynch
- Andrew Lombardi
- Howard Lewis Ship
- Brian Leroux
- Nik Krimm
- Dave Klein
- Sean Kane
- Tim Kadlec
- Bruce Johnson
- Denise Jacobs
- Bob Ippolito
- Kevin Hoyt
- Molly Holzschlag
- Josh Holmes
- Mike Heath
- Erik Hatcher
- Patrick Haney
- Clint Hall
- Kevin Hakman
- Aaron Gustafson
- Arun Gupta
- Nate Grover
- Mike Girouard
- Jesse James Garrett
- Thomas Fuchs
- Jon Ferraiolo
- Szczepan Faber
- Cal Evans
- Ben Ellingson
- Nicholas Eddy
- Scott Dietzen
- Gabriel Dayley
- Luke Daley
- Patrick Chanezon
- David Chandler
- Ludovic Champenois
- Max Carlson
- Bob Byron
- Thomas Burleson
- Ryan Breen
- David Boloker
- David Bock
- Rey Bango
- Tom Ball
- Dan Allen
- Brad Abrams
Tim Berglund
Developer, Consultant, Author
Tim is a full-stack generalist and passionate teacher who loves coding, presenting, and working with people. He believes the best developer is one who is well-informed of specifics and can also make deep connections between software development and the broader world. He has recently been exploring non-relational data stores, continuous deployment, and how software architecture should resemble an ant colony.
His firm, the August Technology Group, helps clients with product development, technology consulting, and technology upgrade projects atop the JVM. The August Group's technology preferences reflect the generalist sensibilities of its founder, and its development practices are always lightweight, self-improving, and humanizing by design.
Tim is a speaker internationally and on the No Fluff Just Stuff tour in the United States, and is co-president of the Denver Open Source User Group in the Denver area, co-author of the DZone Clojure RefCard, co-presenter of the best-selling O'Reilly Git Master Class, co-author of Building and Testing with Gradle, and a member of the O'Reilly Expert Network.
He lives in Littleton, CO with the wife of his youth and their three children.
Presentations
Complexity Theory and Software Development
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.
Getting Started with Grails
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
Grails in Front, Cassandra In Back
Cassandra is a scalable, highly available, column-oriented data store in use at Facebook, Netflix, Twitter, Reddit, Rackspace, and a growing list of other deployments. It offers a compelling combination of a rich data model, a robust deployment track record, and a sound architecture—and it isn't just for web-scale operations. It might be a good fit for your Grails app!
In this session, we'll learn the basics of Cassandra, then look at how to use it for storing data in a simple Grails application. We'll work through a simple data modeling exercise and look at the code required for interfacing with this leading NoSQL solution.
Lightweight Web Apps with Ratpack
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!
Ratpack Workshop (bring a laptop)
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.
Grails Workshop (bring a laptop)
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.
Books
by Tim Berglund and Matthew McCullough
-
Build and test software written in Java and many other languages with Gradle, the open source project automation tool that’s getting a lot of attention. This concise introduction provides numerous code examples to help you explore Gradle, both as a build tool and as a complete solution for automating the compilation, test, and release process of simple and enterprise-level applications.
Discover how Gradle improves on the best ideas of Ant, Maven, and other build tools, with standards for developers who want them and lots of flexibility for those who prefer less structure.
- Use Gradle with Groovy, Clojure, Scala, and languages beyond the JVM, such as Flex and C
- Get started building a simple Java program using Gradle's command line tooling and a small build script
- Learn how to configure and construct tasks, Gradle's fundamental unit of build activity
- Take advantage of Gradle's integration with Ant
- Use Gradle to integrate with or transition from Maven, and to build software more cleanly
- Perform application unit and integration tests using JUnit, TestNG, Spock, and Geb
-
Build and test software written in Java and many other languages with Gradle, the open source project automation tool that’s getting a lot of attention. This concise introduction provides numerous code examples to help you explore Gradle, both as a build tool and as a complete solution for automating the compilation, test, and release process of simple and enterprise-level applications.
Discover how Gradle improves on the best ideas of Ant, Maven, and other build tools, with standards for developers who want them and lots of flexibility for those who prefer less structure.
- Use Gradle with Groovy, Clojure, Scala, and languages beyond the JVM, such as Flex and C
- Get started building a simple Java program using Gradle's command line tooling and a small build script
- Learn how to configure and construct tasks, Gradle's fundamental unit of build activity
- Take advantage of Gradle's integration with Ant
- Use Gradle to integrate with or transition from Maven, and to build software more cleanly
- Perform application unit and integration tests using JUnit, TestNG, Spock, and Geb
