Sessions at Lone Star Ruby Conference V about Ruby

Your current filters are…

Thursday 11th August 2011

Friday 12th August 2011

  • Exceptional Ruby

    by Avdi Grimm

    You know how to raise and rescue exceptions. But do you know how they work, and how how to structure a robust error handling strategy for your app? Starting out with an in-depth walk-through of Ruby's Ruby's rich failure handling mechanisms -- including some features you may not have known about -- we'll move on to present strategies for implementing a cohesive error-handling policy for your application, based on real-world experience.

    At 11:15am to 12:00pm, Friday 12th August

  • Ten Things I Hate About Ruby

    by Hal Fulton

    We all love Ruby. But let's face it: It isn't perfect. We each may have a personal list of complaints. Yours will vary; this is mine. These are the things about Ruby semantics and the Ruby core that I find counter-intuitive, difficult to remember, incomplete, improperly designed, or not quite adequate. There might even be one or two notes here on syntax, the most fundamental level of any language. And "hate" may be too strong a word; but once in a while, we have to ask what is lacking in our favorite tool, so that someday when replace it, we will have something better (whether that thing is called "Ruby 2.0" or something else entirely).

    At 1:00pm to 1:45pm, Friday 12th August

  • Consuming the Twitter Streaming API with Ruby and MongoDB

    by Jeff Linwood

    Want to build your next application off of live Twitter updates? Twitter provides a streaming API that you can filter by username, keyword, or geo-location. Using a couple of great Ruby gems, we can store tweets from the streaming API into MongoDB, a NoSQL store that's perfect for analysis.

    I'll go over the basics of the Twitter API, MongoDB, the mongo and tweetstream ruby gems, and how to bring it all together into a sample application.

    At 1:45pm to 2:30pm, Friday 12th August

    Coverage slide deck

  • Practical Metaprogramming: "Modeling Thought"

    by Steven G. Harms

    ... Or, Lessons Learned While Using Ruby's MP System to Model a 2,500 Year-Old, Dead Language

    During LSRC III's Reject Conf, I began a project to model the linguistic behavior of verbs in Classical Latin. Owing to the irregularity of human communication, modeling the provision of unambiguous answers (return values) to ambiguously asked things (flexible / incomplete method calls) might have required hundreds, if not thousands, of method definitions or static values entered in a database.

    But what if heuristics could be given to a Ruby class such that it "thought" as language learners are taught to think? What if it could be taught to be flexible in respecting the ambiguous calls given and to still give precise, correct answers back - as human language learners are capable of doing? By adopting this design paradigm, code could become leaner and more reflective of human cognitive process.

    Thankfully for Rubyists, this is not a dream, this is reality. Our programs can operate more intelligently, more heuristically, and more insightfully. We can save ourselves days of development time by integrating this next tier of metaprogramming patterns I propose to demonstrate. While I will demonstrate these patterns by modeling linguistics based on the LatinVerb library (https://github.com/sgharms/Latin...), these techniques have wider application across problem domains.

    At 1:45pm to 2:30pm, Friday 12th August

    Coverage slide deck

  • Accelerated native mobile app development with the Ti gem

    by Wynn Netherland ⚡

    Titanium mobile is fast becoming the native platform of choice for Rubyists. This talk will show you how to put your Ruby skills to use to write native apps for iOS and Android faster than you ever thought possible including:

    • The Ti gem which offers Rails-like generators for views, models, and other project items
    • CoffeeScript to write JavaScript using idioms familiar to Rubyists
    • Compass and Sass to write JavaScript stylesheets
    • Rake to compile, build, and deploy your apps

    At 2:30pm to 3:15pm, Friday 12th August

    Coverage slide deck

  • Procrastinate your code: Do it later.

    by Zach Moazeni

    You can't do it all. Sometimes breaking the request/response cycle is just too constraining and you need to bust out of it. Enter asynchronous processing.

    Delayed Job and Resque, two takes at solving this problem, are popular tools. We'll explore their differences, demonstrate how to get up and running in minutes, and show you how to find the best fit for your project.

    At 2:30pm to 3:15pm, Friday 12th August

  • The world runs on bad software

    by Brandon Keepers

    The world is full of poorly structured, overly verbose, untested code. But, a lot of people are doing amazing things and making insane amounts of money from bad software. As someone who might call himself a “software architect” or “craftsman”, this is difficult reality for me to accept. This talk explores the balance between pragmatism and perfection.

    Ruby, being as expressive and versatile as it is, makes it easy for newbies to write alien code that looks more like Java than anything resembling our beloved language, while those versed in "The Ruby Way" spend their days and nights obsessing over how to refactor ten lines of working code into three.

    There is a cost to writing good software. It takes time to write automated tests, refactor code, and do things right. You may miss opportunities to get your software in front of real people, get essential feedback, or even launch at all.

    I have seen and often written both abysmal software that makes me want to cry and glorious code that would make any mother proud; both were perfectly adequate for the task at hand.

    Bad software that ships is better than good software that nobody uses. Learn how to strike a balance between pragmatism and perfection.

    At 3:30pm to 4:15pm, Friday 12th August

    Coverage slide deck

  • More DSL, Less Pain

    by Evan Light

    One much loved feature of Ruby is the ease with which the object model allows for internal DSLs. However, "metaprogramming" code, in Ruby, can be hard on the eyes which written in large quantities. "Lispy", a gem by Ryan Allen, was a first step toward a generic decoupling of internal DSLs from their implementation. I forked it, took it a ways further, and used it in a significant refactoring of a gem. During this presentation, I'll demonstrate how the LISPish notion that code is data can go a long way toward easing the burden of implementing internal DSLs

    At 4:15pm to 5:00pm, Friday 12th August

    Coverage slide deck

Saturday 13th August 2011

  • The Ruby Racer: Under the Hood

    by Charles Lowell

    Have you ever had to implement the same validation logic twice: once in JavaScript for the browser and once in Ruby for the server? Has there ever been a JavaScript library like handlebars.js that you'd love to use server side, but can't because well... it's in JavaScript and not Ruby? Or perhaps a time or two you've been tempted to eval() some anonymous Ruby code, but you didn't dare because it's an unspeakably dangerous thing to do?

    The solutions to these and many other problems are suddenly and elegantly within your grasp when you've got the power of a JavaScript interpreter right there with you in your ruby process.

    Sound crazy? difficult? It's easier than you might think. This talk will focus on The Ruby Racer: a gem that brings the superb V8 interpteter to Ruby. We'll see how to call JavaScript functions directly from Ruby; how to call Ruby methods directly from JavaScript; how to extend Ruby classes with JavaScript; how to extend your JavaScript objects with Ruby, and a slew of other ways of managing their interaction that will bend your mind.

    At 9:30am to 10:15am, Saturday 13th August

    Coverage slide deck

  • Google Go for Ruby Hackers

    by Eleanor McHugh

    Go is a statically-compiled systems language geared to developing scalable and type-safe applications with the light touch of a dynamic language.

    In this session we'll explore Go from a Rubyists perspective, examining the CSP-based concurrency model which has gained it wide-spread press coverage, it's inference-based approach to dynamic typing and the inheritance-free object model this supports. Where possible I'll tie these concepts back to familiar Ruby idioms.

    Along the way we'll meet gotest (Go's testing and benchmarking framework), CGO (for linking to C libraries), goinstall (the remote package installer) and Go's powerful reflection and type manipulation features.

    By the end of the session you'll be comfortable reading Go source code, have a basic feel for developing with the language and the necessary background to get started writing your own concurrent Go programs.

    At 10:30am to 11:15am, Saturday 13th August

    Coverage slide deck

  • State of the Art Telephony with Ruby

    by Ben Klang

    The past 10 years has seen a revolution in the way we make phone calls and even the way we think about a telephone. Ruby is an ideal language to create power tools for building telephony applications. In this talk we will demonstrate how Ruby is the state of the art when it comes to interacting with the telephone network. Using the open source Adhearsion framework, we will demonstrate how you can easily integrate with existing Ruby applications or migrate legacy systems. We will cover how to get started immediately using cloud-based services, as well as how to build, deploy and manage your applications in-house. Network permitting, we will finish with a live demo designed to inspire ideas for ways you can integrate telephony into your application.

    At 11:15am to 12:00pm, Saturday 13th August

  • The Return of Shoes

    by Steve Klabnik

    Everyone talks about writing web applications with Ruby, but it's great for applications of any kind. Shoes is a project that was started by _why the lucky stiff, and when he left, a plucky community of developers kept it alive.

    If you've never worked with Shoes, it's the only Ruby GUI toolkit that is truly Ruby, and not just a binding to another project, like QT or tk. It uses Ruby-only features like blocks heavily, and works on all three platforms.

    In this talk, Steve will do a small introduction to developing desktop apps with Shoes, talk about the challenges of maintaining a large polyglot project with an absent creator, and where Shoes is going in the future, as well as how you can get involved.

    At 1:00pm to 1:45pm, Saturday 13th August

  • Chronologic: you put your activity feeds in it

    by Adam Keys

    The need to maintain social activity feeds is an increasingly useful thing in a variety of software. Whether its a project management app or a social site, many kinds of software can make use of a list of events that have happened in the system, filtered for each user and listed in reverse chronological order. However, this sort of data presents many storage and privacy challenges.

    Gowalla has built Chronologic to meet all these needs. Chronologic is an application built for dealing with events, timelines, and pushing those events to the right subscribers. It is a general service for dealing with activity feeds. On top of that, it implements privacy, a flexible follow model, and the ability to fetch incremental updates to a feed.

    Chronologic is built with Ruby, Sinatra, and Cassandra. We'll show how this trio played nicely together and how it could be improved. Most importantly, we'll show how to get started with Chronologic, how to adapt it to your own application, and how to deploy it in your datacenter.

    At 1:45pm to 2:30pm, Saturday 13th August

    Coverage slide deck

  • Location Matters! How to make your Ruby spatial.

    by Pete Jackson

    This session is intended for intermediate Rails developers who would like to start building location based applications, but may not know the full breadth of the toolkits available.

    We will start by examining the different types of location-based applications. Then we will look at the anatomy of a typical location-based application, and the elements of the spatial tool stack that apply to each geospatial element in the application. The relative strengths and weaknesses of RGeo, GeoRuby, and spatial_adapter will be examined in depth. We will then discuss in moderate detail the capabilities the many visualization libraries and DBMS systems that round out the stack, with a focus on helping the attendee understand when to choose which tool.

    Finally, we will explore some examples of geospatial applications that are 1) inspiring and 2) use different elements of the stack as discussed during the session.

    At 2:45pm to 3:30pm, Saturday 13th August

  • Polyglot Paralellism: A Case Study in Using Erlang and Ruby at Rackspace

    by Phil Toland

    Two years ago Rackspace had a problem: how do we backup 20K network devices, in 8 datacenters, across 3 continents, with less than a 1% failure rate -- every single day? Many solutions were tried and found wanting: a pure Perl solution, a vendor solution and then one in Ruby, none worked well enough. They not fast enough or they were not reliable enough, or they were not transparent enough when things went wrong.

    Now we all love Ruby but good Rubyists know that it is not always the best tool for the job. After re-examining the problem we decided to rewrite the application in a mixture of Erlang and Ruby. By exploiting the strengths of both -- Erlang's astonishing support for parallelism and Ruby's strengths in web development -- the problem was solved.

    In this talk we'll get down and dirty with the details: the problems we faced and how we solved them. We'll cover the application architecture, how Ruby and Erlang work together, and the Erlang approach to asynchronous operations (hint: it does not involve callbacks). So come on by and find out how you can get these two great languages to work together.

    At 3:30pm to 4:15pm, Saturday 13th August

    Coverage slide deck