Using powerful languages makes the solutions in the GoF book look hopelessly complicated. This session shows how to solve the same problems concisely, elegantly, and with far fewer lines of code using the facilities of dynamic languages.
In a blog post called "Multi-core hysteria and the thread confusion," DHH wrote that the advancement of "multi-core technology has caused quite a few folks to pontificate that the sky is falling for Rails because we're not big on using threads." He asserts that "It isn't." In this talk I will detail specific concerns community members have brought up and evaluate them, MythBusters-style.
Web applications have changed the world. Their amazingly powerful and can be slick as snot. The technologies behind them however, leave much to be desired. Come commiserate about aspects of web apps that are painful and talk about why. Then learn how the pain can go away with an introduction to using LimeLight with Rails: the open source client side tool alluded to at RubyConf 2007.
This talk is all about classic hacking: whipping up some code just because you can, because you "need" it, because you want to explore something new and shiny. We're going to talk about some specific hacks, talk about how to hack, and talk about why your boss, clients, and even your significant other should love it when you hack.
This talk will cover several of the more advanced Active Record features by presenting code samples and walking through a best practice refactoring of that code, using the tools given to us by Active Record ('the Rails way'). Some of the topics that these refactoring examples will touch on include Callbacks and Observers, Complex data models, Validations, and other tips, tricks, and gotchas.
Designing RESTful systems in Rails carries many benefits. It is not a problem-free approach, however; there are accessibility issues with the standard conventions, and some functions are more difficult to map to resources than others. In this session, we'll look at solutions for these (and other) problems that arise when you take REST beyond the standard examples.
Many have heard the terms agile development, self-managing teams, and many others tossed out but never explained. This session will go into the details involved in agile development and scrum, and inform you on how agile can be implemented in a company to address the many challenges they face.
Rails makes synchronous, request-driven processes a breeze. But what happens when you need to do something a little more complex or time-consuming? Enter asynchronous processing. We will investigate several ways to bring asynchronous processing to Rails, including cron, BackgrounDRb, AP4R, daemons, and Amazon SQS.
Fuzed is a Rails server stack written in Erlang that can replace standard mongrel/reverse proxy architectures. It focuses on reliability and ease of deployment in distributed environments.
The session is a nuts and bolts look at what is required to build a model that is composed of several other models and functions with Active Record. This "virtual" model can then be used like a regular model where the user wants to interact with the virtual view.
So you want to build a Rails app quickly? Competitors in the Rails Rumble had 48 hours to design, develop, and deploy a complete application. We’ll take you through the development processes of the winning four-man Tasty Planner team, and compare it with those of the one-man Your Pet Records team. We’ll discuss techniques, short-cuts, helpers, and Rails plugins that helped speed development.
This is a detailed step-by-step tutorial on quickly setting up a Continuous Integration (CI) environment for automated Rails testing with Test::Unit, JsUnit, and Selenium. All software and instructions are downloadable, including instructions for running everything in a VmWare VM. With these materials, anyone can set up a their own CI environment, regardless of their skill or access to hardware.
Complex, multi-column, multi-table searches are beyond ActiveRecord's capability. This talk will explore strategies for building and maintaining complex search structures in Rails.
Got a Rails app that needs even more speed? Adam Wiggins of Heroku will show you how to write a custom Nginx module to bring blinding speed to critical code paths (and do HTTP tricks that can't be done with Rails and Mongrel alone), using examples from Heroku's own authentication module ngx_heroku_gate. Dust off your C compiler and prepare to push the limits of nginx, Rails, and HTTP.
Deploy your own application (or watch Guy deploy one) into a FREE Morph AppSpace. Guy will provide tips on multi-tenancy architecture and Rails features. Learn about using DB MIGRATE to initialize your database and how to use Capistrano to deploy from differently supported source code control systems.
Do you often wish you knew how to make your web apps look better? This three-hour workshop will show you how to pick colors, select fonts, draw logos, and mock-up pages using the same techniques designers use. You'll then learn how to take that design and build your Rails layout.
By going over a number of testing technologies, methodologies, and code, this talk will:
* present a set of testing related situations and experience in solving a number of issues
* raise the audiences' awareness over effective ways of communicating through tests
* emphasize skills and courage to solve testing issues
Many of the people working with Rails are independent developers,
doing freelance work or running small development shops. This makes
sense - Rails provides a great framework for an indy developer, making
it easy to work with with designers and other developers.
Have you ever wanted to know why a part of your application is slow? How about how long that query takes? Wouldn't it be nice if you could get this type of information for ruby, rails, and the database server in one place? You can now with DTrace on OSX 10.5.
We'll show you how to best use this tool-chain to debug, profile, and gather more information about your application.
A brief look at how to create (and scale) a Facebook application with Rails. We'll start by creating a simple Facebook application using the facebooker rails plugin. From there, we'll see some tips to scale it up to handle millions of users.
Moderate to massively parallelized tests leveraging multi-core processors. ActiveRecord tests without a database. Yaml-less test data. With leveraging several open-source tools including DeepTest, Selenium Grid, and UnitRecord, in conjunction with techniques such as Model Factory, this session will show how to move beyond the plain vanilla Rails strategy to achieve optimal application testing.
What happens when you combine the intensity and furor of gamers with the leverage of massive social networks? One slow rails app.
This tutorial will walk through the tools used, the tools built, and the code written to bring Warbook from 1 to 1 million users and sustains it at over 16 million daily pageviews.
The Wellcome Trust Sanger Institute played a central role in sequencing the human genome. Learn how we're using Ruby and Rails to quickly build and deploy the next generation of genomic sequencing platforms: high throughput, scalable, multi-petabyte. Twitter have it easy.
What are the day to day issues with Rails hosting. How can they be solved, and what are the best practise methods of avoiding them. Engine Yard have extensive experience with high volume Rails applications and would like to talk about what we've learned and what our customers have learnt.
Learn how to write customer-facing executable user stories and scenarios with RSpec's new Story Runner.
You think Sun is the Java company. Enterprise Edition. Steak and strippers. But Java's only part of the story, and the story is changing every day. In ten minutes, you'll get a whirlwind tour of a different Sun, one that gives hardware breaks to startups, open sources cornerstone software like Solaris, OpenJDK, ZFS and DTrace, and actively funds Ruby projects on and off the JVM.
Ruby is the revenge of the Smalltalkers. Not since Smalltalk has a language had such powerful meta-programming facilities. While this may seem like a minor feature, it turns out that surgical meta-programming allows solutions to problems that are clearer, more concise, more maintainable, and take orders of magnitudes fewer lines of code.
Microapps are a great way to test ideas, blow off steam and vet your crazy ideas. No longer is the "one off" app the sole domain of PHP. Camping, sinatra, merb and friends let you create the next great microapp in hours and days instead of weeks and months. In this session, we'll examine a few live microapps and even code up the skeleton of one live.
Phusion Passenger (a.k.a. mod_rails) enables people to deploy their Ruby on Rails applications in an upload-and-go manner, very reminiscent of the PHP way of deploying, while retaining stability/robustness and performance.
The best way to learn is by falling down. Unfortunately, some things you can only learn by falling down. Based on real world failure, find which parts of Rails sound good at first, but can get tiring once you use them a lot. Discover how to better interact with customers and teammates. Find out how to learn more, faster. All this without actually embarrassing yourself.
Learn from the experience in deploying a dozen different complex web services on Amazon EC2 and how different companies leverage the power and flexibility of EC2, including scaling to thousands of servers to survive a facebook onslaught. This talk will discuss recently introduced EC2 features, how to use them, and how to put everything together into a scalable architecture.
A Panel discussion with Gregg Pollack (Rails Envy Podcast), Ryan Bates
(Rails Casts), Chistopher Haupt (Learning Rails), Michael Slater
(Learning Rails), and Geoffrey Grosenbach (Peepcode & Ruby on Rails
JRuby on Rails brings the agility of Rails to Java technology-based servers and applications, from the simplest web applications to the largest enterprise deployments. In this session, the developers will learn why GlassFish provides an easy-to-use, robust development and deployment platform for JRuby-on-Rails applications than the conventional Rails model.
Refactoring is an essential part of a developer's life. It can be difficult to know when or what to refactor in a Rails application. This talk will present you with tools and techniques to help you tackle the worst offenders in your code base to keep your project moving along through development.
This is a talk about what it takes to *really* scale Ruby applications. We will not only examine all the aspects of hardware and web server configurations, we will also look at scaling the ruby interpreter itself. Including performance quirks of MRI and how Rubinius is set to fix a lot of these problems.
YELLOWPAGES.COM is the 33rd-largest website in the U.S., handling
millions of searches per day. In four months, four developers turned
125,000 lines of Java into 14,000 lines of Ruby and successfully
launched a redesigned site. This session discusses the entire process,
starting with project management and ending with the technical details
of breakneck scaling.
When Rails was first released, there was just one framework for testing applications and things were simple, if not always ideal. Now there are enough frameworks that choosing which one to use for your Rails application can be a difficult decision. This presentation provides a survey of the major Rails testing frameworks and compares their strengths and weaknesses in various areas.
JRuby is becoming an increasingly popular deployment platform for Ruby on Rails applications. We'll discuss how deployment with JRuby can make your deployment and management pains go away. Topics will range from installation, gems and library compatibility, packaging, configuration, and post-deployment tuning and troubleshooting.
Many developers have the skills to implement web applications, but often lack the business skills to make them profitable. Hear from five developers who have transitioned from full-time consulting to building financially profitable Rails-based web applications.
Git is a fast, efficient and distributed source code management system. This talk will demonstrate how Git works, how to use it to manage a Rails project and demonstrate Capistrano's new Git SCM module.
As veterans of maybe the largest enterprisey Rails project ever written, the panelists have written, tested, re-tested, and rewritten more legacy and new-legacy code than your mom has baked nasty green-pepper-with-ketchup-and-saltines meatloaf. Now tackling Ruby and Rails projects as a consulting team, they share their "insights" on software and politics with the old guard, startups, and now you.