DEV Community: Sameh Muhammed

TDD V.S BDD

Sameh Muhammed — Sun, 04 Dec 2022 18:39:05 +0000

Introduction

We talked Here about how important unit testing is in the software development process, and benefits you got from writing unit tests, but here we are comparing between two methodologies which are TDD and BDD

Test Driven Development (TDD)

Test driven development is a methodology that aims on writing the test cases of any piece of code before you go ahead and implement it, after that you write the logic and cover the test cases you wrote before (a.k.a red/green methodology), and so on.. By this you are covering all your logic with safety net that will save your back in case any upcoming changes that may break your code, and the quality of your code here is measured by how much percentage you cover from code with unit tests and based on that your code can be pass or fail on automated pipeline.

The Gap with TDD

We all agree on that the TDD has a lot of advantages that make you follow this methodology while you are developing your product, but on the other hand no matter how much your test cases cover from your logic, there is no guarantee that combining these covered pieces of logic will deliver the desired functionality. Yes each piece of logic does its' job perfectly, but still have no guarantee, and in real software development you don't deliver code, you deliver functionalities/features that what real matters.

Behavioural Driven Development (BDD)

Behavioural driven development is a new methodology that aims on test too, but not at the the level of methods or piece of code but at the level of functionality/feature, which you are writing what you expect from this feature to deliver to user and cover all scenarios that have this feature to do, then implementing the logic that perform this feature. By this you are protecting the most important part of the software. Its' features.

BDD with Cucumber Framework

Cucumber is a framework that enables the BDD methodology by giving the ability to write a software features in some script files called feature file as below and locate these files with source code.

What empowers these files that its' format follow almost the Agile user story format which makes reading and writing them easy even for non-technical persons like scrum masters and product managers and making them more engaged with development process and code.

Then the developer can take these feature files and start implementing the logic based on them as below example with Java.

By making the predicates more general you can get benefit from reusing them and reduce the amount of code to cover the scenarios.

There are multiple frameworks beside Cucumber to enable BDD methodology. more details in Resource section

At the End!

Both two methodologies has its' own benefits, and to get the most safety for our product we should combine both of them, there is no benefit from having 100% unit test coverage, not all pieces of logic have to be covered by unit test, but we can use unit test to cover the most important functions that has a critical job to do and we can cover the rest of code by BDD.

Resources

IF YOU LIKED THE POST, THEN YOU CAN SUPPPORT SUCH CONTENT WITH A CUP OF COFFEE, THANKS IN ADVANCE.

A closer look to docker

Sameh Muhammed — Thu, 17 Nov 2022 10:29:53 +0000

Motivation

In early years of software development process regarding to deploy software on multiple machines you have to repeat deployment steps for every machine you have, Then the need of isolating applications with it’s own dependencies and libraries to be compatible with versions and reduce the overhead of repeating this work on multiple machines/servers came up.

One step ahead, Virtual Machine

VM is a guest Operating System can be run on top of another OS on same hardware and sharing physical components and resources of that machine by using a middle ware the helping in sharing resources operation.

Virtual Machine Pros & Cons

Pros
● Portable
● Less hardware cost
● Supports legacy operating systems

Cons
● Consuming resource
● Less performance

Another step ahead, Containers (Docker)

Docker is a software creates isolated containers that hold a software with it’s own libraries that can be run on any OS and can be transferred from machine to another through docker images.

Docker Components

Docker client

Docker client is responsible for taking the commands from user like (docker ps, docker images) and talk to docker server to execute the command.

Docker Server

Docker server also known as Docker daemon responsible for running the commands that come from docker client like listing the images, run container and so on..

Docker Host

Docker host is the host operating system for docker which docker uses to share it’s resources with containers.

Docker Image

A read-only and sharable set of files that are compiles to create one or more container.

Docker Container

Is a writable instance of image and each container has it’s own file system layer.

Docker Repository

It’s a repository of docker images you can deal with it as git repository review your images add tags to your updates and so on.

Docker Registry

A place responsible for providing docker images, that users can upload and download images like docker hub, thus you don't need to install any software from scratch and handle its' configuration, just pull the image and run the container.

Docker components interaction

Docker container holds a process

Each docker container has a process that starts when you execute docker run command, When this process is finished the container stopped and as much as process is running container will be working as well.

How Docker containers run among any OS?

First of all, any docker image is already built on top of Linux OS and that the common in docker world, so when the container runs on Linux system this OS will be docker host directly, Then the container can use up to 100% of machine resources.

