DEV Community: George Udonte

Crash Guide to Vue 2 in 2025 (Part 1)

George Udonte — Sat, 06 Dec 2025 08:24:12 +0000

Of course, Vue has been around for a while and you may not even have used it before. So if you’re trying to get started with Vue 2 (yes, not Vue 3), let me tell you this:

You’re not “late.”
It’s not outdated.
It’s still powering enterprise-grade production apps that won’t magically disappear because a new version exists.

Vue 2 still rocks, especially if you’re joining a team maintaining an existing product, or you want to understand the foundations behind Vue 3’s improvements.

So let’s get started, you’ll understand how Vue 2 works, how to think like a Vue developer, and how to build scalable structure using Vuex and TailwindCSS.

Step 1: Understand Vue’s Mindset (Not Just Syntax)

Now Vue isn’t just a framework, it’s a philosophy:

Data-driven UI
The DOM doesn’t dictate UI — your state does.
Declarative → Not Imperative
Instead of writing document.querySelector(...), you write:

data() { return { count: 0 } }

…and your UI reacts automatically.

Component First Architecture Everything becomes reusable, maintainable blocks.

If you never internalize this mindset, everything else will feel like mechanical copying. And I mean that.

Step 2: Setup Your First Vue 2 Project (With CLI)

If you haven’t installed Vue CLI:

npm install -g @vue/cli

Create your project:

vue create vue-starter

Choose options like:

Babel
Router (optional)
Vuex
Linter

Then start the dev server:

npm run serve

Boom: Vue is alive.

Step 3: Understand the Vue 2 Component Anatomy

Every Vue component has three core parts:

<template> <button @click="increment">Clicked {{ count }} times</button> </template>

<script> export default { data() { return { count: 0 } }, methods: { increment() { this.count++ } } } </script>

<style scoped> button { padding: 10px; } </style>

Concepts to truly understand:

data():
This must return a function in components and it prevents shared state between instances.
methods vs computed:
Computed caches results while methods re-run always.
props:
The communication channel from parent → child.

4.$emit():
Child → parent communication.

Once these click, Vue stops being “syntax” and becomes a “lifestyle.” lol

Step 4: Project Structure That Scales

Avoid dumping components in one folder like a todo list gone wrong.

Use this structure pattern:

src/
┣ components/
┣ views/
┣ store/
┣ assets/
┣ router/
┗ utils/

Observe that in ReactJS, a pages folders is created instead of a views folder in VueJS.

Why structure it this way?

Because the future you and even the future of other developers, deserves mercy. lol.

Step 5 — State Management With Vuex

When components start sharing data, props become a mess and event emitting starts to look like spaghetti code.

That’s where Vuex steps in.

Install if you didn’t enable during setup:

npm install vuex@3

Create src/store/index.js:

import Vue from "vue";
import Vuex from "vuex";

Vue.use(Vuex);

export default new Vuex.Store({ state: { count: 0 }, getters: { getCount: state => state.count }, mutations: { INCREMENT(state) { state.count++ } }, actions: { incrementCount({ commit }) { commit("INCREMENT") } } });

Now use it in a component:
<template> <div> <p>{{ count }}</p> <button @click="incrementCount">Add</button> </div> </template>

<script> import { mapGetters, mapActions } from "vuex"; export default { computed: { ...mapGetters(["getCount"]), count() { return this.getCount } }, methods: { ...mapActions(["incrementCount"]) } }; </script>

Why Vuex matters:

Predictable state transitions
Debuggable via devtools
Scales to teams and large apps
Separation of concerns is clean

Learn more in the Vuex

vuex.vuejs.org

Step 6: Styling With TailwindCSS (Without Wrestling CSS)

Tailwind is perfect with Vue because it encourages component-driven styling.

Install:

npm install -D tailwindcss postcss autoprefixer npx tailwindcss init

In tailwind.config.js:

