- Ryan Smith - Fewer Constraints More Concurrency
- Sandi Metz - Less: The Path to Better Design
- Paul Dix - Indexing Thousands of Writes Per Second With Redis
- Casey Rosenthal - HysteriaEngine: Ruby Does Violence in the Name of Science
- Jeremy Ashkenas - CoffeeScript for the Well-Rounded Rubyist
- John Crepezzi & Mat Brown - Using Your Database
- Evan Phoenix - Build it and they will come (Rubinius Edition)
Traditional data structures like stacks and queues are strict - perhaps too strict. In this talk I will showcase some classical data structures and then provide alternative constraints that will allow our algorithms to achieve a greater level of concurrency. Examples will include a mix of Ruby and Postgres. Ryan Smith's educational background consists of Computer Science and Mathematics. He has contributed to projects like Queue Classic, ActiveMerchant, Gemcutter and others. These days he is crafting code on the API Team at Heroku
The concrete principles of object-oriented design are useful but are built upon powerful concepts that the principles tend to obscure. When design principles become goals in and of themselves, object-oriented design gets a bad name and applications suffer. This talk strips away the well-known design principles and exposes the hidden, underlying goals of design. It reveals programming techniques that allow you to write less code while creating beautiful, flexible applications. These techniques all involve less. Doing less, debugging less, testing less and knowing less, all in service of achieving more. Sandi Metz works for Duke University in Durham, N.C., is a member of the West End Ruby group and is one of the many DevChix. Her lengthy and varied career has led her to Ruby, in which she has happily spent the last 6+ years crafting applications both large and small. When not thinking, talking or writing about object-oriented design she can be found building bikes in her garage. Her commitment to OOD is paired with a firm belief that one can never have too many bikes.
The financial market data application that we're building sustains an
average write load of around 10,000 writes per second. Scaling a system to
handle this many writes while responding quickly to user requests is quite
challenging. Our data store is able to keep the data, but the indexes
required to respond to user requests would completely overload it. To
solve the problem we moved to storing indexes in Redis. Its functionality
and high speed made dealing with this write load manageable.
This talk will cover what types of operations and data structures Redis provides that enable it to ac as an indexing server. It's a case study of using Redis as more than just a key value store or the backend for Resque. I'll cover the design issues with keeping indexes in Redis and making sure that they get updated if there is an outage. Cache warming, data structures, and advanced Redis use are all part of the talk.
I will present the inner workings of my Ruby algorithm, called HysteriaEngine, which uses personality profiles to generate human-like behavior for an agent, in this case a bot that plays in UnrealTournament2004. I will cover the stack needed to run the bot, using Ruby on top of a little Java, but primarily I will deconstruct the algorithm that generates the commands that drive the bot, code structure decisions in designing the algorithm, and the complexity involved in generating human-like behavior. I will also touch on some of the obstacles of TDD-ing a stochastic model that often has purposefully unpredictable results. Casey Rosenthal is Chief Software Engineer for Port Forty Nine, currently working for NASA, Caltech, and JPL to engineer systems for storing and disseminating the image archives of space telescopes such as Hubble, Spitzer, Chandra, etc. He is writing a chapter on using personality profiles in artificially intelligent bots for an upcoming book titled “Believable Bots,” to be published in late 2011
Being eager to quickly develop our applications and libraries, we often skip over technologies and techniques that have existed for years. Particularly where relational databases are concerned, Rails encourages us to do as much as possible in Ruby, even when our database has the same functionality built-in. This talk will take a step back and see what existing technologies we've reinvented, and compare them with the performance of tried-and-true approaches. Mat Brown has been programming in Ruby and Rails for three years, and is the creator of several open-source libraries, most notably Sunspot. He thinks Ruby's patternmatching constructs are underappreciated. Mat currently works as the lead engineer for Clique. John Crepezzi is a Rails developer at Patch Media in New York City. He created several popular gems, such as IceCube, TrackHistory, and EasyTranslate. He loves traveling and talking about how much he loves to code/solve problems
After years of work, Rubinius is hitting its stride. In his talk, Evan will talk about how you can decide when Rubinius is a good fit for you and what you can expect in the rest of 2011 and beyond. Evan Phoenix works for Engine Yard where he is a lead Rubinius developer. The Los Angeles weather allows him to take long walks on the beach whenever he would like