Item — HN Reader

Magic is wonderful when it works right, and painful when it goes wrong. I will absolutely agree that the magic built around speedy crud apps that handle 80% of what a web developer does making it only take a small fraction of time is a wonderful thing for productivity.

The problem with the magic for the 80%, is that the remaining 20% takes up the remaining 80% of the time. With the first 80% of the delivery in 20% of the time, the final 20% taking 4x longer because of the lack of understanding of the magic gives no advantage in the end.

Thats if everything goes well. If the 80/20 rule fails, you get the ninety-ninety rule ( https://en.wikipedia.org/wiki/Ninety-ninety_rule ).

RoR lets one build crud without understanding what goes on beneath the ActiveRecord. RoR is great when there is low complexity of the code and it is easy to follow the data through the pipes. Once it goes beyond that, adding complexity to that with the spooky action, highly declarative style that RoR encourages it can be painfully difficult to do - and something that far beyond what the 'write crud in 30 mintes/hours/days' classes offer.

Beyond that, with the failure to understand the before and beneath, one gets the impossible to debug bugs and security holes that lie within libraries that have been imported ( https://williamedwardscoder.tumblr.com/post/43394068341/ruby... ).

1 comments

> RoR is great when there is low complexity of the code

I disagree. RoR is great when there's moderate complexity. Microframeworks (Sinatra) are better for low complexity, and everything with high complexity is a unique and special snowflake.

> Magic is wonderful when it works right, and painful when it goes wrong

...and really educational when you start digging into it, and then you generally realize it only went wrong because you were trying to do something stupid.

> the remaining 20% takes up the remaining 80% of the time

Sure, but that's because the first 80% took a fraction of the time, not because that last 20% takes a multiple.

Do you have a particular example?

> spooky action, highly declarative style that RoR encourages

This is a bit of a "cognitive style" difference. In most of RoR - particularly your models - you want to be describing the idea of the thing. Since most people start programming by writing procedures, this is a bit of a leap. RoR Models are not about how a thing gets done, but about what that thing is. When you think from this perspective, RoR models are easy and nice.

> Beyond that, with the failure to understand the before and beneath...

Straight up, I want you to explain the complete before and beneath of your favorite tech stack or this is problematically hypocritical. I would then also want you to explain why it's reasonable to expect this of all programmers, rather than just senior programmers.

> Straight up, I want you to explain the complete before and beneath of your favorite tech stack or this is problematically hypocritical.

I can answer this one. I could explain to you every aspect of go's net/http package and database/sql package. The interface is compact, and even the source is very legible and easy to digest. You don't need all the extra bullshit to build API and run CRUD operations. I am a former RoR developer. I have lost no speed in just using simple tools and simple packages.

Also, I can have a junior or associate developer from any background get up to speed in a matter of days. Where as when I was at the Rails shop, you specifically had to hire a "rails guy/gal" and even then still took them days to get started.

(Don't mean for this to be a "go is great" rant, I am sure there are equally simple tools out there - Dropwizard is another one that comes to mind -- just a bunch of jars glued together)

> every aspect of go's net/http package and database/sql package

Nice! That sounds really appealing; I want to learn Go, I just haven't felt like I've identified a problem I want to solve that's best solved in Go.

That said, the obvious direction this questioning is going is...

Well, but either you're relying on the database and networking magic, or you need to understand the before/beneath of the database and networking; and it keeps recursing down until you get to the point of electrons in silicon, and then the switch is "magic of the scientific method".

How do you draw the line of "this magic is fine" and "this magic is not fine"?

It sounds like maybe the line isn't "do you know" but rather "what does it take to learn", and that Go makes it easy to learn the before / beneath?

I suspect that you learned a lot from Rails, though. For example, your applications probably have a thought-out directory structure, you clearly understand how the applications are layered, you probably pay attention to having good names, and think about testing.

It is possible to learn good practices without seeing well-structured applications that you can use as "role models", but it's really hard (I know, I had to read how to structure n-tier applications from books, and then apply it to a deficient platform that my employer had standardized on).

The "just use standard library" argument often seems a bit deceptive to me, though. For example, how are you managing schema updates?

> I suspect that you learned a lot from Rails, though. For example, your applications probably have a thought-out directory structure [..]

Absolutely, not saying my experience doesn't translate. However directory structure doesn't exist like you think in go. Files are the primary organization, and the only thing that goes in subfolders are different packages. It's actually quite nice, now I don't need to dig into 4-6 folders to get to the important stuff like I did in my Java/RoR days.

> The "just use standard library" argument often seems a bit deceptive to me, though.

It is absolutely a mantra in the go community. No deception here.

> For example, how are you managing schema updates?

Use your favorite tool! So funny you mention, I have a RoR background and I loved active-record migration, so I use standalone active record migration https://github.com/thuss/standalone-migrations, but you can just as easily use any other schema migration tool like Liquibase.

But what I am learning more and more these days is to just write sql. Write your migrations in plain sql. It's always easier for everyone involved. SQL is a ubiquitous language.