"That said, I threw my hands up after running into multiple libraries duck punching (monkey patching) ActiveSupport into a mangled, conflicting mess one too many times. The open classes thing really is harmful, no matter what anyone tells you. It's a feature that, when used with care, can be very powerful...but the problem is in my experience it's not used with care very often in the Rails world."

I don't quite agree with this. Of course I agree that you should use monkey patching with care, but it's the implications I disagree with.

First, you can monkey patch in python too. Python doesn't make this safer, but it is used more in the ruby world. I think the implication that I take issue with is that it's rails fault that some other library you used monkey patched rails. It's the libraries fault, and people should look into libraries before they use them. Just as you should use monkey patching with care, you should use other peoples libraries with care. Peek at the code before using it.

Rails 3 makes it easier to change things without monkey patching so it should occur less frequently going forward.

I guess the issue is the prevalence with which it occurs in Ruby, as you say. I've been programming professionally for over a decade now, in at least as many languages, and I've only had this problem with ruby.

Still, I enjoy ruby very much, and I haven't seen my last project in it or Rails. I just need reliability and consistency now, and Python seems to offer more of it. I may as you say hit this same problem in Django, but I haven't yet.

"I've been programming professionally for over a decade now, in at least as many languages, and I've only had this problem with ruby."

It's a trade off. Take away monkey patching and you get other problems. Just look at java projects. Once you make an interface and someone else uses it you can't change it anymore without breaking everyones code. Check out the eclipse code base for examples.

That's a helpful metaphor. What I'm looking for is a framework that can be used for rapid prototyping, and it sounds like rails fits the bill.

Django is great for rapid prototyping. The admin area is built in, that alone saves a ridiculous amount of time

The admin will definitely be extremely helpful to someone who is new to databases.

You may also want to consider Sinatra for rapid prototyping. It's lighter weight (less framework) than Rails. Depending on your preferences, it may suite your needs.

Sinatra is also based on Ruby yes? How does it differ specifically from Rails?

I'd learn rails over sinatra. Sinatra is like being thrown into the deep end of the pool when you haven't learned to swim yet. You have to do it all yourself, where as in rails they've done all foundational stuff for you. Learning rails will teach you some good practices for how to structure a project, sinatra assumes you already know how to do this stuff yourself.

Yes, Sinatra is a Ruby web framework.

Sinatra is more of a "micro-framework" and puts you closer to the http method.

Basically, the api mimics http more closely, you literally use get, put, post, and delete methods to define your routes and actions.

In Sinatra, you define your routes in the same place where you program your Resource's functionality, so less mapping is required. In Rails, you have a separate controller and route files.

The model layers between Sinatra and Rails are very similar. For example, you can use ActiveRecord in Sinatra.

Say I take the Rails class. What's the learning curve from there to Sinatra? Better / worse than the other way?

The learning curve to Sinatra will be light. Sinatra is pretty easy to learn, especially if you already know Rails.

Also, if you want rapid prototyping, you should look into a document store such as Mongo.

Not having to write migrations (as you would with ActiveRecord + Mysql) is huge.

Also, your models can be more flexible. You can add keys to your document as needed. With Mysql, you need to have a migration to add the column.

No offense, but this is absolutely bad advice to a newbie programmer. First, mongo_mapper is virtually undocumented, whereas ActiveRecord has oodles of documentation and examples. You'll spend a order of magnitude more time trying to learn to use both MongoDB and mongo_mapper effectively than you will writing a proper set of migrations.

Second, I'm tired of all the NoSQL hype. I've worked on a project with MongoDB and MongoMapper, and the combination caused more problems than it solved. If you want cutting edge and all that comes with that, go with Mongo. Otherwise, if you'd prefer to focus on problems in the domain you're trying to solve and not the technology you're trying to solve it with, go with something relational and tried and true (PostgreSQL, if I were deciding).

I'm sick of all of the hype (for the past 20+ years) that relational databases is the only data storage technology you need.

When all you have is a hammer...

That's true and all, but Rails and Django were built to run on SQL dbs right out of the box. Getting them to work with MongoDB takes some work, and I don't think it's a diversion that someone just starting learning frameworks should try to deal with.

As for migrations, I don't think he's gonna be dealing with anything too complicated schema-wise. Django South will write your migrations for you. Maybe Rails has something like that? But honestly, I'd recommend using SQLite and just starting a new file whenever he really felt the need to alter the schema.

@grasshopper - That makes sense. Mongo is certainly new tech, so it would be more work right now with Rails.

With Sinatra, I'm finding it to be less work.

I would probably stick with relational tech if starting off with Rails, but keep your eye open toward alternative store, such as document databases and key/value stores.

@refugee - My experiences have been quite the opposite. Mongo allows me to focus on the domain. AR forces me to think about fitting the relational model into my problem, which causes a huge impedance mismatch, and causes lots of extra work and performance issues.

Of course it depends on the problem, but working with hashes and arrays is simpler than the relational model, no?

I do concede the vast swaths of docs for AR, however AR is pretty complicated and issues arise that aren't well documented.