http://www.web2expo.com/pub/w/51/presentations.html

My favorites from the current list are:
Building Community-focused Apps with Rails
Scaling a Rails Application from the Bottom Up

My favorite talks were the ones that included code. That is probably because I am a programmer, but somehow code makes the talk real. I went to a few talks that were explanations of processes. Those are OK, but they include a lot of common sense stuff that you will already know if you have been in the field for a few years. The very best talks were ones that included code and showed best practices. I don't want to be a Rails core team fan boy, but I love to hear Jamis Buck talk. He and Koz did a great job showing off the 'Rails Way'. DHH's talk was great. He is a nice guy with great ideas and he is a good presenter. He deserves the credit he gets.

The food at the conference sucked. Breakfast needs to be better. Lunch needs to be better.

Rails Conf felt a little to corporate for a rebellious framework like Rails. Something more like IIW would fit this community perfectly. Somehow O'Reilly manages to make their conferences a little to rock starish. However, O'Reilly support also shows the support and power behind Rails which is cool.

I wouldn't attend the tutorials before the conference. They are pretty much an introduction to whatever topic they introduce.

Overall the conference was enjoyable. I would probably go again. I look forward to more local Rails events. I think the community is growing and we should start seeing more regional conferences in the 50-150 person range.

See you next year.

Look at the code in his slides.

Luke is a tool that lets you view your lucene index.

This is a pretty sweet tool for adding search to your site. I plan on looking into it further.

Move logic into your model. This lets you break functionality into more granular components and makes testing easier. Keep your controllers skinny. Jamis blogged about this principle here.

Use before filters to setup state before your controller runs. Use before_create in your models.

ActiveSupport helps you make your code intention revealing. Ruby code can be self documenting.

has_many, belong_to makes your code powerful easy to use, but many users don’t use the power of the associations.

Document.find_all_by_user_id(@john.id)

@john.documents # this one hits the db once and then stores the objects in memory. After the call you don't have to keep hitting the db.


You can do the same with

