Blog RefWyWen = new Blog(); //This blog is about refactoring: why and when should be done?.

These days I'm enjoying reading "Clean Code: A Handbook of Agile Sofware Craftsmanship " by Robert C. Martin, which I recommend any software developer to read because it makes me feel smart and dump at the same time! smart when I shout: That what I always think how code must be written! and dump when seen my code is messy as hell!

So here I will try to summarize what I find the "two" most common mistakes that we as software engineers fall into most the time by noticing my Smart/Dump moments, and those mistakes not only brings more bugs to our code but also makes the code harder to maintain to fix those bugs.

First Mistake: Naming wrongly!

The book starts with the following image:


which makes me really thinking: "what makes me say WTF while reading a code?" and I notice my self saying that -even on my own code- on two scenarios:

Names!

Reading the name of a class, variable, method ... etc, that is shorted in a way that lost its meaning or reading a name that has no relation with what that code element is nor containing nor doing!
So it's so critical to name properly, and the book gave a bit of good advice on dealing with naming: Names should be pronounceable, could be said loudly and searchable, and the most important thing is it relevant.

Examples:

Variables and Objects:
naming an object as notiSrv is hard to understand or read for anyone how doesn't write the code, but name it as notificationService is better because it is searchable and pronounceable and making sense.
the only role for naming an object and non-boolean variables, that it should be none, not a verb like notificationBuild this is even hard to understand its type.
 For boolean I recommend naming to be a question like isPageLoaded or PasswordIsValid, Therefore, it could be answered using yes or no (true or false).

Functions:
The function name should be a verb, showing the action that this function is doing, what it should handle and when (by when I mean which event or in which situation).
Therefore, RegULDT() is confusing name, and no one even the one who wrote it can understand what this function is doing, and you will be surprised by knowing this function should register login date and time for a user, and it is better to be LoginTimestamping().

Therefore, clear naming will reduce comments that describe your code, because the code will describe itself.


Since we already mentioned functions, we will move to my next "WTF shouting" scenario which is:

Long Nested functions:


Long Nested functions, the book advice to make small functions, and even that small function should be smaller! that makes code editing easier and clear, even reading code will be faster, and walks you step by step to its logic.

Example:


I had this constructor on app.component.ts for an Ionic app that I'm working on, it doesn't have that much code but it was confusing:


And it had been changed to be something like this:

and that's it!

Comments

Post a Comment

Popular posts from this blog

How to Automatically deploy Configuration Files with Azure DevOps CD pipelines

Introduction Part of the CI/CD Automation is to add environment-related configuration files through deployment automatically, rather than manually uploading them. This will provide less human error and more security by splitting the developer's responsibility of knowing the environment configuration or editing it, as to be handled by Operation side. We will take an example of CI for DotNet Core 6 WebApi project, and on that project, we need to copy the related appsetting.json to its environment. Pre-Requested Knowledge: To benefit from this article you need to be familiar with the following:  Azure DevOps. the Concept of CI/CD. Azure CI/CD Pipelines. DotNet Core Web Api Deployment (or similar). Adding From Source Code Branch In some cases, we will have configuration files included in our source code, for example, in
Read more

Adding Multiple DB Contexts in your DotNet Project

Introduction  In this article we will discuss adding multiple DB contexts to our DotNet projects, we will use EF core as our ORM to make a "Code First Database" approach.  In this article example, we will use DotNet 7 connecting to SQL Server through EF Core 7, all of this will be in a web API project to see how to define those DB contexts as services in program.cs  file.  You can download the example source code from here .  Why would we need multiple DB Contexts in our Solution?  There are two situations where you need multiple DB Context in your project or Solution:  We have a single database but need multiple  schemas in our database, and each scheme will have a group of entities.  We have Multiple databases and our project needs to connect them to do its operations.  We will take the first situation as our code example. Creating Our models Let's assume we have a simple solution that manages the cust
Read more

Adapting a New Technology: A General Guide to keep Your Systems up-to-date

Image
Special Thanks to [Mohamed Othman](https://www.linkedin.com/in/mohammad-othman-55351b20b/) for his help in editing this blog. ## Introduction If you are generally working in the technology sector and specifically in the software industry, you will be under stress by the number of new things that are coming up every day. New stuff can be a new integration technology, a new framework, a language version upgrade, or even a new library that helps you to do specific tasks in your code. In this article we will refer to those as: "new Tech". And if you are like me, you will feel messed up if you don't know or know how to use the new trend! So here, I will list some tips and tricks, along with best practices for keeping your projects up-to-date. **Note**: the tips in this article for when and how to implement the new technology in your daily working projects are not concerned about keeping your knowledge up to date, knowing things and doing them are two different t
Read more