module.exports = { purge: ["./index.html", "./src/**/*.{vue,js}"], };

Create src/assets/tailwind.css:

@tailwind base; @tailwind components; @tailwind utilities;

Import in main.js:

import "@/assets/tailwind.css"

Use immediately:

<button class="bg-blue-600 text-white px-4 py-2 rounded shadow hover:bg-blue-700"> Click Me </button>

Tailwind makes UI iteration fast, consistent, and scalable without worrying about CSS conflicts.

Advanced Tips (That Make You a Real Vue Developer)

Use computed for anything derived from state. Don’t duplicate logic in multiple places.
Modularize Vuex when the app grows. Split store into modules.
Use watchers carefully. Watchers are useful, but if you're overusing them, it usually means your computed properties or mutations aren't structured right.

My Final Thoughts

Learning Vue isn’t just learning a framework, it’s learning how modern frontend works:

Reactive thinking
State-driven UI
Component-based architecture
Scalable styling and state management

Vue 2 gives you the solid foundation to transition effortlessly later to Vue 3, Nuxt, and more advanced patterns.

The Real Truth About Becoming a Cracked Frontend Engineer (Not Just a “React Developer”)

George Udonte — Fri, 21 Nov 2025 11:05:47 +0000

I see a lot of posts telling frontend developers to “learn React, learn Vue, learn Next.js.”

Cool.

But if you really want to become cracked — the kind of frontend engineer companies fight for — you need to understand the invisible layer of engineering that most developers never talk about.

Now clock this out:

1.Tools Don’t Make You Cracked — Mental Models Do

You can know React, Next.js, Vue.js… and still write code that collapses like a Jenga tower.

Cracked frontend engineers think in systems, not components.

Here are questions real seniors ask on every project:

What happens to performance at scale?
How predictable is state flow?
Can another dev debug this in 10 seconds?
How will this component behave with untrusted or malformed data?
If the API changes tomorrow, will this UI break silently or loudly?

The earlier you start thinking like this, the faster you grow.

2.UI Is More Than Pretty Pixels — It’s Applied Psychology

The frontend is the closest layer to the human brain.

Top frontend engineers understand:

Cognitive load
Interaction patterns
Decision latency
Microfeedback loops
Error recovery intuition
Accessibility that feels natural, not forced

You’re not just moving divs — you are engineering how humans experience software.

That skill alone can 10x your value.

3.State Management Will Make or Break You

Most devs think state management = Redux or Zustand.

No.

Cracked frontend engineers understand state architecture, not just tools.

Ask yourself:

When should state live at the component level?
When should it live globally?
How do you prevent “global state bloat”?
When do you cache or memoize?
Should UI fetch synchronously or optimistically?
How should you invalidate stale state?

This is why frontend feels harder than backend sometimes — the backend rarely deals with interactivity chaos at this scale.

4.Performance Is a Frontend Duty, Not a Backend Favor

Real frontend devs measure performance like backend engineers track database queries.

You should know:

Bundle splitting
React server components (RSC) behavior
Network waterfalls
Critical rendering path
Preloading & prefetching
Image optimization strategy
JavaScript execution cost (not just size)
Cumulative Layout Shift (CLS) killers
A fast UI is a business advantage, not a checkbox.

5.Debugging Is a Superpower — Treat It Like One

Juniors try random fixes.
Cracked Frontenders trace the root cause like forensic engineers.

To improve debugging:

Learn your browser devtools like your own home
Set breakpoints intentionally
Read call stacks cleanly
Understand event loops and microtasks
Know network failures vs logic failures
Learn how to catch race conditions (most devs can’t)

If you can fix what others can’t explain, you’re already senior.

6.Version Control Is Not “Git Add .”

If you want to stand out:

Write commit messages that actually explain intent
Use branches like you use toothbrushes — frequently and intentionally
Learn how to revert cleanly
Learn interactive rebasing
Protect your main branch like it’s your baby