On the other hand when we use Docker on top of Mac or Windows, there is software called Docker Desktop you have to install, this application installs internally a small version of Linux OS and this will be the Docker Host and also docker desktop allow you to manage how much resources can docker take for containers.

Long short story: You always run containers based on Linux OS

Note: there is a windows based images also but it’s not common to use.

IF YOU LIKED THE POST, THEN YOU CAN SUPPPORT SUCH CONTENT WITH A CUP OF COFFEE, THANKS IN ADVANCE.

About DB Transaction and Spring @Transactional

Sameh Muhammed — Sat, 12 Nov 2022 14:05:59 +0000

What is database Transaction?

Database transaction is a group of SQL statements that have to either success all or fail all, So that we can guarantee data consistency, As below image any break in the middle of these SQL statements will cause data inconsistency.

So you have to run these as a transaction, If any failure happen it will rollback all the changes and this provide Atomicity concept therefore transaction can not be divided (Any persistence tool have to provide Atomicity, Consistency, Isolation, Durability properties to it's system)

So, What about Spring @Transactional annotation?

When you are using Spring Data JPA, you are using CrudRepository implementation that Spring gives you out of the box which build on top Hibernate framework which uses EntityManager class to deal with your database.
As EntityManager class, Any communication with database have to be done throw transaction as below example

And for reducing any boilerplate code regarding to begin transaction and commit it or rollback, Spring added @Transactionl annotation so that any method annotated with this will guarantee a lot of things mainly now beginning DB transaction and providing Atomicity to your logic.

But you may wondering about using JPA repositories in methods without adding @Transactional and it works, Yes you are right because JPA methods (save() , findById(id) .. ) their implementation already annotated with @Transactional which taking care of creating DB transaction if not exists.

Additionally, JPA methods like (save() , saveAll()) not perform any commit statements instead they just change the entity state in Persistence Context (EntityManager class), Then when transaction ends it performs flush operation that writes the records into DB then when closing the session commit statement is fired.

As a result, when you are using many JPA methods in one business logic method without @Transactional that means each JPA method will open it's own DB transaction and close it after finish, Therefore using JPA save() in loop may cause performance issue regarding to multiple open/close for transactions, In this case using saveAll() will be better.

@Transactionl 's propagation property

@Trasnactional have propagation property with REQUIRED value as default which means in case of no transaction found start one, if there is one already found use it, So when using @Transactionl on your methods or services any inner JPA methods will use same transaction to deal with DB instead of creating one for each method.

There is more about propagation property and isolation as well, you can get more information resource section

@Transactional read-only property

At end of each transaction hibernate framework needs to know if it should fire any insert/update statements or not, So it fires dirty checking operation so it can know if there any entity changed and fire statement for it, so in case you have a methods with just retrieve operations it's better to set read-only property to true so you can avoid dirty checking operation (by default it has false value)

Resources

Spring Transaction propagation isolation

IF YOU LIKED THE POST, THEN YOU CAN SUPPPORT SUCH CONTENT WITH A CUP OF COFFEE, THANKS IN ADVANCE.

Database Isolation levels

Sameh Muhammed — Wed, 09 Nov 2022 14:15:40 +0000

Introduction

When you have one single user that will use your application that the optimal case and Youtopia of our software industry, but when it comes to multiple users, that what will bring all evil to the application as you now have to manage concurrency and pay attention and resources to manage that, databases engineers suffered from this issue and came with multiple solutions. Let's discuss them mainly with Read operation.

Here we discussed DB concurrency from Write operation point of view

Our use case

Let's say we have below use case, we have an E-commerce application with 2 actors user and admin.

At the same moment each on of them fire a request to the application that will start a transaction on DB

User want to submit new Order.
Admin want to generate weekly report of financial and order counts state of application.

The point is, the currently processing order should be displayed on the admin report or not (it's not finished yet we are still processing)?

Some people say, yes we should include it as it coming order, and not included it me display a wrong data on report, but what if we include the order and while processing some failure happens on this transaction and DB decided to rollback and delete all the data regarding to this order, now you also have wrong report data.

Because of this database engineers decided that, this decision depends on multiple factors, like business domain criticality, admin and business requirements and etc.., So they decided to defer this decision up to other engineers to decide which case is applicable for their situation.

Isolation levels

As ACID principals of database engine the letter 'I' stands for Isolation, that each transaction should run in isolated environment, and database engine provides multiple isolation levels/types to describe how transactions should behave regarding to another transaction work.

Read Committed isolation level

This is default transaction isolation level for many databases, by using this the transaction is allowed only to read data that committed as below.

Read Uncommitted / Dirty Read isolation level

In this isolation level the transaction is allowed to read any data written by any transaction at any time, but this may lead to wrong results as this can be rolled back at any time as below.

Snapshot isolation level

This isolation level is capturing a database state when a new transaction begin even the data have been committed or not and when asking for values database provides data based on this snapshot even if it changed during time as below.

Also known by "Repeatable Read" but the most descriptive one is Snapshot.

Serializable isolation level

This isolation level is the strongest one, as it prevents transaction race at all each transaction is processed one by one and not concurrent, this will prevent the issue from its source but this will make a performance impact on your application as below image.

Isolation levels comparison

Conclusion

At the end, there is no best isolation level you can choose it depends what is your use case and what is the requirements and business needs.

Resources and References

IF YOU LIKED THE POST, THEN YOU CAN SUPPPORT SUCH CONTENT WITH A CUP OF COFFEE, THANKS IN ADVANCE.

Layer 4 V.S Layer 7 load balancing

Sameh Muhammed — Sun, 06 Nov 2022 21:27:55 +0000

What is Load Balancing?

load balancing is a mechanism or strategy applied when you have an API or back end service that heavily used in the system so you can run multiple instances form that component and on top of them there is another service that distribute requests among of them.

Load Balancing Algorithms

Most popular two load balancing algorithms are IP Hashing and Round Robin

IP Hashing

Here the load balancer hashes the request and match the hash with one of services, whenever this request came again it will stick with same service

Round Robin

Here the requests distributed among service equally as image below

So, What is Layer 4 and Layer 7?

regarding to OSI (open system interconnection) Model the network model has 7 layers described as below image

So Layer 4 and Layer 7 we are talking about is transport layer and application layer in OSI model, let's talk about each one.

Layer 7 : Application Layer

Here your load balancer service will receive the whole request from the client and decide which service should receive this request and forward the request to it, This means that the load balancer service has full awareness of what is received and what is sent, Therefore as benefit from this you can enable caching for responses, Whenever got this request before it's not needed to forwarded the request to server just pull up the response from the cache and return it to client, also you can define here some URLs you don't want some users to access them so load balancer can act as security layer to prevent this access, But it also has a security wise if load balancer service hacked, Hacker can now know a lot of data about your system.

Layer 4 : Transport Layer

Here as OSI model describers the data packet is surrounded by source and destination addresses (IP address and port) as below image

So when you enable layer 4 load balancing, Your load balancer service will not wait until gather all packets and recognize the request, It will directly open a connection with one of your back end servers and send the packets to it, Therefore the load balancer has no awareness of what happen here it just act as transporter only, So you can't get benefit of caching or prevent some URLs from being processed in load balancing layer, but it also enhance the security of load balancer service as it's now don't have any information about your system and also it faster in packet transporting.

For more better explanation watch this video

IF YOU LIKED THE POST, THEN YOU CAN SUPPPORT SUCH CONTENT WITH A CUP OF COFFEE, THANKS IN ADVANCE.

Optimistic V.S Pessimistic databases

Sameh Muhammed — Tue, 01 Nov 2022 16:09:15 +0000

Introduction

Handling multiple writes

Let's define the problem first and then discuss the solitons.
As below image 2 users are trying to increment same counter value in DB each user read same value from DB because they start they transaction almost at the same time, correct result of this operations must to set counter value to 44 but because race condition the result is 43 and this gives us wrong information.

Or as below image 2 users read same record A from DB and each one runs its' own logic upon it, but regarding that user Y finished its' write late so database kept its' value, and when user X try to refresh the record he will not find his updates and this known by Lost Updates or Last Write Win (LWW) problem.

First solution: Locking

first solution for these problems is locking, whenever any transaction/user want to write to database he must get a lock upon records and prevent any transaction/user from accessing these records.

- Explicit lock

Database allows user to acquire locks on demand as below
SELECT * FROM customers WHRER id = 5 FOR UPDATE

FOR UDATE clause indicates that user needs a lock here so he can do his updates safely, and this is helpful when you are using read-modify-write approach as below.

BEGIN

SELECT * FROM customers WHERE id = 5 FOR UPDATE

//do your logic

UPDATE customers SET is_done = true WHERE id = 5

COMMIT

But there is also another approach which is called atomic updates or compare-and-set which when you fire update statement database will acquire a lock and not let any transaction/user from accessing it what records your updating now until you commit.

UPDATE customers SET available = true WHERE id = 5

- Table V.S Row locking level

Table level lock

in this locking mechanism database lock the entire table you are working on and don't let any transaction accessing it even for another set of records, and keep this lock until you finish your transaction.

Row level lock

In this mechanism database locks only the records you are working on not entire table.

You may think Row level is better than table, but it depends because managing these locks by acquiring and releasing operations can be expensive in case of huge set of rows modification at same time, but also Table level lock can affect your user experience in case of long running transaction started on main table so it's now have a lock and no one can access the table until it finish.

Two Phase Lock (2PL)

what we discussed till now has a performance impact as any transaction starts, it locks the others until it finishes, even if it just read-only transaction, so database engineers decided to do something smart, it's Two Phase Lock (2PL).

In this mechanism you have 2 types of lock, Shared and Exclusive and here how it works:

When any transaction want to read a record, it first have to acquire Shared lock.
You can have any number of Shared locks on same record, by this you allow multiple reads on same records.
If you want to update the record you have to acquire Exclusive lock, to acquire this type of lock all Shared locks have to be released first so now you are the only person who have the lock.
If you acquired the Exclusive lock, no one can access this record until you finishes your updates and release the Exclusive lock.

This approach enhance performance a little bit as now not any transaction/operation locks the record, just write operation, but still has performance impact regarding to managing locks.

To be Optimistic or not to be, that the question

What we discussed until now is known by Pessimistic approach, you are pessimistic that if you didn't do locking there a problem will happen, so in any case you do restrictions.

But there is another approach called Optimistic, by this approach you will not do any locks here you will keep all transactions free to read and write any time they want, BUT in order to solve the conflicts and prevent lost updates we will do these steps

In each table there will be what called version column with default value 0.
Whenever any update operation happen to this record it increments version by 1.
In case of 2 transactions are updating same record at same time first one will increment the version by 1, so the second one has a outdated version number now, so the database will decide to terminate the second one and they have to fire the transaction again after getting the most recent version of this record.

Conclusion

Regarding all these techniques we discussed here, there is no best technique or worst one, it depends what your application accept and what not, regarding to this you choose which database engine that provide locking mechanism will match your application requirement.

Resources

Designing Data-Intensive application Chapter 7 : Transactions.
Optimistic V.S Pessimistic Video

IF YOU LIKED THE POST, THEN YOU CAN SUPPPORT SUCH CONTENT WITH A CUP OF COFFEE, THANKS IN ADVANCE.

GraphQL : Deal REST API like SQL

Sameh Muhammed — Sat, 29 Oct 2022 20:36:01 +0000

Motivation

Have you ever faced these problems, as a back-end developer which front-end requires a lot of changes regarding field names, or field is missing in API response, or you are sending more fields than UI requires and front-end got mad about this, or you have multiple consumers and each consumer want the response as he wishes.

On other hand as front-end developer have you faced that API response field names not match your object, you need same resource in different UI components and blocked until back-end handle them, back-end not formatting dates and strings before sending them to you or formatting don't match with your UI.

What about if we can deal with REST APIs as some sort of SQL : selecting what needed only, formatting the response as we want and manipulate response with our needs.

GraphQL in your service

Graph Query Language is a manipulation language for APIs made by Facebook(meta) to solve problems of continuous UI changing with multiple devices and requirements and propagation of this changing impact to back-end APIs to accommodate with, so let back-end build one API and each consumer can pull what he needs from it, manipulate field name as he needs and formatting the values as per his need.

How this magic happens?

You have to do setup steps so that GraphQL engine can work upon it , At first you have to build graphql schema that define what operations you provide like getAllTransactions() , createTransaction() with what parameters these operations takes and what are they return , and this setup have to be resident in **.graphql* extension with specific syntax as below

After defining your schema you have to link between operations in schema and actual logic that have to be done during these operations call, Linking between operations and logic is done through DataFetcher component, as Graphql engine not performing logic instead it just look at your schema and what requester requests, Then match between them.

How GraphQL link between operation and logic have to be done?

When you start your application GraphQL engine will pull your schema files and parse them, if there any syntax error it will crash. also DataFetcher used to link between operation name and service method that should be executed with , Then this setup goes to SchemaGenerator to generate GraphQLSchema and expose GraphQL API as below

Now GraphQL API responsible for

Receiving the request from requester.
Extract operation name and match with one of defined in schema files.
Fire service method that wired with operation in DataFetcher.
Get result from service method, filter what fields needed in Request and applying any format needed upon data.
Return response to requester.

request - response sample

Fortunately, a lot of helper libraries now exists, and your setup will not go beyond define your schema files and implementing an interface that provide your business logic and let the magic begins.

Nothing is perfect!

let's taking about GraphQL pros and cons

Pros

Limiting the hassle of change back-end APIs when continues changes of UI.
Supporting multiple API consumers with different requirements with same back-end service.
One GraphQL API can handle multiple operations as per your schema files and don't worry about contract just give consumers one URL and your are done.
Helper libraries for providing GraphQL UI that consumer can browse your schema and test the operation.

Cons

Having performance impact for GraphQL engine works so you have to use it wisely.
Can't depend on HTTP error codes as GraphQL always send 200/Ok even with errors but it provide you with error filed in that case.
You have to configure special exceptional handler layer for GraphQL as the request now takes different path from rest of your back-end service.

Resources

IF YOU LIKED THE POST, THEN YOU CAN SUPPPORT SUCH CONTENT WITH A CUP OF COFFEE, THANKS IN ADVANCE.

Keep your code healthy with Refactoring

Sameh Muhammed — Fri, 28 Oct 2022 08:42:32 +0000

Motivation

In software development day-by-day activities, you go through deadlines, workarounds and misunderstanding and under estimate of work, this leads to bad code and design quality regarding to bad or temporary decisions you took to pass the situation, and this affect whole project quality and upcoming development activities and this generates what called by Technical Debt.

Technical debt (also known as tech debt or code debt) describes what results when development teams take actions to expedite the delivery of a piece of functionality or a project which later needs to be refactored. In other words, it’s the result of prioritizing speedy delivery over perfect code.

So, in order to eliminate technical debt you must revisit your code/decisions and try to refine them frequently and plan time in your weekly work to do that and this what called Refactoring.

What is Refactoring?

Refactoring is the process of restructuring code, while NOT changing its original functionality. The goal of refactoring is to improve internal code by making many small changes without altering the codes' external behavior and it's not necessary to improve performance.

So, the main goal of refactoring is enhancing code readability and maintainability.

When to Refactor?

There are multiple times that a refactor is good at.

Rule of three

Three strikes and you refactor, decide when similar pieces of code should be refactored to avoid duplication. It states that two instances of similar code do not require refactoring, but when similar code is used three times, it should be extracted into a new procedure.

Before adding new feature

Before adding new feature you have to take a look and see how this feature can affect your existing code, is it need a change in it? or what is the best way to add this feature? and so on.

When you found some ugly code

There is a rule that says, leave the place cleaner than you found, when you find some code that can be better regarding to readability and maintainability don’t be hesitated and refactor it.

Refactor principles

- Small changes at a time

Always consider a small change at time, build and compile and test what you did, then complete the refactoring.

- Don't break your code

All your refactor changes have not to break the code, and always code must be compilable and runnable, cause of any urgent matter happens and you need to leave the refactoring right now, otherwise you don’t refactor.

- Do unit test

Writing unit test before refactoring can save your back and give you more confidence when refactoring cause you now have an alert when there is something goes wrong you will be notified once it happens.

Refactor Catalog

refactor catalog describes solution for each code smell you may face in your daily work and code smells are categorized by

Bloaters

Bloaters are code, methods and classes that have increased to such gargantuan proportions that they are hard to work with. Usually, these smells do not crop up right away, rather they accumulate over time as the program evolves (and especially when nobody makes an effort to eradicate them).

Symptoms

Large method

A method contains too many lines of code. Generally, any method longer than 10 lines.

some example here

Primitive obsession

Use of primitives instead of small objects for simple tasks (such as currency, ranges, special strings for phone numbers, etc.)

Use of constants for coding information (such as a constant USER_ADMIN_ROLE = 1 for referring to users with administrator rights.)

some examples here

Large class

A class contains many fields/methods/lines of code.

some examples here

Long parameter list

When you have more than three or four parameters for a method.

some examples here

Data clumps

Sometimes different parts of the code contain identical groups of variables (such as parameters for connecting to a database). These clumps should be turned into their own classes.

some examples here

Object oriented abusers

All these smells are incomplete or incorrect application of object oriented programming principles.

Symptoms

Alternative classes with different interfaces

Two classes perform identical functions but have different method names.

some examples here

Refused Bequest

If a subclass uses only some of the methods and properties inherited from its parents, the hierarchy is off kilter. The unneeded methods may simply go unused or be redefined and give off exceptions.

some examples here

Temporary field

Temporary fields get their values (and thus are needed by objects) only under certain circumstances. Outside of these circumstances, they are empty.

some examples here

Dispensable

A dispensable is something pointless and unneeded whose absence would make the code cleaner, more efficient and easier to understand.

Comments

Comments are usually created with the best of intentions, when the author realizes that his or her code isn't intuitive or obvious. In such cases, comments are like a deodorant masking the smell of fishy code that could be improved.

some examples here

Duplicate code

some examples here

Data class

A data class refers to a class that contains only fields and crude methods for accessing them (getters and setters). These are simply containers for data used by other classes. These classes don't contain any additional functionality and can t independently operate on the data that they own.

some examples here

IF YOU LIKED THE POST, THEN YOU CAN SUPPPORT SUCH CONTENT WITH A CUP OF COFFEE, THANKS IN ADVANCE.

How to master your career

Sameh Muhammed — Wed, 26 Oct 2022 14:02:59 +0000

Introduction

Have you heard about below advices on social media or some of your friends told you them

You have to follow your passion.
If you wanted to love your job, you have to make it follow your passion.
Free yourself from your bored job and start looking something you are passionate about.
Your wage is the price for getting rid of your passion and your dreams.

While we are going through this article we will try to spotlight on the truth of passion from "So Good They Can't Ignore You" book point of view, we will discuss about where the passion comes from, and how people love their jobs and show creativity, and what matter most is how you also can reach out to this stage to obtain a successful career path.

First Step : Don't follow your passion

Following your passion not only a bad advice, but it also can be dangerous

Many people think that what makes other people successful in their jobs is the passion, and they support their thoughts about passion with that each one was born with a passion toward something specific, and each one should work hard to discover what is that thing, but the truth is that's not the case for the following reasons

Researches and studies proved that human not born with passion regarding to specific job, but maybe with some sort of hoppy.
Discovering your passion requires a lot of time and expertise for a lot of fields, and you may not reach out to something.
The truth is that passion comes from mastery of your job, and to get to this stage, you need a lot of time and hard work, so you can't easily say that you are passionate about something.

So, for the above listed reasons the advice of following your passion is wrong.

But, if following the passion isn't the right thing what we should do to have a great career path.

Step Two : Adapt the craftsman mindset

Your nowadays hard work, opens multiple paths in the future

The financial rule said that "if you want to obtain something rare and precious, you have to give something rare and precious", So, the craftsman mindset encourage you to acquire different skills at your job to be able to exchange them with a great job position.

And here comes a question, what are the treats of great work environment that deserve your skills?

The writer mention that the great work environment which provides below to their employees

Innovation: where the employee has the chance to show up his creativity without being tied with specific rules and regularities and he can always challenge his skills and measuring the his improvements.
Impact: where the employee can feel that his job affects people lives and makes it better
Control: where the employee has the full control over his duties and requirements, not be bothered with micromanagement
Relation: where employee can feel that he is a part of something not just a task doer

The craftsman mindset also says that, it doesn't matter what is your current job and how do you feel about it, if you are able to acquire more skills you will be able the exchange them with your dream job.

On the other hand, to be realistic there is nothing can be done perfectly, the writer mention that the circumstances the craftsman mindset can backfire you

There is no enough space at your current job to show up your skills and be different from the others.
When you feel that your work has no impact on other peoples, or it may harms the society.
When your current job force you to be with accompany you don't feel comfortable with.

Third Step: Seek for promotion

No one owes you a great career path, you have to deserve it

Obtaining a control is something mandatory to boost your success toward a great career path, and we mean by control here is the space of control over your work and activities, which lets you do your work with the most suitable way for you. and the promotion is the shortest path to get this control, with promotion the micromanagement will be reduced and you have the ability to apply your thoughts and your way of work, therefore you can obtain more trust from your bosses so that you can perform your tasks in more comfortable way, so that the writer encourage you to seek for promotion at your job.

the writer also mention that not all places provide you with control, so you have to choose wisely for your next move the company will provide you with much control.

But while you looking for control you have to be careful and avoid these control traps you may encounter

- Avoid the fake control

Fake control is when you are seeking the control in a field or domain you don't have enough skills or information about it.

- Control generate resistance

You will encounter resistance either from your colleges or from your managers, because you are asking for something they are not familiar with, so you have to arm yourself with skills and trust to tackle this resistance.

Fourth Step : Set a goal for your career path

Any work you do can be a spark for a great career path

Off course getting paid is reason number one for getting a job, but setting a goal for your job like for a software engineer "make life easier for people by providing helpful apps", or for a doctor "helping poor people to recover from diseases", setting such goals for your career path continuously recharge your power to tackle the obstacles and acquire skills needed to have a great and memorable career path.

So, to summarize the main idea about the truth of passion and how people can find it from the book and writer view

Mostly the passion is the result of hard work and continuous learning to acquire the needed skills to tackle your job tasks in more efficient and best way, then you can exchange these skills with a job in place that satisfies your needs and match your personal goals, so that your job doesn't became something you hate anymore, further more you can innovate and create new things.

*And here list of advices from the writer to help you acquire a great career path *

List the most required skills for your job and seek for acquiring them as soon as possible.
Always look for someone you can consult to help you take better decisions.
Seek for feedback from your colleges and managers.
Try to but your ideas in execution to test their effectiveness.
If you want to evaluate your ideas, always ask yourself are people ready to pay for it or not.
Monitor how you are spending your day time to eliminate the bad and increase the good things.
Use different methodologies when you are learning something new to tackle it quickly.
Sharping your skills by challenging yourself and not staying in comfort zone for a long time.
Mix between theory and practice to improve your skills.
Set a goal so that it can be your compass to check if you are getting closer or far from it.
Be patient, it takes time to mastery.

References

So good they can't ignore you book

IF YOU LIKED THE POST, THEN YOU CAN SUPPPORT SUCH CONTENT WITH A CUP OF COFFEE, THANKS IN ADVANCE.

WebSocket V.S HTTP

Sameh Muhammed — Tue, 25 Oct 2022 11:02:44 +0000

Introduction

WebScoket and HTTP both are protocols used to transmit data over network and both of them built upon TCP so what the purpose and when to use each one, and here is the story.

Hence the more popular one is HTTP we will take it first, HTTP mechanism is based on Request/Response strategy so there is must be client (browser/mobile/another back end service) that send the request first and the server process the request and send the response then connection closed (can use keep-alive header to make TCP connection open for a while but mainly HTTP request is finished).

So regarding to HTTP Request/Response mechanism which needs the client to ask for data then server response, we needed a way to make the server pushes data to the client (without client asking for it) this is the need for such WebSocket protocol, WebSocket works as this

First the client needs to start to communication with the server so it sends an HTTP request to server with upgrade request to indicate to server this request need to be converted to another protocol, Then server respond with channel created, then communication established, therefore any of both side now are aware of each other and can accept data from each other so server can now send a data based on current event without request from client itself.

Also it's very helpful for making Asynchronous calls that the client should not wait for a long request to be done, just release it and when server is finished will send the result to client.

HTTP request starts with http:// but WebSocket start with ws:// or wss:// for secure connection and also HTTP is stateless but off course WebSocket is stateful.

whenever any of both side close the connection the communication channel is closed and need to be open again from client.

Resources

IF YOU LIKED THE POST, THEN YOU CAN SUPPPORT SUCH CONTENT WITH A CUP OF COFFEE, THANKS IN ADVANCE.

Consider Anti-corruption Layer when integrate with another system

Sameh Muhammed — Sun, 23 Oct 2022 20:16:04 +0000

Motivation

You may be worked on projects that deal with third party APIs (APIs related to another service provider) or some libraries generated by another companies or you building new system but it deals with a legacy system, when you use or deal with these APIs you have to deal them with special handling in order to keep your code clean and maintainable.

The main problem is different languages

Mostly these APIs you deal with outside your system are built with different language from that in your system, By different language I don't mean programming language I mean Domain language, Different objects and properties from that used in your system.

If you start directly use this language (Objects and Properties) in the middle of your Domain business logic, you will find that you are make explicit conversion between your system objects and third party objects, also may handle exceptions that may occur from library or handle failure of HTTP requests in the middle of your business logic, and maybe your functionality is very small or trivial but because it uses a third party API it became more complex to read and maintain.

Meet Anti-Corruption Layer

Anti-corruption layer is one of DDD (Domain Driven Design) principles, name came from that preventing corruption of your business logic that may happen because of integration code, which tells you that if you will deal with any third party API you have to isolate integration code in different layer and any service in your system needs to use this API it should use it from Contract/Interface.

Let's take an example, If you have a Social Insurance System and want to integrate with a third party that provides Citizen information based on national id, so your system have Insurer class that belongs to your system domain like this

`Class Insurer {

private String firstName;

private String lastName;

private String nationalId;

private Integer age;

// getters and setters

And third party response will be like this

`Class Citizen {

private String fullName;

private String id;

private Date dateOfBirth;

// getters and setters

it's Obvious that 2 different classes and need conversion, so how our anti-corruption layer will be look like?

First we will build the contract/interface as this

`public interface CitizenSystemIntegration {

public Insurer getInsurer(String nationalId);

and our contract implementation service will be like

`class CitizenSystemIntegrationImpl implements CitizenSystemIntegration {

    @Override
    public Insurer getInsurer(String nationalId) {

        // build request object

        // call third party api

        // convert response to Insurer object

        // return

    }

Now whenever you need this facility you can create object from this implementation and use it, listing below benefits of this strategy

Isolating the integration code.
Reducing code duplication , as we have one place to edit and maintain.
You can build your exception handling logic in one place.
Your main system functionality is clear, there is no different object you need to handle, no specific exceptions you have to deal with and your domain service is clear.
You can add logging functionality

At the end , Anti-corruption layer is built based on same concept of Adapter Design Pattern

Resources

IF YOU LIKED THE POST, THEN YOU CAN SUPPPORT SUCH CONTENT WITH A CUP OF COFFEE, THANKS IN ADVANCE.

RestTemplate and FeignClient, The Dependency Injection Principle

Sameh Muhammed — Thu, 20 Oct 2022 14:15:50 +0000

Introduction

In any application you work with regardless it's a monolith or microservices it's common to deal with third parities using HTTP calls, Spring Boot provides multiple ways to do HTTP calls.

RestTemplate Class

RestTemplate is a class responsible for handling HTTP requests and map the response for you, for an example you can do this.

Yeah, this it works fine , but we missed something, regardless static URL in the code, we are communicating with another system over network and this may faces a lot of failures, network may be unstable so the calling fails or another system we deal with has bugs, and all of this might affect badly on our system.

So what, let's add try catch block.

Yes it's more safer now, but what about if we want to handle the exception in special way like log the exception into database or send some notifications to user.

Let's do it,

We did it and works fine, but here is the problem, now we broke Single Responsibility principle and now this method is responsible for many things, so in order to make our code cleaner we may extract all business logic related to calling HTTP request to another service with it's error handling and just use this service to interact with third party.

This better now what about using another technique,

Feign Client

Feign Client also is a component used to handle HTTP requests but in another way, you create an interface then annotate it with @FeignClient and fill annotation properties and type your API signature as method as below.

then you use @Autowired upon interface and now you are having HTTP handler out of the box provided to you from Spring Boot, much easier right, isn't it?

what about error handling?

There are multiple ways to do that you can use fallback property in @FeignClient you can use it to provide fallback class that contains error handling logic, you will find links below about Feign Client.

Feign Client It's not only about ease code writing?

Providing Feign Client in Spring Boot toolbox not only for ease code writing purpose for developer instead of using RestTemplate, but also it has an architectural decision and design.

Let's say you are using RestTemplate for communication with third parties, and Spring team decides that they need to change some RestTemplate method signatures to add some value to the class, off course they have to support backward compatibility and deprecate methods gradually, but in case you need to catch up the updates you have to make changes to your code and test it again and deploy it.
That's the key and main reason behind Feign Client.

While you are using Feign Client you don't depend on concreate class/implementation. Instead, you are using interface and out of the box Spring Boot knows that you are need here HTTP call, so it did that for you without interfering you about how it dose do that, they may still depends on RestTemplate class but they hide that from you, and now they can do whatever change they want and not affecting your code.

Depending on contracts/interfaces while dealing with other system modules or third parties instead of concrete classes, makes your code loosely couple and each module can change its' behavior without affecting other modules.

So you have to follow this rule

Depend on abstractions, not on concretions It means, coding to interfaces, not to concrete classes.

Especially with parts that you expect changes during development process.

At the end, what we were talked about is Dependency Inversion Principle

Resources

IF YOU LIKED THE POST, THEN YOU CAN SUPPPORT SUCH CONTENT WITH A CUP OF COFFEE, THANKS IN ADVANCE.