Speakers
- Dan Allen
- Aaron Bedra
- Tim Berglund
- Rohit Bhardwaj
- David Bock
- Stevie Borne
- Jeff Brown
- James Carr
- Scott Davis
- Jeremy Deane
- Keith Donald
- Michael Easter
- Robert Fischer
- Neal Ford
- Brian Gilstrap
- Andrew Glover
- Brian Goetz
- Stuart Halloway
- David Hussman
- Mark Johnson
- Dave Klein
- Scott Leberknight
- Tiffany Lentz
- Howard Lewis Ship
- Chris Maki
- Matthew McCullough
- Alex Miller
- Ted Neward
- Michael Nygard
- Pratik Patel
- Mark Richards
- Brian Sam-Bodden
- Srivaths Sankaran
- Nathaniel Schutta
- Aleksandar Seovic
- Ken Sipe
- Brian Sletten
- Matt Stine
- Venkat Subramaniam
- Burr Sutter
- Vladimir Vivien
- Mark Volkmann
- Craig Walls
- Richard Worth
Glenn Vanderburg
Chief Scientist, Relevance Inc.
Blog
MagLev
Posted
Chad Fowler nails it with his summary of MagLev. Like Chad, I think MagLev’s initial performance numbers will hold up. It’s possible that as it matures it will get slower, but it could get a lot slower than it is now and st more »Growing Great Programmers
Posted
Here’s another highlight from RubyConf 2007: watching Jamis Buck and Michael Koziarski give a terrific keynote based on their joint blog, The Rails Way. I leaned over to Alan Francis and mentioned how encouraging it is to see young programm more »Highlights from RailsConf 2007
Posted
Chad’s opening call to change the way our community is perceived from the outside. Preach on, brother! Hot on the heels of that, Chad strumming on his ukelele while Rich Kilmer gamely tried to deadpan through his introduction of David He more »"I don't think this is an act that a healthy company would commit."
Posted
Douglas Crockford says, "I don't think this is an act that a healthy company would commit.". He was referring to Media Rights Technologies, but he could just as easily have been referring to Microsoft more »Try It
Posted
Two of my best friends in the Ruby community have suddenly gone all nyah nyah on us, and it’s time for a bit of reality. Neal Ford says static typing is communist bureaucracy, and Stuart Halloway (presumably trying to tone things down a bit) say more »Keeping Track of Unimplemented Features
Posted
I started a new Rails project last week. The customer had done an unusually good job of working out the site look-and-feel ahead of time, so my first day on the project I grabbed the HTML mockup of the first page we were going to implem more »Textmate Footnotes
Posted
For a while now I've been using Duane Johnson's TextMate Footnotes plugin with my Rails development. It's been the biggest boost to my productivity since I started using Rails. I kind of assumed that most Rails developers were using i more »Know for yourself ...
Posted
Greg Vaughn thinks there are only two people who read his blog. I’m pretty darn sure at least six read mine, so maybe I can quadruple Greg’s readership today. I’m always interested in the things that other fields can teach us abou more »Presentations
JavaScript Exposed: There's a Real Programming Language in There! (Part 1)
With the sudden importance of Ajax, it's time to take JavaScript seriously. That means learning it the right way: looking at the fundamentals of the language and surveying its strengths and weaknesses, instead of just copying other people's poorly written more »JavaScript Exposed: There's a Real Programming Language in There! (Part 2)
Building on part 1, this talk dives deep into JavaScript's object model. We'll see how it differs from more mainstream object-oriented languages, and why. We'll explore how to hide some of those differences, as well as the reasons you might not want to. more »Metaprogramming: The Magic of Dynamic Languages
Dynamic programming languages are on the rise. There are several possible explanations, but the biggest one is probably their support for metaprogramming: the ability to extend the language itself with domain-specific capabilities that keep your system s more »Java Performance Myths
Performance myths about the Java platform abound, from the general "Java is slow", to the more specific "reflection is slow", "allocation is slow", "synchronization is slow", "garbage collection is slow", etc. Many of these myths have their root in fact ( more »Ajax Design and Architecture
Ajax applications have unique design and architectural challenges and opportunities. This presentation will show you how to take advantage of the Ajax's strengths, and work around its quirks. more »Core Internet Protocols
Most of the time we don't have to think about how the network works; it's hidden from us by higher-level abstractions. Sometimes though, it helps to understand what's happening on the wire. This talk will provide an overview of some of the core protocol more »The Beauty of Ruby
Many people love Ruby at first sight, and some never learn to like it at all. But the most common reaction is a middle ground: at first glance it seems like nothing special, but after using it for a while, subtle strengths start to become apparent and th more »Everything Old Is New Again
The early years of computers -- the '50s and '60s -- were characterized by furious exploration of a huge variety of different ideas. Since then many of the hot topics of those days have moved to the fringe, largely ignored by the mainstream of software d more »Introduction to Functional Programming Using Haskell
Functional programming languages have been around for years, but have mostly been used by academics. Several factors are causing them to be taken more seriously by average software developers, and there's a strong chance that functional programming will more »With the sudden importance of Ajax, it's time to take JavaScript seriously. That means learning it the right way: looking at the fundamentals of the language and surveying its strengths and weaknesses, instead of just copying other people's poorly written examples.
JavaScript got a bum rap. It's almost universally derided among serious programmers for being a toy language, or for its strange characteristics, or bugs, or slowness, or because it's only good for adding useless window dressing to web pages.
But JavaScript is actually a very nice little language which is popping up everywhere these days (not just in Ajax apps). Sure, JavaScript is quirky, but its problems are mostly due to history, association, and misunderstanding. Especially misunderstanding. Let's face it: most developers learned JavaScript by looking at examples in web pages they found online, and few of those examples are paragons of JavaScript style. Other developers learned JavaScript from books, but the typical JavaScript book ignores the fundamentals of the language, instead focusing on examples and the fastest ways to do fancy web page tricks.
In this talk, we'll go back to the basics that most JavaScript resources omit. We'll talk about JavaScript as a language, learning its fundamental concepts and the simple rules that underlie the sometimes bewildering behavior.
Building on part 1, this talk dives deep into JavaScript's object model. We'll see how it differs from more mainstream object-oriented languages, and why. We'll explore how to hide some of those differences, as well as the reasons you might not want to. Additionally, we'll cover useful tools for JavaScript testing, debugging, and profiling.
Ajax is not the focus of this talk, but a strong foundation in JavaScript is essential for working with Ajax.
Dynamic programming languages are on the rise. There are several possible explanations, but the biggest one is probably their support for metaprogramming: the ability to extend the language itself with domain-specific capabilities that keep your system simple. This talk examines the whys and hows of metaprogramming using Ruby and JavaScript.
Dynamic programming languages are on the rise. There are several possible explanations, but the biggest one is probably their support for metaprogramming: the ability to extend the language itself with domain-specific capabilities that keep your system simple. This talk examines the whys and hows of metaprogramming using Ruby and JavaScript. We'll see how Rails and some of the Ajax libraries work their magic, and learn how to identify and implement the domain-specific languages your system needs.
Performance myths about the Java platform abound, from the general "Java is slow", to the more specific "reflection is slow", "allocation is slow", "synchronization is slow", "garbage collection is slow", etc. Many of these myths have their root in fact (in JDK 1.0, everything was slow); today, not only are many of these statements not true, but Java performance has surpassed that of C in many areas, such as memory management.
In this class, we'll look at some common Java performance myths, identify where they came from, and explore the platform changes that have rendered them no longer true. Many common performance hacks don't actually help, and some can seriously hurt performance. The result is that clean code that follows common usage patterns generally shows far better behavior on modern JVMs than code laden with tweaks designed to "help" the JIT or garbage collector. More often than not, this well-intentioned assistance has the unfortunate effect of undermining many common JIT optimizations, resulting in slower -- not faster -- code.
Ajax applications have unique design and architectural challenges and opportunities. This presentation will show you how to take advantage of the Ajax's strengths, and work around its quirks.
We'll start with an overview of Ajax, and then dive right into an extended example where we add Ajax to an existing web application. Along the way we'll cover several tools that we use to aid in Ajax development: The JavaScript Shell, Firebug, and the Web Developer's Toolbar. We'll also look at two popular JavaScript Ajax libraries: Prototype and Scriptaculous.
With the example application under our belts, we'll move to a discussion of Ajax architectural questions, including:
How do I select an Ajax library? What format data should my Ajax calls use: XML, JSON, HTML, or other? How do I handle the back button and deep linking in Ajax? Prior exposure to Ajax and JavaScript is useful but not required.
Most of the time we don't have to think about how the network works; it's hidden from us by higher-level abstractions. Sometimes though, it helps to understand what's happening on the wire. This talk will provide an overview of some of the core protocols of the Internet, from the network layer on up.
We'll cover IP, TCP and UDP, SMTP, and HTTP, with glimpses at other protocols as well.
Many people love Ruby at first sight, and some never learn to like it at all. But the most common reaction is a middle ground: at first glance it seems like nothing special, but after using it for a while, subtle strengths start to become apparent and the language grows on you. In this talk, I'll attempt to accelerate that process a little bit.
The point of the talk is not to belittle other languages or to claim that Ruby is the best possible language. Instead, I will demonstrate some of the subtle beauty that experienced Rubyists know and love.
The early years of computers -- the '50s and '60s -- were characterized by furious exploration of a huge variety of different ideas. Since then many of the hot topics of those days have moved to the fringe, largely ignored by the mainstream of software development. But some of them are being rediscovered, and a lot of what we think of as "new developments" are really just some old ideas returning to center stage.
This talk will trace the roots of some contemporary software trends back to their origins before most of us were born.
Functional programming languages have been around for years, but have mostly been used by academics. Several factors are causing them to be taken more seriously by average software developers, and there's a strong chance that functional programming will continue to become more and more important. Haskell is one of the foremost functional languages.
This talk will be a whirlwind tour of Haskell and what it's like to program functionally. We'll see real, useful programs (not just academic exercises) and learn about the strengths and weaknesses of functional programming languages.