Most issues in teams are not React issues — they’re bad Git hygiene.

7.The Secret Sauce: Build Boring, Predictable, Maintainable Apps

Cracked Frontenders understand that:

Flashy code impresses nobody
Maintainability impresses everyone
Predictable architecture saves companies millions

If your code requires a YouTube tutorial to understand, it's not cracked-level — it’s irresponsible.

8.Yes, Learn Backend… But Not for the Reasons You Think

Not to “be fullstack”.
Learn backend to:
Build better APIs through empathy
Stop blaming backend teams for slow responses
Structure your data flow properly
Understand authentication deeply
Avoid over-fetching and under-fetching

You don’t need to be backend-heavy.
You just need to understand the contract between UI ↔ API.

If you can master even 40% of this, you're already above 90% of the field.

Frontend is no longer “HTML/CSS + React.”

It’s:

Engineering
Psychology
Architecture
Systems thinking
Performance
Debugging
Design intuition
Product understanding

This is why frontend engineers who truly master the craft can comfortably earn 7–8 figures, as this linkedin post says.

Because great frontend engineers aren’t just coders —
They’re the bridge between humans and software.

Unleashing Developer Potential: Balancing Cognitive Load for Peak Productivity

George Udonte — Thu, 23 Oct 2025 09:50:10 +0000

Introduction

In the ever-evolving landscape of software development, engineers and teams are constantly challenged to bring their A-game to the table. One crucial factor that determines their effectiveness is cognitive load, the mental burden placed on individuals when they work. Striking the right balance of cognitive load can be the key to unlocking a team's full potential. Inspired by the Team Topologies framework, we delve into the three types of cognitive load and explore strategies to optimize each one for maximum productivity.

The Three Types of Cognitive Load

Intrinsic Load: Nurturing Technical Prowess
Intrinsic cognitive load refers to the mental effort required for tasks that are intrinsic to your work, primarily your technical skills. For example, understanding how classes are defined in Java or mastering the intricacies of a complex framework. While this load is necessary, it can become a barrier to productivity when it overwhelms engineers.

Scenario: Imagine a team tasked with developing a prototype. They can either choose to build it from scratch using a custom full-stack application or leverage a low-code tool to simplify the process. The latter option reduces the intrinsic load, allowing engineers to focus on the core functionality rather than getting bogged down by technical complexities.

Strategies for Reducing Intrinsic Load:

Make smart technology choices to simplify development.
Invest in team capabilities through training, pair programming, and strategic hiring.
Extraneous Load: Tackling Unnecessary Distractions
Extraneous cognitive load involves the mental burden associated with tasks that do not add value to the development process. These distractions can range from cumbersome bureaucratic processes to repetitive, time-wasting activities.

Scenario: Consider a scenario where developers frequently grapple with remembering how to deploy an application due to convoluted documentation or an outdated deployment process. This extraneous load distracts them from their primary goal—writing code and delivering value to users.

Strategies for Reducing Extraneous Load:

Streamline development processes and focus on developer experience (DX).
Foster a culture of continuous delivery to eliminate unnecessary bottlenecks.
Germane Load: Leveraging Domain Knowledge for Value Creation
Germane cognitive load is the holy grail of development. It encompasses the knowledge of your business domain and the specific problems you aim to solve. This type of load directly contributes to value creation.

Scenario: Picture a team working on an e-commerce platform. Their deep understanding of the domain allows them to make informed decisions about how to structure financial data for optimal performance. They can also implement best practices for an e-commerce checkout process, enhancing user satisfaction and revenue generation.

Strategies for Optimizing Germane Load:

Organize teams to apply domain knowledge effectively.
Minimize plumbing and non-business-related tasks, allowing engineers to focus on solving domain-specific problems.
Conclusion

In the world of software development, cognitive load management is an art that can elevate teams to new heights of productivity. By recognizing and addressing the three types of cognitive load—intrinsic, extraneous, and germane—engineers can unlock their true potential. Creating an environment where germane knowledge is maximized while intrinsic and extraneous loads are minimized is the path to success.

