Programming languages divide their types mainly into two categories.
- Primitive types (A built-in types like string, boolean, int, decimal…)
- Objects (class/function): User-defined types using class-based/prototype-based objects.
A primitive data type is a data type for which the programming language provides built-in support. Example: number, string, boolean, date and so on.
There are situations when developers should represent their idea/concept using user-defined types (Abstraction or encapsulation).
Whereas they choose to use primitive types (inbuilt int, string…) to represents the concept.
“Talk is cheap. Show me the code.” ― Linus Torvalds
Consider the above API for scheduling meetup.
If you observe carefully, all the parameters: topic, description, date, location id, and max participants when they stand together represent the concept/idea called meetup.
Almost all the data types are primitive types (Built-in types: string, int, DateTime and so on).
Overutilization of these primitive types to solve a problem makes the code more verbose/procedural and logic to deal with them is scattered.
Since all method parameter stands together to represent the concept called Meetup.
Here, we could group all these parameters together to represent the idea/concept called meetup. So, introduce an object to gather these data values.
Upon replacing data values with an object API would look like:
This is how the API should have been. However, the developer chooses to go with all built-in types (segregated). IMO, this overutilization of primitive types in almost all cases can be treated as an obsession about primitives which can be called a primitive obsession.
I have explained only one scenario and there are other scenarios too.