Suppose we have a large to-do task manager app with many features. Say we have an entity, which is the task, and it has certain fields like: title, description, deadline, sub-tasks, dependencies, etc. This entity is used in many parts of our codebase.
Suppose we decided to modify this entity, either by modifying, removing, or adding a field. We may have to change most if not all of the code that deals with this entity. How can we do this in a way that protects us from errors and makes maintenance easy?
Bear in mind, this is just an example. The entity may be something more low-key, such as a logged user event in analytics, or a backend API endpoint being used in the frontend, etc.
Potential Solutions
Searching
One way people do this already is by just searching the entity across the codebase. This is not scalable, and not always accurate. You may get a lot of false positives, and some parts of the code may use the entity without using it by name directly.
Importing
Defining the entity in one central place, and importing it everywhere it is used. This will create an error if a deleted field remains in use, but it will not help us when, say, adding a new field and making sure it is used properly everywhere the entity is being used
so what can be done to solve this? plus points if the approach is compatible with Functional Programming
Automated Tests and CICD
Tests can discover these types of issues with high accuracy and precision. The downside is… Well tests have to be written. This requires developers to be proactive, and writing and maintaining tests is non-trivial and needs expensive developer time. It is also quite easy and common to write bad tests that give false positives.
Most languages have an IDE which will manage the import of that object and when you rename incorrectly, it’ll flag it up. If you’re calling an incorrect function or variable, it’ll flag it etc. Many will have refactoring tools so when you rename something through this, it’ll rename all instances of that.
This is related to what I discussed in the “Searching” section. Entity fields may not be necessarily imported, so they would not be caught in this. Say you’re using that field’s name in a SQL query, HTTP or GraphQL request / query. This may also not be caught by IDE.
This also would not cover the case where a field is modified without necessarily changing its name, or a new field is added and now the code using that entity is not using the field.
Usually when you change your database structure, you would change the object that this is mapped into. If you were to change one without the other, that would be a monumental developer oversight. Adding a field without using it in many frameworks wouldn’t necessarily break it, so it wouldn’t be a bad change per se.
Any change you make to persistence should reflect as a bare minimum, the object data gets mapped into. This would likely be part of the same branch, and you probably shouldn’t merge it until it’s complete.
You’re looking for tooling to protect you from human errors, and nothing is going to do that. It’s like asking, how can I stop myself from choking when eating. You just know to chew. If this isn’t obvious, it’s a good lesson in development. Make one change at a time and make it right. Don’t rush off to presentation changes or logic changes until your persistence changes are complete. When you get into habits like this, it becomes steady, methodical and structured. Rushing is the best way to make mistakes and spend more time fixing them. Less haste, more speed.
For example, if I add a new field. I’d write the SQL, run it, populate a value, get that value and test it. Then I’d move on to the object mapping. I’d load it into the code, and get a bare minimum debug out to see it was loaded out, etc. etc… Small tweak, test and confirm, small change, test and confirm. Every step is validated so when it doesn’t work, you know why, you don’t guess.
You are not logged in. However you can subscribe from another Fediverse account, for example Lemmy or Mastodon. To do this, paste the following into the search field of your instance: !programming@programming.dev
Welcome to the main community in programming.dev! Feel free to post anything relating to programming here!
Cross posting is strongly encouraged in the instance. If you feel your post or another person’s post makes sense in another community cross post into it.
Hope you enjoy the instance!
Rules
Rules
Follow the programming.dev instance rules
Keep content related to programming in some way
If you’re posting long videos try to add in some form of tldr for those who don’t want to watch videos
Most languages have an IDE which will manage the import of that object and when you rename incorrectly, it’ll flag it up. If you’re calling an incorrect function or variable, it’ll flag it etc. Many will have refactoring tools so when you rename something through this, it’ll rename all instances of that.
This is related to what I discussed in the “Searching” section. Entity fields may not be necessarily imported, so they would not be caught in this. Say you’re using that field’s name in a SQL query, HTTP or GraphQL request / query. This may also not be caught by IDE.
This also would not cover the case where a field is modified without necessarily changing its name, or a new field is added and now the code using that entity is not using the field.
Usually when you change your database structure, you would change the object that this is mapped into. If you were to change one without the other, that would be a monumental developer oversight. Adding a field without using it in many frameworks wouldn’t necessarily break it, so it wouldn’t be a bad change per se.
Any change you make to persistence should reflect as a bare minimum, the object data gets mapped into. This would likely be part of the same branch, and you probably shouldn’t merge it until it’s complete.
You’re looking for tooling to protect you from human errors, and nothing is going to do that. It’s like asking, how can I stop myself from choking when eating. You just know to chew. If this isn’t obvious, it’s a good lesson in development. Make one change at a time and make it right. Don’t rush off to presentation changes or logic changes until your persistence changes are complete. When you get into habits like this, it becomes steady, methodical and structured. Rushing is the best way to make mistakes and spend more time fixing them. Less haste, more speed.
For example, if I add a new field. I’d write the SQL, run it, populate a value, get that value and test it. Then I’d move on to the object mapping. I’d load it into the code, and get a bare minimum debug out to see it was loaded out, etc. etc… Small tweak, test and confirm, small change, test and confirm. Every step is validated so when it doesn’t work, you know why, you don’t guess.