As software development continues to evolve, mastering the art of cognitive load management will be a hallmark of high-performing teams. By doing so, engineers can transform challenges into opportunities, creating innovative solutions that drive business success.

Decoding Developer Relations: A Comprehensive Guide to DevRel

George Udonte — Tue, 16 Jan 2024 10:15:28 +0000

Introduction:

A lot has evolved in tech, especially for software organizations. These days most tech businesses do not only have to build the tools/technologies that developers use, they also have to continuously build strong relationships with these developers in order to thrive.

Developer relations, often abbreviated as DevRel, is the strategic approach that organizations employ to engage with and empower developers, in order to foster a mutually beneficial ecosystem.

In this blog, we'll explore everything around Developer Relations.

Understanding Developer Relations:

What is Developer Relations?

Developer Relations, or DevRel, is the practice of building and maintaining relationships between developers and a company, product, or technology. It involves advocating for developers within an organization, serving as a middleman between technical teams and end-users.

Over the years, DevRel has grown into a multifaceted field that plays a pivotal role in bridging the gap between developers and the technologies, products, or services they use.

The Importance of DevRel:

A company must have a developer products, for it to need a Developer Relations person/team; otherwise it may just need a marketing team. DevRel itself is not just about marketing; it's about fostering a sense of community, providing support, and empowering developers to succeed with a particular technology or product. The stronger the developer community, the more vibrant and sustainable the ecosystem becomes.

DevRel is becoming increasingly important for businesses for several reasons:

Developer-driven innovation: Developers are at the forefront of innovation, and building strong relationships with them can help businesses stay ahead of the curve.
Open source adoption: Open source software is becoming increasingly popular, and DevRel plays a key role in helping companies get involved in open source communities and build a developer following.
Talent acquisition: DevRel can help companies attract and retain top talent by building a strong reputation as an employer of choice for developers.

Key Responsibilities in DevRel:

Developer Advocacy:
Developer Advocacy is at the core of DevRel. Advocates act as the voice of developers within the organization, promoting products, creating content, and ensuring that the needs and concerns of the developer community are heard and addressed.
Community Engagement:
Building and nurturing a thriving community is central to DevRel. This involves active participation in online forums, social media, conferences, and other events to connect with developers, share knowledge, and gather feedback.
Content Creation:
DevRel professionals often create diverse and valuable content such as blog posts, tutorials, videos, and documentation. This content serves as a resource for developers, helping them understand and utilize the technology or product effectively.

Essential Skills for Success in DevRel:

Communication Skills:
Effective communication is a cornerstone of DevRel. As a developer advocate you should be able to articulate complex technical concepts in a way that is understandable to various audiences, from beginners to experienced developers.
Technical Proficiency:
While it is not mandatory, a strong technical background is beneficial for DevRel professionals. It enables them to understand developers' challenges and contribute meaningfully to technical discussions.
Empathy:
Empathy is key to understanding and addressing the needs of developers. DevRel professionals should be able to put themselves in the shoes of their audience, recognizing the challenges and triumphs developers experience.

Types of DevRel Roles

There are a variety of DevRel roles, each with its own set of responsibilities:

Developer Advocate (DevAd): DevAds are the face of DevRel, responsible for evangelizing a company's products and technologies to developers. They often speak at conferences, write blog posts, and create tutorials.
Engineering Advocate: Engineering Advocates work closely with engineers to ensure that products are well-designed and easy to use for developers. They may also help with customer support and bug fixes.
Community Manager: Community Managers are responsible for fostering a vibrant community of developers around a company's products. They may organize meetups, manage online forums, and run developer events.
Content Creator: Content Creators produce educational materials, such as blog posts, tutorials, and webinars, to help developers learn about and use a company's products.

Strategies for Success in Developer Relations:

