--
You received this message because you are subscribed to the Google Groups "Ruby on Rails: Core" group.
To post to this group, send email to rubyonra...@googlegroups.com.
To unsubscribe from this group, send email to rubyonrails-co...@googlegroups.com.
For more options, visit this group at http://groups.google.com/group/rubyonrails-core?hl=en.
That said, it's something that Rails has had since the beginning of
time, and was an original selling point.
That said, you could _still_ do the fifteen minute blog video, you'd
just run three commands instead of one.
It would _also_ probably cause another internet shitstorm. I can see
zillions of blog posts now. There's no such thing as bad press...
A big 4.0 release means a time to rethink old sacred cows.
Changing the guide would help new people, but removing it entirely
would be better.
I like it. :)
Pretty much this. Also, everyone using old books/tutorials (pre 4.0)
will run into trouble.
Don't get me wrong, I'm wholly in favor of killing it. Repeatedly. And
violently. But truth is, it's hard do kill something that has been
around this long, and that is included in pretty much all tutorials
for rails that have existed since The Beginning of Time.
Not sure what the best approach is.
-foca
On Thu, Mar 8, 2012 at 4:38 PM, Geoff Harcourt <geoff.h...@gmail.com> wrote:I would be in favor of either of these two options. I imagine extracting andgem-ifying the controllers would be a hassle, but then the default path forsetting up a new view and controller action would require the user to thinkabout what they are doing rather than just observe the magic.Unfortunately, I think that even if we were to extract out to a gem thatevery non-official tutorial and book would just tell users to add"rails_controller_generators" to their gemfile as the first step, and theintended goal of this work would be completely bypassed.Pretty much this. Also, everyone using old books/tutorials (pre 4.0)will run into trouble.Don't get me wrong, I'm wholly in favor of killing it. Repeatedly. Andviolently. But truth is, it's hard do kill something that has beenaround this long, and that is included in pretty much all tutorialsfor rails that have existed since The Beginning of Time.Not sure what the best approach is.-foca
My general feeling after seeing it in action:
A: You're not doing a beginner any favors. This holds true for a number of other things that I'd love to see demonstrated long-form in the guides before the shortcuts are introduced. `resource`-style routes and form helpers are awesome time/LOC-savers when you know what they're doing. When you don't, they're dark and mysterious magic words that you dare not examine too closely.
When we teach student the Rails-style REST pattern conceptually, show them how to connect routes, controllers, and models themselves, then show them the handy time-savers provided by the framework they perform better and appreciate the niceties more.
B: the advantages of Rails in 2012 aren't the same as the advantages of Rails in 2005. In 2005 relatively few people writing web apps separated concerns into different types of objects, followed any particular organization pattern, wrote tests, or any of the the practices that made Rails seem like such a breath of fresh air. Now basically every app framework – regardless of language – follows these as best practices. Routing, MVC, tests, are all important to highlight but they're par for the course. Scaffolding may have had some use in 2005 – it showed you how to properly write Rails before there was a body of well-written apps to examine – but there are better solutions to this problem now.
The advantages in Rails today have to do with large, enthusiastic (although sometimes overly curt) developer community, the ecosystem of well written and tested Rails-compatible libraries, the collection of good instructional material both in the project itself (Guides) and from 3rd parties, and the fact that Rails is still one of the places were smart people are experimenting with different (hopefully better) ways of making applications.
These are the things I'd miss if I was working with other tools and I think it's what we should focus on highlighting and improving.
- @trek
> --
> You received this message because you are subscribed to the Google Groups "Ruby on Rails: Core" group.
> To post to this group, send email to rubyonra...@googlegroups.com (mailto:rubyonra...@googlegroups.com).
> To unsubscribe from this group, send email to rubyonrails-co...@googlegroups.com (mailto:rubyonrails-co...@googlegroups.com).
On Friday, 9 March 2012 at 7:30 AM, Ryan Bigg wrote:
Hello friends,It's been fun having the scaffold generator exist as a part of Rails since The Beginning Of Time, but I think its time is now up. It has been abused time and time again, and most often leads to confusion amongst people who are new to Rails.This confusion happens when a user first generates a scaffold and sees that it is good. They can perform CRUD actions on a resource using one command?! WOW!Then they try to modify the scaffold and run into problems. First of all: how do they add an action to the controller? Do they need to run another command? How do they then define a route for that action? A template?If they were to *not* use the scaffold generator from the beginning, I believe they would have less confusion. They would know how to add another action to the controller and a template for that action because this would be how they're doing it from the start. Learning how to define a route for a new action in the controller is something easily learnable by reading the routing guide.I think that we can fix this problem in one of two ways, the latter more extreme than the first one.
The first way is that we completely change the Getting Started Guide to simply *mention* the scaffold generator, but then show people the "correct" way of generating a controller (rails g controller) and adding actions to it one by one, adding a model as its needed, and using similar practices to how you would do it in the "real world".
The second way, and sorry if this sounds a little extreme, is to completely remove the scaffold generator from the core of Rails itself. This means that there wouldn't even be the option to run the scaffold generator for newbies. You could then extract this out into a gem if you *really* wanted people to have the option for it. However, if this path was taken it should be made clear that this is not the "sanctioned" way to create controllers.
Thoughts?
--
You received this message because you are subscribed to the Google Groups "Ruby on Rails: Core" group.
To post to this group, send email to rubyonra...@googlegroups.com.
To unsubscribe from this group, send email to rubyonrails-co...@googlegroups.com.
To post to this group, send email to rubyonra...@googlegroups.com.To unsubscribe from this group, send email to rubyonrails-co...@googlegroups.com.
Many times all I need is a CRUD. The amount of customization I have to
do is minimized by having project specific templates in lib/templates,
and scaffold saves me quite some time. Even if I have to rewrite some
or most of the generated code, I still think it's pretty useful.
I agree, thought, that you really shouldn't use the scaffold if you're
a beginner and doesn't know what's going on. When I'm teaching Rails I
use the scaffold for a 15-minute WOW factor, but then I jump straight
to doing it piece by piece. Once one knows what the scaffold does, how
you can customize it, and how you'd do it all without the scaffold, I
don't really see all the evilness in it.
Can anyone please elaborate on the disadvantages of using the scaffold? :)
On Thursday, 8 March 2012 at 11:30 AM, Elomar Souza wrote:
Can anyone please elaborate on the disadvantages of using the scaffold? :)
Jumpstart Lab's intro to Rails class teaches without scaffolding, and
it's really fantastic, actually. At the end, the big reveal of 'What
you've done over the last day or two is just one command' blows
people's minds, but we've had some of them say "I'm really glad you
didn't show us that first."
This helpful Stack Overflow question should display why teaching noobs scaffold first off is a bad thing: http://stackoverflow.com/revisions/9622251/1. He's shown way too much code, and if you take a look at his routes he has a whole bunch of actions that probably don't need to be there. He has no idea what the controller provides to the view or how that even works.
We should teach them this *first* (create a controller, actions, etc.) and then show them the shortcut to doing it (scaffold generator). Teaching them scaffold first is wrong. It's a cheap trick that needs to die.
I think that extracting it out into a gem and educating people on how Rails should be taught would have the best impact. The people who still want to use scaffolding for rapid prototyping can do that.
There is really only one disadvantage to the scaffold
generators: They have to be maintained.
Every time Rails goes through one of its periodic
syntax/structure paroxysms the generators are immediately
placed out of date. A scaffold generator rewrite requires
some detailed knowledge of the new ways of the Rails world
otherwise the code they produce is worse than useless as
exemplars.
Unfortunately this knowledge is often limited in
distribution around the time the changes are introduced.
Further, those that do possess the requisite skills not
infrequently have no wish to spend their limited time on
something that they do not use themselves and perhaps
believe is 'morally' suspect from a professional point of
view.
I rather suspect that arguments about the benefits of
building RoR apps 'from the ground up' and potential
confusion for Rails newcomers that might arise from using
scaffolding is quite beside the point.
--
*** E-Mail is NOT a SECURE channel ***
James B. Byrne mailto:Byr...@Harte-Lyne.ca
Harte & Lyne Limited http://www.harte-lyne.ca
9 Brockley Drive vox: +1 905 561 1241
Hamilton, Ontario fax: +1 905 561 0757
Canada L8E 3C3
> Agreeing with José, I work on a University, and we try to keep all our systems follow a pattern, so clients get used to our layout and design and our developers get standard comment tips about how to name and describe methods. For this, we rely strongly on scaffold customization.
>
> I also agree that this should not be put as an advantage for beginners on tutorials and books, showing them how to "not" write code. Even a warning message could appear on scaffolding generation, or making the generators a little less "automagic" (and maybe a little more dumb also), forcing people to customize scaffolds before getting something usable.
WAT.
No, seriously - this is like a group of Ikea craftsmen deciding to no longer use pre-cut wood, since making customers cut it for themselves will teach them carpentry more quickly. "Dumbing down" the generator is them trying to split the difference by cutting to shape but not drilling holes; both approaches ignore that the "EAT UR VEGGIES NAOW" method only works if you've got customers that can't choose an alternative.
To me, it seems easier to imagine the counterfactual: imagine Rails *without* a similar generator, and then imagine the responses to a proposed generator that would automatically create reasonably clean, idiomatic code that a new developer could quickly see results from. Such a thing would likely be popular...
--Matt Jones
There is really only one disadvantage to the scaffold
generators: They have to be maintained.
a) We, as developers *of* Rails (or at least those who lurk here), realize that we're not the primary target of scaffolding. So, while it could be moved to gem for pros, it would be hard on new developers if it wasn't baked in and highlighted in guides/docs
b) People who have spent time teaching Rails to new folks have chimed in saying they don't tell people to about scaffolding or, if they show people it exits, it's with a hand-wavy caveat: don't use this yet, since you don't know what it's all doing.
c) Folks who haven't taught Rails (or at least didn't mention it) say the teaching folks thinking about it backwards: "After you know, using it is a cheap trick, before then it's a useful way to get an example and dig in."
d) Other people counter saying "no idea about the n00bs, but I use scaffolding so much that I have custom scaffolds to match my coding style"
Thoughts:
* Scaffolding is less useful to new Rails developers – at least those with a learning resource of some kind – than we assumed
* Scaffolding is more useful to pro Rails developers – especially with personalization – than we assumed
Separating/keeping the scaffold generator might be a good Github ticket-based question for the larger Rails community. Then we'd get a feel for how many people use it and how they're using it.
If the answer is "hardly anyone and many of those people use customization" it might indicate that scaffolding generation would be a good 3rd party project: scaffold users could give scaffolding the loving care it deserves. The notion that it's a tool for beginners might be holding back some truly excellent growth
If the answer is "almost everyone and without customization" then it should remain as part of core. I'd *still* argue it should be moved out of the Getting Started with Rails guides
If the answer is "never use it now, but it was invaluably helpful when I was learning" then the suggestion of making it a more incremental generator that can build the entire REST pattern over time by running it multiple times would be awesome. I think this would also jive better with the TDD/BDD threads floating through Rails. I've always found it odd to talk TDD and then generate a hundred lines of untested code.
Incremental scaffolding would generate only the routes, models, migrations, controller/action, spec/test files and context/describe blocks, for the specific thin slice of Rails you're currently developing. Running it a second time with new arguments would slowly build a Rails app with guidance.
e.g:
$ rails g scaffold Person
- empty model
- migration to create table
- empty model test file
possibly we could run tests so after generation there's a clear next step: write tests
$ rails g scaffold Person new create
- model exists
- no migration changes needed
- empty resource controller
- resource controller spec create with context for new and create
- route added: "resources :people, :only => [:new, :create]"
- empty view for new, create
running later:
$ rails g scaffold Person name:string birthdate:date
- model exists (although maybe attar_accessible :name, :birthdate is added and warning about mass assignment)
- migration created to add name and birthdate attributes
- form partial gets name/birthday fields appended
- model test file gets new empty context/describe blocks for added attributes
- no controller or route changes
- @trek
> --
> You received this message because you are subscribed to the Google Groups "Ruby on Rails: Core" group.
> To view this discussion on the web visit https://groups.google.com/d/msg/rubyonrails-core/-/MxELMN9M7OYJ.
> To post to this group, send email to rubyonra...@googlegroups.com (mailto:rubyonra...@googlegroups.com).
> To unsubscribe from this group, send email to rubyonrails-co...@googlegroups.com (mailto:rubyonrails-co...@googlegroups.com).
With gems like inherited_resource, I am not sure what the use of scaffolding is.
--
You received this message because you are subscribed to the Google Groups "Ruby on Rails: Core" group.
To view this discussion on the web visit https://groups.google.com/d/msg/rubyonrails-core/-/s7O105GGnjAJ.
To post to this group, send email to rubyonra...@googlegroups.com.
To unsubscribe from this group, send email to rubyonrails-co...@googlegroups.com.
> b) People who have spent time teaching Rails to new folks have chimed in saying they don't tell people to about scaffolding or, if they show people it exits, it's with a hand-wavy caveat: don't use this yet, since you don't know what it's all doing.
Just my 2 cents.
I think being overprotective of noobs from themselves is not exactly learning-friendly. Scaffolds may be bad when you're actively mentoring someone, you get overwhelmed with having so much to explain at once, but for those who learn on their own (like I did) — scaffolds are something for me to discover, explore, abuse, ask a bunch of "how do I make scaffolding build my site for me" questions on IRC (there was no SO when I was learning), get yelled at, abandon them, then maybe rediscover them again as a configurable generator tool.
That first "discover and explore" stage turned out invaluable as soon as I understood that scaffolds simply generated a bunch of code. From then on, I was reading the code and connecting the dots. Even at the point when I abandoned scaffolds, I still occasionally generated a Foo scaffold just to remember how it's recommended to write create/update action in my controller, and such.
Scaffolds are most useful to those who learn by example and learn alone. Did anyone speak out who isn't teaching and isn't being mentored?
Please note, from the inhereted_resources page:
Since Rails 3 came out, I have no longer used Inherited Resources. I
have found that the responders abstraction and
custom Rails generators offer the perfect balance between hiding and
showing too much logic. That said, I suggest developers to make use of
the responders gem (at github.com/plataformatec/responders) and no
longer use Inherited Resources.
So even it is deprecated. ;)
+1 on all that.
Scaffolds are a boon to someone trying to work it out for themselves
and they provide the instant gratification Wow factor that lets them
get something up and running like magic. They did exactly that for
me.
Colin
This doesn't address the fact that scaffolds teach the learner
incorrect things. Even if it's instant, it's still ultimately bad.
Furthermore, since they shouldn't use them when they get more advanced
either, it leads them down the long path, and 'running like magic'
means that you didn't really learn anything anyway.
I don't think it teaches them incorrect things, it fails to teach many
things but what it does teach is ok. Can you give an example of an
incorrect thing that it teaches?
> Even if it's instant, it's still ultimately bad.
> Furthermore, since they shouldn't use them when they get more advanced
> either, it leads them down the long path, and 'running like magic'
> means that you didn't really learn anything anyway.
I think I learned a lot from scaffolding when I was first trying to
work out what rails was all about.
Colin
I agree that an incremental code generator for RoR would
be an incredible tool. Whether it is feasible is another
question.
On Friday, 9 March 2012 at 10:16 AM, Colin Law wrote:
On 9 March 2012 18:06, Steve Klabnik <st...@steveklabnik.com> wrote:Scaffolds are a boon to someone trying to work it out for themselvesand they provide the instant gratification Wow factor that lets themget something up and running like magic. They did exactly that forme.This doesn't address the fact that scaffolds teach the learnerincorrect things.I don't think it teaches them incorrect things, it fails to teach manythings but what it does teach is ok. Can you give an example of anincorrect thing that it teaches?
Even if it's instant, it's still ultimately bad.Furthermore, since they shouldn't use them when they get more advancedeither, it leads them down the long path, and 'running like magic'means that you didn't really learn anything anyway.I think I learned a lot from scaffolding when I was first trying towork out what rails was all about.Colin
--You received this message because you are subscribed to the Google Groups "Ruby on Rails: Core" group.
To post to this group, send email to rubyonra...@googlegroups.com.To unsubscribe from this group, send email to rubyonrails-co...@googlegroups.com.
Could we get technically specific on which "incorrect" things
the scaffold brings?
Maybe we could try to fix those specific issues (on a technical
and documentation level).
On a technical level, I see 3 specific (but fixable) problems:
* the issue with attr_accessible is not explained (so the application is
vulnerable to owner_of_record_id being set to another owner as in the
recently publicized case). I see solutions for that (changing the code,
in the direction suggested recently by @dhh (that is not attr_accessible,
but a local function in the controller that slices the params in the
controller context) and adding explanation about it).
* the default auto-generated controller rspec tests have a few minor issues
that make those tests brittle (comes down to slightly improving that format)
* the views have a horrible amount of repetition. We should have a simple
loop there doing each over an array of [:field_name, :type] entries (that
structure is available anyway to produce the migration). That approach would
also make it trivial to manually add and remove a few fields later on.
Optimally that list of "active fields" in the new and edit views should be the
slice list for filtering the incoming params in create and update actions
(IMO that is the proper solution for the attr_accesible issue and it would
be not too difficult to bake that right into the scaffold code).
Besides these 3 issues, rails g scaffold continues to be valuable to me.
E.g. I have actively used it this week to bootstrap a new project. The
valuable points for me where:
* migrations are made automatically
* I get a an initial framework of rspec tests (model controller, views) that
give a basic test scaffold as I start adapting the application to the real use
case.
* I had an immediate view on the actual data in existing production db.
On a more general note, I would certainly want to continue to use scaffolds,
in one form or another.
HTH,
Peter
On Friday, 9 March 2012 at 6:45 AM, Trek Glowacki wrote:
So, just to recap the flow of this conversation for myself:a) We, as developers *of* Rails (or at least those who lurk here), realize that we're not the primary target of scaffolding. So, while it could be moved to gem for pros, it would be hard on new developers if it wasn't baked in and highlighted in guides/docsb) People who have spent time teaching Rails to new folks have chimed in saying they don't tell people to about scaffolding or, if they show people it exits, it's with a hand-wavy caveat: don't use this yet, since you don't know what it's all doing.c) Folks who haven't taught Rails (or at least didn't mention it) say the teaching folks thinking about it backwards: "After you know, using it is a cheap trick, before then it's a useful way to get an example and dig in."d) Other people counter saying "no idea about the n00bs, but I use scaffolding so much that I have custom scaffolds to match my coding style"
Thoughts:* Scaffolding is less useful to new Rails developers – at least those with a learning resource of some kind – than we assumed* Scaffolding is more useful to pro Rails developers – especially with personalization – than we assumedSeparating/keeping the scaffold generator might be a good Github ticket-based question for the larger Rails community. Then we'd get a feel for how many people use it and how they're using it.
If the answer is "hardly anyone and many of those people use customization" it might indicate that scaffolding generation would be a good 3rd party project: scaffold users could give scaffolding the loving care it deserves. The notion that it's a tool for beginners might be holding back some truly excellent growthIf the answer is "almost everyone and without customization" then it should remain as part of core. I'd *still* argue it should be moved out of the Getting Started with Rails guides
If the answer is "never use it now, but it was invaluably helpful when I was learning" then the suggestion of making it a more incremental generator that can build the entire REST pattern over time by running it multiple times would be awesome. I think this would also jive better with the TDD/BDD threads floating through Rails. I've always found it odd to talk TDD and then generate a hundred lines of untested code.Incremental scaffolding would generate only the routes, models, migrations, controller/action, spec/test files and context/describe blocks, for the specific thin slice of Rails you're currently developing. Running it a second time with new arguments would slowly build a Rails app with guidance.e.g:$ rails g scaffold Person- empty model- migration to create table- empty model test filepossibly we could run tests so after generation there's a clear next step: write tests$ rails g scaffold Person new create- model exists- no migration changes needed- empty resource controller- resource controller spec create with context for new and create- route added: "resources :people, :only => [:new, :create]"- empty view for new, createrunning later:$ rails g scaffold Person name:string birthdate:date- model exists (although maybe attar_accessible :name, :birthdate is added and warning about mass assignment)- migration created to add name and birthdate attributes- form partial gets name/birthday fields appended- model test file gets new empty context/describe blocks for added attributes- no controller or route changes
- @trekOn Thursday, March 8, 2012 at 8:26 PM, Mark Ratjens wrote:My first gut feeling was "kill it, kill it". But then, I am the kind of person that tends to spring-clean then regret throwing away too much.The Wow factor is what got me into Rails in the first place, even though I quickly refactored the scaffold code I had generated ... and never looked back. Scaffolds help lower the barrier to newbies. I may not have jumped out of Java into Rails as quickly if that barrier was higher. But that was 2005 ...So I think it's an issue of education. Trainers, mentors and senior devs need to 'pace' newbies.1) Show them scaffolds. Let them go 'wow.'2) Develop an example to the point where scaffolds become problematic. Let them grok the cul-de-sac they're in.3) Fix the problem by showing them how controllers are really developed.You can't go directly from step 1 to step 3, because many of them will still be basking in the glow of the wow. The won't be attending to what you're trying to show them. As some have said, their mental models could be distorted.Mark Ratjens--You received this message because you are subscribed to the Google Groups "Ruby on Rails: Core" group.To view this discussion on the web visit https://groups.google.com/d/msg/rubyonrails-core/-/MxELMN9M7OYJ.To post to this group, send email to rubyonra...@googlegroups.com (mailto:rubyonra...@googlegroups.com).To unsubscribe from this group, send email to rubyonrails-co...@googlegroups.com (mailto:rubyonrails-co...@googlegroups.com).For more options, visit this group at http://groups.google.com/group/rubyonrails-core?hl=en.--You received this message because you are subscribed to the Google Groups "Ruby on Rails: Core" group.
To post to this group, send email to rubyonra...@googlegroups.com.To unsubscribe from this group, send email to rubyonrails-co...@googlegroups.com.
I did not speak out, but learned rails on my own using training materials and attending some short classes. I started just before the end of the dynamic generators. I think everyone agrees that the dynamic generators were bad, but the current generators were a big help. They showed the correct way to build controllers and helped teach CRUD. It also provided a nice bookend to the routes resources macro. I hope we keep them, if we do chunk them we should also consider changing the default route generation for models to not use resources as that will create even more confusion.
I like them, they helped me learn Rails and CRUD, I use them and I am stoked to learn I can customize them.
> --
> You received this message because you are subscribed to the Google Groups "Ruby on Rails: Core" group.
> To post to this group, send email to rubyonra...@googlegroups.com.
> To unsubscribe from this group, send email to rubyonrails-co...@googlegroups.com.
--
You received this message because you are subscribed to the Google Groups "Ruby on Rails: Core" group.
To unsubscribe from this group and stop receiving emails from it, send an email to rubyonrails-co...@googlegroups.com.
To post to this group, send email to rubyonra...@googlegroups.com.
Visit this group at https://groups.google.com/group/rubyonrails-core.
For more options, visit https://groups.google.com/d/optout.