Vue.js is not Easy.
It is Approachable.
Vue.js is not Easy. It is Approachable.
A Familiar Sound
Nowadays, marketing terms like Simple/Easy are frequently used.
I don't intend to mention other specific languages or frameworks this time.
This is purely a story about how to approach Vue.js.
"Vue.js is Easy"
Have you ever heard this phrase?
I've heard it many times.
And just as often, I've heard people say "Vue.js is bad because it has no rules."
Fallacy
I started working with Vue.js / Web around Q4 of 2020, and I don't know what the world was like before that.
I also don't know when this phrase started becoming popular.
However, based on my current feelings, I always have doubts about whether using this phrase is appropriate.
"Vue.js is Easy" is, in my opinion, still correct in limited contexts.
But how many people actually understand those contexts?
Lately, there's been a trend of "things with rules (not limited to web frameworks)," and they do their own marketing like "〇〇 is △△ (but not Easy)."
And in response to that,
"Vue.js is bad because it has no rules"
"It sacrifices rigidity for short-term simplicity"
"Having no rules makes code a mess"
Such claims emerge.
Abstract marketing gets beaten by abstract marketing.
Trade-offs
As I mentioned earlier, "Vue.js is Easy" is indeed correct in some contexts.
Since Vue.js has no explicit rules, it's correct in the sense that from the framework's standpoint, it's not wrong even without learning any particular rules.
However, actually building a product requires thinking about many things.
And here lies a trade-off.
Many people probably approach programming with the preconceived notion that "having rules is better" without considering this trade-off.
Of course, even "having rules is better" has its own trade-offs, but that's not what I want to discuss today.
Let's imagine a situation where the conclusion was "having rules is better."
What should be considered here is:
- What is the rule for (what benefits does having that rule bring)
- Is it appropriate for the current (future) team (yourself) (I'm using parentheses because it varies by context)
- What trade-offs does that rule create
Web applications are incredibly diverse.
Some simply implement UI for data from the backend and display it,
while others provide rich UI combined with complex DOM operations.
And the rules needed for these are completely different.
Design is quite ad-hoc, and there is no silver bullet.
Who's Responsible
What's important here is "who takes responsibility for those rules".
In the case of web applications, I don't think it's necessarily good for the framework to own the rules.
Of course, there may be use cases where it's good for the framework to own the rules.
However, having "the framework"—the foundation of our work—take on this responsibility involves trade-offs.
When the framework takes responsibility here, in most cases, compliance with it is expected.
Even if it's not important for our product.
At the same time, we should also consider other trade-offs that are lost as a result (such as learning costs).
Additionally, I want to note that "who takes responsibility for those rules" and "whether rules are necessary" are completely different matters.
Abstraction Through Language
I've covered the essential points I wanted to make so far.
However, we can't help but want to play word games with definitive statements.
If "Vue.js is Easy" tends to contain negative fallacies and isn't appropriate, what should we say instead?
I love the word "Approachable" that appears in Vue.js's official documentation.
As I mentioned earlier, "Vue.js is Easy" is correct within the scope of "the framework's responsibility," but when extended to "implementing (and maintaining) web applications," it may lead to incorrect judgments.
If there's some kind of challenge (demand), thinking about conventions and design is a given.
The word Easy might give the fallacy that you can build something good without thinking about this.
Vue.js is Approachable.
It doesn't get in the way when you're thinking about something.
However, in exchange, the implementer bears a bit of responsibility.
This is a trade-off.
This is merely my personal essay and not an official view of the Vue.js Team.