@john.documents.find(:all, :conditions => ....


try this:

@cool.documents.find_by_user_id(@john.id)


then define it as a method:

@cool.documents_authored_by(@john.id)

just be sure to not duplicate the method in both the tags and authors models that is difficult to maintain.
You might prefer:

@john.documents.tagged_with(@cool)


Don't use the '!!' idiom. What you are doing is saying not not.

def account_code?
!!@account_code.nil? # will return false if account_code nil
end


this is better

def account_code?
@account_code ? true : false
end


or you can do this

# make sure to document true because... false because...
def account_code?
if @account_code
true
else
false
end
end


I'm tired of typing code. I'll post a link to the slides when they get them up.

Simplify 'New' for creating objects with associations by creating a method in your model called build with associations that does that work for you instead of creating a bunch of objects and then associating them in the controller

Simplify your routes. If you are pointing to the same controller all the time use with_options

you can make better urls like this

def to_param
"#{id}-#{name}"
end

find(params[:id])

but you have to be careful in your controller to make sure that other methods work with params[:id]

returning new do |billable|
billable.contract = Contract.new
end

is the same as

billable = new
billable.contract = Contract.new
return billable

but looks cool

How do you deal with validations when you have a lot of associations. I have dealt with this and it sucks. I have had to force the various objects to validate and then pull the errors into an error object then show the errors from that object.

Another standing room only session. Perhaps the organizers will wise up and have at least on larger room next year for the sessions that are very popular.

We are going over the basics of audience analysis – understand your users:
Context
Motivations
Challenges

Know your stakeholders – anyone that has an interest in the project
Understand your objectives

Maybe it is just me but this seems like webdesign 101 it is also the standard stuff you hear in a 9th grade English class. Know your users. Talk to them. Get the goals from everyone that has a stake the project etc.

What is interesting to me is that he seems to imply that you can figure out your ‘users’ I have been reading Don’t Make Me Think. What is interesting is that Steve Krug the author says that there are no standard users of website. There are users and they frequently use your site in unique ways that the next user will not follow. That is one thing that makes the web a unique medium. Your users are not forced to sit and wait until after the next commercial so they can hear the news story they want. Instead they follow a non linear path of their own choosing.

Here’s a good point from his talk:
Don’t try to be everything to everybody. I think we know that, but it is so very easy to ignore that principle and say but this case is the exception. Before you know it you have a lot of exceptions and a bloated app with lots of useless features.

Other than a few reiterations of common sense web design (and any other design, instructional, etc) this talk is not especially enlightening.

Daemons are a bit of a dark art.


def daemonize
Kernel.fork and Kernel.exit
Process.setsid
Kernel.fork and Kernel.exit
# system maintenance items so you don't hold up directory maintenance and so you don't have to deal with permissions
File.umask 0
Dir.chdir '/'
# you don't want to hold onto
ObjectSpace.each_object(IO) {|io| io.close rescue nil}
STIN.open('/dev/null')
end


or just use a gem


require daemons
Daemons.daemonize

You can interact directly with your Rails environment.
include environment file

Threads
ThreadsBase.allow_concurrency = true

Or you will get a nasty error:
Mysql::Error: Lost connection to MySQL server during query:

Start and Stop
use a unix init script that takes start/stop/restart
OSX got ride of init script Solaris is going to do the same. Use Launchd instead. It uses xml.

Make sure the process doesn't start twice so that it doesn't run over itself.
Use a Pid File. This is how the daemon finds out its own id for stopping. It is also how you keep a process from starting up twice

Configuration Files
Talk to your process. Configure with yml files. Read it in with YAML.Load

Logging
Daemon doesn’t have standard IO. Log it. Do it with Logger.new. Set log levels etc. Use logging for debugging.

Security
When the system boots all is root. You don’t want your app running as root. Drop privileges as soon as you can so that you become a lesser user.
def become_user( …. See the slides

Testing
Create a test suite. Testing a daemon is challenging. Spawn the daemon before tests.
Mocking makes testing safer. See slides for code under slide Testing – Mocking makes this much safer.

This was a great talk with real code. We need more code.

I like Japanese food so we went looking for a Japanese restaurant last night. When we saw the place we kept walking because it looked like it would be crap. Unfortunately, all the other places were full and we were running out of time so we went back. Bad choice. If you are in Portland do not eat at Koji OsaKaya. Their food is total crap.

I have taken to eating granola bars and bananas. Does anyone have a decent recommendation for lunch?

PS a special thanks goes out to thoughtworks for supplying me with ALOT of granola bars.

I also had a conversation about releasing code on edge Rails. 37signals has no problem with it at all. DHH told me to freeze a version, test that and then release. This is a bit of a mind shift from the big frameworks like .net or java. If you release on a beta of either of those you will get fired and maybe sued. Microsoft doesn’t let you release on their framework until they ship unless you are willing to accept a ‘go live’ license.

The other thing we talked to him about was machine to machine authentication. They use basic http authentication over ssl (something DHH talked about in his keynote this morning). This is good to hear. We are working on a service that uses a REST API which will handle machine to machine authentication for all of our apps and which we plan to share with the world.

Anyway if you see DHH he is a great guy, but then most everyone at this conference is. I reiterate that I disagree with Chad Fowler. The Rails community isn’t a bunch of arrogant jerks. This is a friendly open community that loves to share the Ruby love.

Adam Keys is funny and entertaining

"If you want to learn from the masters you have to read their code."
Read code because "you're surrounded by idiots."

When you read Rails code start in the routes. You can look in the url to see where you are and then go to routes to figure out where the code is.

He is giving ideas for where to start and which parts of the app you should look at.

My complaint about this conference is still that the sessions aren't as advanced as I would like. I would love to see a session like we had at the Mountain West Ruby conference. Jamis Buck and Marcel Molina Jr. went through some code in front of everyone (our ozmozr code actually) and pointed out everything that was wrong. It was a great learning opportunity.

The main point of this talk is basically that you should be taking commonly used, well developed code - plugins, rake, core Rails code etc and read through it. Seems obvious but it really does make sense.

The talk turned out to be interesting in that it led to a discussion of revolution of of Frameworks and development philosophies. Historically, frameworks have evolved and been replaced with something new. In their wake however they leave large installations and large numbers of programmers trained in the technology. So I agree that there needs to be change and things need to get better. However, there is a need for responsibility. The success of these frameworks (like Ruby on Rails) depends on widespread adoption. Widespread adoption depends on some assurance that the framework will be around, be scalable, be developed, etc.