Should I create different classes for the same technical object but different business usages

There's a better option.

You want to separate shop tags from customer tags and you struggle with the fact that they are both just tags. Then why not add another property to tag for differentiation?

In addition to id and name you could introduce type, which is of type TagType. Then create an enum TagType with members Shop and Customer.

or keep a common Tag class despite it has no business sense?

Does not refer to the same business reality

Not all code directly translates to or stems from a business need. If a common class makes sense for a particular code design, then there's nothing wrong with using it. Assuming the design itself is appropriate of course.

Since those two type of tags can never be interchanged (John cannot be made of bricks)

But can you state for a fact that there will never be a tag which may overlap? It's easy to gloss over possible future tags that overlap if your current ones simply happen to not overlap.

should I create two child-classes with all properties deriving from a base Tag class like ShopTag and CustomerTag or keep a common Tag

It very much depends on several points:

• Is there a direct need to enforce validation here instead of relying on the tag creators to do the right thing?

Take StackExchange for an example. I can tag my question however I like, the sytem does not block it in any way. But there is an implicit expectation that the users will sanitize any bad entries that may occur.

Trying to write an algorithm to do so takes a lot of effort and there can be a lot of false positives and negatives, so the effort is not worth it. The same can apply to your case, you haven't really shown any reason to want to actively enforce this other than "I could do it".

• Are you going to expect tag creators to always know in advance which entity a tag describes?

Even though it makes sense to you, it might not make sense to end users to categorize tags like this. You're still going to rely on your tag creators to categorize tags correctly - so why can't you then just rely on these users to apply tags with the same level of correctness?

• Will there never be any overlap between entities that a tag might apply to?
  • or if there is, how do you expect to handle that case?

If you need to start handling overlap, it's going to get really hard, because you're going to have to design a validation system that is really complex to develop, and really complex to wield by your tag creators.

That being said, there is a range of options you could take here:

• Let the users manage their own content
• Create an enum type (TagType) and give the Tag class a property of that enum type.
• Make specific Tag classes for each type and use inheritance of a generic base class to specify which tag type a certain object uses.
• Store these tags in different tables and give each entity a FK (albeit with a cross table due to many-to-many) to their specific tag table.

You haven't really shown why you need to have this enforced/validated. Without a direct need, I suggest you err on the side of not writing something you don't know you need yet.

Some direct feedback to your question:

Prevents other developpers to mix them up later on

Wait, is it developers who are using specific tags, or end users? Because tags tend to be a sort of "free form categories" used by end users to sort their data.

If specific tags are a developer concern, then these specific tags are effectively a constant in the codebase? I mean that regardless of where the data is stored, your code expects certain tags to exist - these cannot be created or deleted by end users after release?

Improves readability

That's highly arguable. More complexity detracts from readability. Since you haven't expressed why you need this, it's unclear whether it's going to add or detract from the readability.

Comes from different databases, I have no control on that point (should I take that in consideration?)

Do these databases live independent lives? If one database changes its tags (let's say tag names now come as a list of translations), does that mean the other might not receive the same update?

If they are deployed and versioned independently, then you're always going to need separate classes, even if these tags could be freely mixed.

Whether you then still use a base class very much depends on whether you expect to have code that can operate on either entity without needing to know its specific type (nor the specific type of its tags).

This seems like a good use case for a generic type. You can define a type Tag<T>, and then where relevant code that deals with tags depend specifically on Tag<Shop> or Tag<Customer>, without you needing to create those two separate classes.

It's easier to lump splits than to split lumps. There are at least two different possibilities for the future evolution of this code:

1. The tags stay split apart forever
2. The tags need to be merged.

If they are separate, then in case 1, you're happy since nothing needs to be done. In case 2, you can just rename ont of the two tags, say ShopTag to Tag, remove the declaration of the other one (CustomerTag( and replace the usages of them with Tag.

If they are joined together then while you are happy in case 2, in case 1 you will have to examine every place the single tag type is being used to figure out which tag type it should be in that case.

If the code for a tag is simple enough, I would suggest actually having two versions that do not depend on each other, (say if they just both held a string). If there is enough code you become worried about the two types going out of sync, then you could pull out shared static methods that operate on their members, which each type will delegate to.

Static methods are just the simplest option. If there are enough members you get tired of passing them all to static methods, you can wrap those members in an inner class, which could resemble the abstract base class in your initial example. If you find your self passing these members to many different complicated methods that don't make sense to be static, then it may make sense to have an ITag interface that both types can implement, so the methods can be non-static.

Never say never. Unless it’s impossible.

I could very easily imagine that your system, may one day manage Purchase of those customers in those shops. What bout the new PurchaseTag? Should it be yet another independent transaction related tag entered by the user? Or could it be automatically assigned by the system for example based on the most expensive product chosen, or the most used shop tag searched by the user online in the month preceding the purchase? In the latter case some overlaps would be needed, without putting in question the overall design

A never-assumption very often appears to be a not-now-statement. When you make important design decisions you should therefore carefully ask “what if”, just to be sure that you won’t regret that decision later.

Keep your design open and future friendly: Don’t close doors if you don’t have to. Your abstract class is in this regard a wise choice:

• in the end, a tag is a tag (this is not likely to change)
• at the same time, it allows some differences/specialization (open for extension)
• and generic code written for the tag parent will (at least if LSP is ensured) work with all future kind of tags not yet invented.

But what about behavior and separation of concerns?

The only thing that bothers me is that we did not mention at all any behaviors. A class is not just a wild aggregation of values.

The question is therefore to know if the shop and customer tags only differ by the values they can take (value space) or also by their behavior.

If it’s only about the value-space, I’d consider another approach:

• Keep the tags general: Use Martin’s approach to implement a qualified tag: each tag is associated with an identifier telling what the tag is about.
• specialize the context where the tag is used and in particular its containers.

In my view, this approach would implement a better separation of concerns: the tag class is focused on the tags themselves, and the responsibility for using the right tags is moved to another class.

This would allow you a higher degree of freedom to innovate by specializing tags according to their own nature (e.g. single language tags as now, multilingual tags, graphical tags, voice tags, ...) and at the same time ensure through the tag context (for example using dependency injection for the factory and selection of the right subset of tags in the tag repository) and the tag containers, or a tag policy, that no mistakes can be made in assignments.