On naming things that start with the letter E
Most people don't think about naming conventions until they hit a problem. I've been dealing with this for years, and the issues tend to surface in weird places. Here's what you need to know about choosing a name that starts with the letter E.
Why nome que começa com a letra e matters more than you think
There's a specific cluster of conflicts that show up when everything in your project starts with E. It's not a coincidence that this creates problems. Let me explain why this is a real issue and then walk through how to handle it. When I was working on a parser library a few years back, I named nearly every entity class starting with E. Entity, Expression, Element, Event, Error... that's five separate classes in one namespace, and they all collided with common abbreviations like eval(), env(), and exec() in JavaScript environments. The real headache started when I tried to integrate with an existing API that used the same prefix internally. I spent about three weeks untangling naming conflicts across module boundaries, and the solution was essentially: pick a consistent prefixing strategy, document it, and stick to it without overthinking it.
The counter-intuitive thing here is that being too systematic about your naming actually makes things worse, not better. A random mix of naming styles can sometimes be easier to debug because each name stands out visually. When everything follows the same pattern, your brain starts auto-skipping over entire groups of identifiers during code review.
👉 Clique no botão abaixo para saber mais sobre o assunto!
How to actually implement this
Start by listing every concept in your project that needs a name. Go through them and assign a consistent initial letter. Then check for collisions with built-in functions, common abbreviations, and language keywords. This usually takes about 20 minutes for a small project and maybe an hour for something larger. The alternative is fixing it later, which typically takes about ten times longer. I use a simple checklist: does the name conflict with any standard library function? Does it create ambiguity when abbreviated? Is it distinguishable from similar names at a glance? If you answer yes to any of those, rename it before you commit.
Common mistakes people make
The biggest one is not checking your names against the runtime environment. A name might look fine in isolation but collide with something in the JavaScript global scope or a framework's internal naming. I learned this the hard way when a perfectly reasonable name like "Entry" conflicted with an AngularJS service. Another mistake is assuming that longer names solve the collision problem. They don't. A name like "ExpressionEvaluator" sounds more unique but it's still immediately recognizable as starting with E and will cause the same pattern-recognition blindness I mentioned earlier.
When this approach doesn't work
If you're working in a team where everyone has their own naming preferences, no amount of guidelines will stop them from creating conflicts. In that scenario, the only reliable workaround is an automated linter rule that enforces a naming convention at the tool level rather than relying on human compliance. This cuts down the time spent in code review catching naming issues from about 15 minutes per PR to roughly zero, since the linter just fails the build. The downside of using a linter is that it adds friction for onboarding new people who have never seen these rules before. Budget an extra half-day of explanation when you introduce this to a team.
If none of the above fits your situation, consider using a different initial letter altogether. Sometimes the simplest solution is just picking something less loaded, like naming conventions that start with T or C, which tend to have fewer collisions with common abbreviations and framework internals.
