we should break down and MR into "Blocks"

command = AuthenticateUser.call(params[:email], params[:password]) 8 9 if command.success?

Instead of using private controller methods, simple_command can be used.

The Executor replaces these with a single more abstract interface.

A data model[1][2][3][4][5] is an abstract model that organizes elements of data and standardizes how they relate to one another and to the properties of real-world entities.

Testing frameworks often introduce their own abstractions for e.g. evaluation order, data validation, reporting, scope, code reuse, state, and lifecycle. In my experience, these abstractions are always needlessly different from (and inferior to) related abstractions provided by the language itself.

The argument used to propose its use is to avoid the construction of multiple volatile objects. This supposed advantage is not real in virtual machines with efficient garbage collection mechanisms.

The complex typewriting effect is abstracted away in a neat function, out of site and out of mind.

Please note that this is a higher-level debugging tool that does not confront you with a 200-lines stack trace the way Ruby does it, but pinpoints the exceptional code and locates the problem on a task level. This is possible due to you structuring code into higher abstractions, tasks and activities.

While you could program this little piece of logic and flow yourself using a bunch of Ruby methods along with a considerable amount of ifs and elses, and maybe elsif, if you’re feeling fancy, a Trailblazer activity provides you a simple API for creating such flow without having to write and maintain any control code. It is an abstraction.

Activities are a necessary abstraction on top of Ruby.

An activity is a high-level concept to structure code flow

In functional programming, a monad is an abstraction that allows structuring programs generically

would love to hear from you if you’re excited about our gems, high-level abstractions and improving our documentation

This text wound up founding the discipline which we today call "metaphysics", and one way to describe what this subject encompasses is that it covers things at a level of abstraction above physics.

Trailblazer extends the conventional MVC stack in Rails. Keep in mind that adding layers doesn't necessarily mean adding more code and complexity. The opposite is the case: Controller, view and model become lean endpoints for HTTP, rendering and persistence. Redundant code gets eliminated by putting very little application code into the right layer.

While Trailblazer offers you abstraction layers for all aspects of Ruby On Rails, it does not missionize you. Wherever you want, you may fall back to the "Rails Way" with fat models, monolithic controllers, global helpers, etc. This is not a bad thing, but allows you to step-wise introduce Trailblazer's encapsulation in your app without having to rewrite it.

Yes, Trailblazer is adding new abstractions and concepts and they are different to the 90s-Ruby, but now, at the latest, it becomes obvious how this improves the developing process. We’re no longer talking in two-dimensional method stack traces or byebug hoops, the language and conception is changing to the actual higher level code flow, to activities sitting in activities structured into smaller step units.

I feel how needed those new abstractions are. Yes, you can write everything with your own code, you don’t need abstractions for flow control and automatic error handling, which makes me wonder why you’re not programming in assembler since Ruby is also an “unnecessary abstraction” on top of a processor. We need abstractions, unless you want to program like we did 30 years ago.

Also, the more I use Trailblazer in projects or even in Trailblazer itself, I feel how needed those new abstractions are.

That's the whole point of an abstraction layer—to isolate your business logic from a subsystem's mechanics

Abstract myself from the how it does and get focus on what to do.

I've been over the use case for form objects in this post on moving away from fat models but wanted to go into more detail on how and why I use them here. I really believe in the utility of these objects; their ability to abstract and isolate logic in a simple and effective manner is unmatched, IMO.

It's a generic abstraction for the logic and styling of elements that pop out from the flow of the document and float next to a reference element, overlaid on top of the UI.

but the design pattern is so simple that it takes hardly any effort to implement it on any existing reducer, so I rejected abstraction for abstraction's sake.

One should "depend upon abstractions, [not] concretions."

express one's model of Existence

Ambiguity is a tool of consciousness to compel us to explore the dissonance in our current model of Existence. Follow the rabbit hole…and a richer Existence awaits.

Language, using a schema, provides a system of abstraction enabling one to model something. Language is context sensitive & composable. With the Language tool, we craft systems of illusion, intelligence, & life.

"The Map is not the territory" —Alfred Korzybski

"All non-trivial abstractions, to some degree, are leaky" —Joel Spolsky

Alfred Korzybski remarked that "the map is not the territory" and that "the word is not the thing", encapsulating his view that an abstraction derived from something, or a reaction to it, is not the thing itself.

The map–territory relation describes the relationship between an object and a representation of that object, as in the relation between a geographical territory and a map of it.

"The menu is not the meal."

A map is not the territory it represents, but, if correct, it has a similar structure to the territory, which accounts for its usefulness.

Transparent debugging: a <div> is just a div.

Eliminating needless classes frees up operating memory on the computer—and bandwidth in your head.

While you can do a lot with just utility classes, as a project grows it can be useful to codify common patterns into higher level abstractions.Tailwind provides tools for extracting component classes from repeated utility patterns, making it easy to update multiple instances of a component from one place:

However, it is often the case that you do need a higher layer of abstraction in order to deal with the complexity of non-trivial applications. If you don’t deal with that abstraction explicitly, one day you will wake up and find that you’ve created a mess of abstraction and indirection through a thousand cuts.

This is an abstract form of De Morgan's laws, or of duality applied to lattices.

When it comes to building HTTP APIs, other frameworks weigh you down with tons of dependencies and unnecessary abstractions. Falcon cuts to the chase with a clean design that embraces HTTP and the REST architectural style.

I'm always in awe at some of the things you can create with the simple primitives that d3 provides.

the abstraction I wished to have was a sort of a pure functional Vim, completely decoupled from terminal UI - where 'vim' is a function of (editor state, input) => (new editor state)

There is no reason material-ui can't create a better abstraction on top of the one provided by React itself though.

abstraction is in itself but a dull and inert thing