Building Trust:
Trust is the foundation of successful DevRel. Advocates must establish credibility by providing accurate information, addressing concerns transparently, and actively listening to the community.
Measuring Impact:
DevRel success is measurable. Metrics like developer engagement, community growth, and feedback collection provide tangible insights into the impact of advocacy efforts. These metrics guide future strategies and initiatives.
Balancing Advocacy and Corporate Interests:
DevRel professionals must strike a delicate balance between being a user advocate and representing the company's interests. This requires transparency and authenticity to build trust within the community.

New DevRel Trends:

Remote DevRel:
The rise of remote work has impacted DevRel, with advocates engaging with developers globally through virtual events, webinars, and online communities.
Inclusivity and Diversity:
DevRel is increasingly focused on promoting inclusivity and diversity within developer communities. Advocates work towards creating environments that welcome individuals of all backgrounds and experiences.
Evolving Technologies:
Keeping pace with technological advancements is crucial for DevRel professionals. Staying updated on industry trends enables advocates to provide relevant and timely information to the developer community.

Challenges in DevRel:

Technical Depth vs. Accessibility:
Finding the right balance between providing in-depth technical content and making it accessible to a broader audience can be challenging.
Scalability:
As communities grow, ensuring scalability in terms of support, resources, and engagement becomes a challenge that DevRel teams need to address.

Practical Approach to Become a DevRel Professional

To become a successful DevRel professional, one should have a good technical background and be passionate about software development. One should also be able to communicate effectively with both developers and non-technical audiences.
Some additional tips for becoming a DevRel professional:

Get involved in the developer community: Attend meetups, contribute to open source projects, and blog about your technical interests.
Develop your public speaking skills: Practice giving presentations and learn how to connect with your audience.
Build a strong online presence: Create a personal website and blog, and network with other DevRel professionals on social media.

Conclusion:

Developer Relations is an interesting and rewarding field that requires a combination of technical expertise, effective communication, and a genuine passion for fostering developer success. DevRel is a growing and exciting field that offers a unique opportunity to make a real impact on the software development community. If you're a passionate developer with strong communication and interpersonal skills, then DevRel may be the perfect career for you. By building strong relationships with developers, you can help your company succeed and make a positive impact in the software development space.

Emacs and Vim - A Basic Overview For Beginners in Software Engineering

George Udonte — Thu, 24 Feb 2022 12:06:23 +0000

Introduction

You've probably never heard of emacs or Vim, especially if you're just starting out your career in software engineering.

It is also normal that as a windows Operating System user, you've only been working with the notepad, notepad++, sublime text, visual studio code, and all other common text editors.

In the Linux operating system, Emacs and vi are the major editors that are used to manipulate files. Both are the major gladiators in the popular editor wars that started in the late 90s.

Nowadays, the hottest contenders in tech software are web browsers. Internet Explorer, Firefox, and Chrome are competing for a larger market in the figurative browser war.

Holy wars are also existing in every sphere of life, especially in pop culture: iPhone vs Android, Marvel vs DC, Coke vs Pepsi, and so on.

Text Editor Wars

The editor war is the rivalry between users of the Emacs and vi (now usually Vim, or more recently Neovim) text editors. The rivalry has become a lasting part of hacker culture and the free software community.

Since at least 1985, The Emacs versus vi debate was one of the original "holy wars" even before the internet. Many users insisted that their editor of choice is the paragon of editing perfection, and insulting the other. Similar tech battles have been fought over operating systems, programming languages, version control systems, and even source code indent style.

We are going to look at both editors and analyze their features and jargon.

Emacs

Emacs (Editor Macros) was developed by David A Moon in 1976 making it one of the oldest pieces of software which exists today. GNU Emacs, the most used variant(fork) of Emacs, was released in 1985 by Richard Stallman, the founder of GNU/Linux.

Emacs is a highly advanced, extensible, and customizable text editor that also offers an interpretation of the Lisp programming language at its core. Different extensions can be added to support text editing functionalities.

