Vue.js is not Easy. It is Approachable.
Familiarity
Recently, the marketing term "Simple/Easy" has been commonly used.
This time, I will not mention specific languages or frameworks other than Vue.js.
This is a story about how to approach Vue.js.
"Vue.js is Easy"
Have you heard this phrase before?
I have heard it many times.
And just as many times,
I've heard a lot of words like "Vue.js has no rules, so it's not good."
Fallacy
I started to work with Vue.js/Web around Q4 2020, and I do not know how the world was before that.
And I do not know when this phrase became popular.
However, I always feel doubtful as to whether it is appropriate to use this phrase based on my current feelings.
In my opinion, "Vue.js is Easy" is correct in limited contexts even now.
But how many people really understand that "context."
Recently, there is also a trend of "entities with rules (not limited to web frameworks)" who often market themselves as "〇〇 is △△ (not easy)."
And as a response to that,
"Vue.js has no rules, so it's not good."
"Sacrificing toughness for immediate simplicity."
"The lack of rules makes the code messy."
Such statements arise.
Abstract marketing is defeated by abstract marketing.
Trade-offs
As I mentioned earlier, indeed, "Vue.js is Easy" is correct in some contexts.
Since Vue.js does not have clear rules, it is not wrong as a framework not to require learning any rules.
However, to actually create a product, you need to consider many things.
There are trade-offs here.
Probably, many people are engaging in programming without thinking about these trade-offs, prioritizing the need for rules.
Of course, there are trade-offs even in the idea that "rules are necessary," but that is not the focus today.
Let's imagine a conclusion being made that "rules are necessary" in a certain situation.
What you need to think about here is,
- What are the rules for (what benefits do the rules provide)?
- Is it appropriate for the current (future) team (or yourself) (I have put it in parentheses because it depends on the context)?
- What trade-offs does the rule entail?
Web applications come in many varieties.
There are applications that simply implement UI with data obtained from the backend and display it, as well as those that provide rich UIs by combining complex DOM operations.
The rules required for these are completely different.
Design is quite ad hoc, and there is no silver bullet.
Stakeholders
What is important here is "Who is responsible for these rules."
In the case of web applications, I do not necessarily think it is good for the framework to have rules.
Of course, there may be good use cases where the framework has rules.
However, there is always a trade-off when the fundamental part called "framework" takes on this responsibility.
If the framework assumes this responsibility, in most cases, compliance is desired, even if it is not important for our product.
At the same time, you should also consider the other trade-offs that might be lost (such as learning costs).
In addition, it is important to note that the discussion of "Who is responsible for these rules" is separate from whether rules are necessary.
Abstraction through Language
I have already talked about the essential points I want to make.
However, we cannot help but play with words in a definitive way.
When it comes to "Vue.js is Easy," negative fallacies are often included, and if it is not appropriate, what should we say?
I love the word "Approachable" that appears in the official Vue.js documentation.
As I mentioned earlier, "Vue.js is Easy" is correct within the "framework's responsibility" scope, but when expanded to the implementation (and maintenance) of web applications, it implies the potential for making incorrect decisions.
It is natural to think about conventions and designs when there is some issue (demand).
The word "easy" can give the fallacy that you can create something without thinking about it.
Vue.js is Approachable.
It does not get in the way when thinking of something.
However, in exchange, the implementer bears some responsibility.
This is a trade-off.
This is just my essay and not the official view of the Vue.js Team.