Motivation
All programing principles and paradigms aim to enhance code readability and maintainability, from OOP to functional, SOLID, DRY, YAGNI, KISS and design patterns all these main purpose is to write clean and maintainable code for long life software, as a software by nature will keep evolve and change, so all these concepts help us to make our software flexible and easy to change.
Boost readability and maintainability
One of most popular code smell is if-else chain or code branching, of course you can't develop a software without if-else but heavily using to harms your code and in order to eliminate/reduce multiple is-else chain there are some tactics you can do to avoid this code smell.
Fail early mechanism
This mechanism works by validate violation first and terminate if any violation happen, instead of checking for right values and terminate if not as below
Flat-Chain mechanism
This mechanism works by repeating your conditions over if statements to avoid branching in your code and this approach favoring readability over performance if code may be need a lot of changes in future
Use polymorphism
If you have multiple operations and you need to fire specific one depending on specific condition, you can encapsulate creation of these operations into one single class(Factory) and delegate the determination of what operations fit for this criteria to one isolated place and make your code more readable and this make code strict to open-closed principle.
Predicate-Action mechanism
You can apply this mechanism by using a Map or List of Pairs one side is a predicate(condition) and the other side is the action you want to fire if the predicate success and by iterating over this pairs you can achieve your conditional logic in better way
Use State design pattern
By using this you first define your states as below
Then implementing each state and which state currently now and which state you are allowing to return from current one.
Then use the states with your object
IF YOU LIKED THE POST, THEN YOU CAN BUY ME A COFFEE, THANKS IN ADVANCE.
Top comments (27)
Agree with all your points.
Language specific, but in Kotlin the
when
expression is a massive improvment over if/elseYes, good tip but i don't use Kotlin that much, it's language specific but the idea is to make code more readable.
I wonder what other languages have a similarly good structure.
Not like switch case which don't return anything, something better.
Probably functional languages in general?
Like switch expressions for Java v12 have a look
indeed yes, I didn't know they can return a value
Rust has a nice match statement too, even though it is not functional.
I believe it is something that most functional language have and newer languages are starting to adopt it.
Almost every modern language have pattern matching.
In computer science, pattern matching is the act of checking a given sequence of tokens for the presence of the constituents of some pattern. In contrast to pattern recognition, the match usually has to be exact: "either it will or will not be a match." The patterns generally have the form of either sequences or tree structures. Uses of pattern matching include outputting the locations of a pattern within a token sequence, to output some component of the matched pattern, and to substitute the matching pattern with some other token sequence.
The techniques above are called pattern matching. I wrote an article about it here:
dev.to/n1ckdm/pattern-matching-dec...
Really good article thanks
Not that Kotlin when is not true pattern matching found in more fiftieth languages, it's a better switch case. Combined with static types and algebraic types it's 80% of that though
Newer versions of PHP have
match
.Just a heads up that the Markdown we use here supports syntax highlighting, and is generally more accessible than inserting an image of code. Images of text are an issue for people using screen readers, for example, and their content won't get picked up by the site's search facility.
You can add code blocks with 3 backticks: More details in our editor guide!
Thanks! , great idea
I would say be aware of polymorphism. It's not wrong, but not the only concept.
The principle composition over inheritance is often a better choice, because you don't couple classes with an inheritance structure.
Sometimes it's a great mix to use inheritance for the structure and composition for the logic.
i.e. prefer interface inheritance (
implements
; for polymorphism) over implementation inheritance (extends
).The original quote (GoF, 1994, p.20):
talks about implementation inheritance.
Actually, we talked about this principle here Composition vs Inheritance, take a look π
Good post.
Just to add something, there is another possible iteration when you have a set of fixed conditions (like the
switch
), for large number of options a map is a better and more readable approach.I am SOOOO HAPPY to see your article. For once it's "how to do it better" and not "omigosh, you should NEVER nest if-s, here's why". Glad to see people who don't clickbait.
Your comment made me happy also π,
You can follow me for more amazing content, and stay tuned π
Such humility too, hahahaha! π
πππ
nice
Great read π―
This is a good tip
amazing post !
In the Fail early, the final result of your change is not the same.
Because it should fail at a negative price or a discount equal or higher than 50.
Yeah, but it just example that helps illustrate the idea not more