Emacs has the following features:

User documentation and tutorials
Syntax highlighting using colors even for plain text.
Unicode supports many natural languages.
Various extensions including mail and news, debugger interface, calendar, and many more.

You can find basic emac commands here

Vi(m)

Vim (Vi Improved), as the name suggests is an improved clone of the text editor. The text editor was originally developed by Billy Joy in 1976 for the proprietary Unix operating system. Bram Moolenar later enhanced vi and released it as vim in 1991.

Vim is a powerful command-line-based text editor that has enhanced the functionalities of the old Unix Vi text editor. It is one the most popular and widely used text editors among System Administrators and programmers that is why many users often refer to it as a programmer’s editor. It enables syntax highlighting when writing code or editing configuration files.

The UNIX vi editor is a full-screen editor and has two modes of operation:

Command mode commands which cause action to be taken on the file, and
Insert mode in which entered text is inserted into the file. In the command mode, every character typed is a command that does something to the text file being edited; a character typed in the command mode may even cause the vi editor to enter the insert mode.

In the insert mode, every character typed is added to the text in the file; pressing the (Escape) key turns off the Insert mode.

While there are several vi commands, just a handful of these is usually sufficient for beginning vi users.

You can find basic vi commands here

Vim is also used with Kubernetes for Developer Operations (devops) expecially the Certified Kubernetes Application Developer Exam

Similarities between Emacs and Vi

The buffer tabs are supported in both the command line and graphical user interface.
Cross-platform text editors, including Unix, Linux, and Microsoft Windows.
Available in English, Chinese, French, Italian, Polish, Russian, and even more languages.

Differences between Emacs and Vi

User Interface and Environment

Vim uses editing modes - most commonly the command mode and insert mode. Vim aims to minimize the number of keystrokes that a user has to press, because vi, upon which Vim is based, was designed to be used over slow terminals.

Emacs uses modifier keys to enable shortcuts, which often involves pressing several keys simultaneously for a single function. This aspect of Emacs is often criticized.

As computer technology developed, new advancements like the GUI (Graphical User Interface) were developed. Emacs adapted and developed its own GUI to make it easier for people to learn and use the editor. In comparison, Vi did not develop its own GUI. This is partly due to the appearance of Vi variants that took over.

A good example is Vi iMproved, also known as Vim, which gradually became more popular than Vi as it added more features and improvements that are not found in Vi. There are also variants of Emacs, but those have not caused the software to fall by the wayside.

Ease of Learning

Emacs is easier to learn since it has a more natural interface (for users familiar with GUI-based text editors). Since Vim has different editing modes, beginners find it a little harder to learn.

Productivity and Editing Speed

The main difference between the two is speed. Vi has historically been the faster of the two starting up in less time and is just generally the more responsive of the two.

Vim enthusiasts argue that once a user becomes familiar with the editing modes and commands of Vim, it enables far greater productivity and efficiency. File editing is usually faster with Vim than with Emacs because of Vim's purposely speed-driven interface. For example, cursor movement can be controlled through the H, J, K, and L keys in the normal mode. This means the user's hands do not need to leave the "home row" position, which improves efficiency but comes at the price of adding overhead as mode switching is required to choose between movement and text editing.

In Emacs (with the default configuration), the user moves the cursor with the Ctrl-B or Ctrl-F shortcuts, which might slow down the novice user since two keys need to be pressed. Productivity and efficiency improvements in Emacs depend upon the configuration of the editing environment rather than the editor itself.

RAM usage of Emacs vs Vim

Vi also takes up much less memory than Emacs; this is at a time when 8MB is considered to be a huge amount of RAM. Vim is lighter than Emacs and uses less memory. Vim advocates criticize Emacs' resource consumption with the tongue-in-cheek suggestion that Emacs stands for "Eighty Megabytes And Constantly Swapping".

