It’s a symptom of a general lack of respect and lack of desire to collaborate with one another. Compared to real problems you’ll face in trying to communicate and collaborate towards a goal, it’s a miniscule level of effort required to get on the same page with what things are called and then roughly stick to it going forward.

Is the difference in naming going to make a difference? Maybe. The little extra bit of cognitive load and confusion that can result may or may not hurt, although it definitely won’t help. How about the lack of shared desire to put in the effort that it takes to operate as a cohesive unit; is that going to make a difference? Yes, yes, a thousand times yes.

It may or may not be something worth stressing over or trying to fix on your end (sometimes it just be that way), but it’s definitely not unimportant.

You’re not wrong to be bothered. Consistent naming is necessary for clear communication, especially since there is often so much abstraction in our line of work.

It does become difficult though when working cross-team or cross-service, because there may be overlap in terminology. You just have to do your best. In these situations, sometimes it helps to create a sort-of “glossary” for reference when needed.

I think I’ve learned to get less attached to opinionated terminology in code and database design because I see it happen all the time where the usage of the value/field/thing can evolve naturally over time as the business needs evolve. And refactoring field names (as an example) from UI to database is often a painful exercise, not without significant regression risks. (Depending on the size and complexity of your systems, of course)

So while I totally agree with you and others that ideally naming would be consistent throughout, my real world experience with the issue has taught me that this isn’t the hill I die on.

My 2 cents from 10 years experience in the industry.

Yes, that is the single most important lesson from DDD.

If you work in a large place, naming coherence (that comes from conceptual coherence) is one of the most impactful things for you effectiveness. It will save you from writing useless software, from surprise requirements changes, it will increase the target public of any software you create, and so on.

The problem is that you just won’t get it. There is no task or process you can do that leads you there. What you can do is improve it here or there, a little bit, at great cost. So, I’d say, do insist on it, but pick your battles. You can’t really win, so if you focus on it you will burn yourself and your image out.

you’re right, bro. It’s not just about naming consistency; understandable naming, not gibberish, is also very important. That is the key to precise communication. In my company, we are not allowed to use abbreviations to avoid causing any misunderstandings.

Is having a consistent domain language across the board important? Yes, obviously it’s a huge benefit in communication and in maintainability.

Is not following that convention, in and of itself, a huge problem? Probably not, so long as the primary parties understand the differences between separate aspects (such as the database using a different word order), although the documentation needs to explain this.

Is not being able to get an agreement on a consistent domain language that everyone will follow a problem for development? Yes. Huge. Crippling. It reeks of poor, indecisive management at the top project level, and petty interdepartmental squabbling all the way down. It’s a huge red flag as to a company’s ability to deliver. It’s not that difficult a thing to get agreement on or to enforce, as it’s entirely visible. If a project can’t do that, it’s not going to be able to do the things that are actually difficult.

Consistency is very important espcially later on. When the user or client is talking about X and it’s called Z in the Database and Y in the code this will cause so much confusion. I think the fact you care means you are good programmer. Don’t loose that.

I build software that is used by nearly all engineers in our company. We own hundreds of web applications and websites. We’ve grown by acquisition of smaller companies, and we have an extremely heterogenous environment.

25 years ago, I started my career as a web designer. Today, I’m a Principal Cloud and Platform Engineer. Still to this day, I regularly leverage lessons when building tech that I learned from the world of UX.

“Design is not how it looks. Design is how it works.” — Steve Jobs

Naming consistency helps to reduce the mental friction that people have when learning how something works. For example, one my projects is a suite of Terraform modules that are designed as building blocks which cover all of the fundamental pieces of any app’s stack. We have designed these 20-ish modules to work well standalone, as well as when used together. Certain patterns are the same across the board.

(1) We strongly favor dependency injection, and limit the use of ternary statements. In the world of Terraform, this is via variables or a .tfvars file. Everyone knows that this is how it works, so it reduces the mental friction when adopting a new/additional module.

(2) Variable names which do the same thing are named identically across all modules. Their descriptions are identical. For example, tags = [k:v] works exactly the same way across all modules, and people don’t have to think about it.

(3) Modules have a naming pattern. Among other things, they begin with the name of the service that the module talks to. (If we find that we’re talking to multiple services, we need to break the module down into smaller chunks.) So aws- or newrelic- or datadog- or github- or pagerduty- are all examples.

This overall “design” has not only helped reduce mental friction and made the modules easier to understand and use, but it also makes them easier to manage across hundreds of repositories supporting hundreds of apps. Collaboration, cooperation, and communication are all improved as a result. And if something is difficult to understand, then it means that we screwed up. We need to do a better job listening to the app-engineering teams and SREs who support them to streamline and clarify as much as possible.

“Customers” come in all sorts of shapes and forms.

Anything to do with naming is going to be doomed to bike shedding (https://en.wikipedia.org/wiki/Law_of_triviality). The only way to avoid the kind of problem you mention is to have one person come up with all the naming rules and to enforce it.

You’re right to think it’s important because it’ll make maintenance significantly easier than having 3-4 disparate naming schemes. However, there’s no way that you can get a group of people to agree on a single naming scheme. Everyone will have their own idea which will make complete sense to them but to no one else, and they’ll argue for hours about this. There’s no easy solution, even though it should be trivial.

It is warranted, and your colleagues seem to agree.

and other people on the team will almost always agree that it’s a good idea and will happily accept my PRs

I think you may be misinterpreting what is happening.

Them not taking initiative does not correlate to its importance. It’s just that most people don’t take initiative - or at least here, evidently, for naming consistency.

How much of an issue ambiguous naming is or may become depends on context - on a lot of things. But ambiguity in naming, just like elsewhere, weakens certainty and reasonability. If you can define and keep clear terminology, then always do so.

We recently had this issue at work with the term tenants.

We had tenants as in guests, tenants as in multi tenant backend and aad tenants.

It was beginning to get very confusing when talking about them so we sat down and came up with a list of terms we all agreed on.

I think it really depends on how the company is organised and who is working closely together as to whether it makes a big difference.

Different teams can use different names as long as they know what the others are meaning.