However, with GNUclient, a single persistent Emacs process can be run that can support several clients simultaneously. This speeds startup time and decreases total memory usage, closing the gap between Emacs and Vim.

Extensibility and Customization of Emacs vs Vim

The advantage of Emacs over Vi is its extensive customizability. Emacs lets the user choose from a wide variety of macros to integrate into his workflow and reduce the effort needed in his process.

Vi lacks this level of customizability and relies on its simplistic and straightforward process. Emacs is also capable of emulating Vi in what they call “viper mode”; thereby making it easier for Vi users to use Emacs. Vi, with its simplicity, lacks such capabilities.

While both Vim and Emacs support plugins that enhance their functionality, Emacs supports a lot more customization of the editor environment. This is arguably the most important feature of emacs and is responsible for much of emacs' devoted following.

Emacs can be extended on the fly by redefining built-in elisp functions, either by typing the new definition into Emacs or by loading elisp files. Groups of related changes are called "modes" and can be easily configured to be automatically used for particular types of files (buffers). So it is easy to define modes for different programming languages or frameworks such as "lisp mode" or "Ruby on Rails mode" or "PHP mode". These modes can directly modify even core behaviors of Emacs, automatically format or colorize text and add standard template or "boilerplate" text such as function declarations and closures.

Programmers find Emacs to be far more customizable to their particular requirements than Vim. Yet some programmers may find Vim to ultimately be better suited to their programming environment due to its equally customizable and fully modal operation.

Emacs can be extended in elisp, while Vim has its own internal scripting language and supports the use of other programming languages for plugin development.

While Emacs can be extended in elisp, Vim has its own internal scripting language and supports the use of other programming languages for plugin development can also be extended on the fly by using the command mode. The command mode allows configuration options to be set, functions to be defined, and macros to be made. Configuration files for Vim are just commands that can be input through the command mode.

Graphical User Interface (GUI)

Both Vim and Emacs have graphical user interfaces. Virtually all menu items on the graphical interface for both editors are simply ways to handle a shortcut command or quick configuration. The GUIs for the editors do not provide virtually any additional functions beyond those available in the CLI (command-line interface)

Emacs uses XDisplay or gtk2 for its GUI. Vim can use many other GUI libraries, such as gtk, gnome, gnome2, motif, athena, and neXtaw, in addition to gtk2.

Summary

Vi is lighter and faster than Emacs.
Emacs is more customizable than Vi.
Emacs can emulate Vi but not the other way around.
Emacs later developed a GUI while Vi did not.
Emacs continued developing while Vi was succeeded by its variants.

Do we still have a war or a clear winner?

In 2020, Jake King the CEO of CMD decided to settle a long-time debate with his CTO Mike Sample, about which of the two editors is more popular in the Twitter tech space.

// Detect dark theme var iframe = document.getElementById('tweet-1245137819787382784-921'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1245137819787382784&theme=dark" } .

You should want to make some vim friends right now.

DEV Community: George Udonte

Crash Guide to Vue 2 in 2025 (Part 1)

The Real Truth About Becoming a Cracked Frontend Engineer (Not Just a “React Developer”)

Unleashing Developer Potential: Balancing Cognitive Load for Peak Productivity

Decoding Developer Relations: A Comprehensive Guide to DevRel

Introduction:

Understanding Developer Relations:

What is Developer Relations?

The Importance of DevRel:

Key Responsibilities in DevRel:

Essential Skills for Success in DevRel:

Types of DevRel Roles

Strategies for Success in Developer Relations:

New DevRel Trends:

Challenges in DevRel:

Practical Approach to Become a DevRel Professional

Conclusion:

Emacs and Vim - A Basic Overview For Beginners in Software Engineering

Introduction

Text Editor Wars

Emacs

Vi(m)

Similarities between Emacs and Vi

Differences between Emacs and Vi

Summary

Do we still have a war or a clear winner?

Further Readings