DEV Community: Tawfik Yasser

Get your proposal winning: Bits of Advice from TOP RATED FREELANCER on Upwork

Tawfik Yasser — Sat, 27 Nov 2021 05:03:02 +0000

Hi there!

Let's jump into the steps directly to save your time 🙂

ON Upwork, clients need to work with the best freelancer and the best freelancer is the one who knows clearly what is the client need.

So, using a real example I'll show you how I got a job from a client, the client contacted me instantly.

There was a job on Upwork, the client want to clean up some data in an Excel file.

In this case, you've to show the client that you understand the need and know how you will do the task.

and my proposal was

You can see here that I've sent a video to explain to the client how I'll do the task, and imagine at the moment the client says WOW!. because he can see that you're really interested in the job and knows how you'll do it. so no way, he will contact you.

and don't forget to explain more in the proposal that you understand the description and your free time to start the work.

I hope you benefit from this experience and apply it to get great results.

Upwork: Tawfik Y.

Good Luck,

Tawfik

Distributed Systems in Terms of Scalability, Fault tolerance and Latency

Tawfik Yasser — Sun, 23 May 2021 21:09:54 +0000

Hello Geeks

In a simple way, distributed systems is a Shared Architecture to achieve three aspects, terms of scalability, fault tolerance and latency for a system with multiple machines which supposed to achieve high availability of data storage and retrieval.

In a simple words, distributed systems consists of machines or virtual machines , each one of these machines is called Node , each one of these nodes use independent resources.

To build a distributed system only you need to now is the following two ways: Replication and Partitioning

And we will talk about Replication

Let's get started!

Replication

means keeping a copy of the same data on a multiple machines that are connected via a network.
Replication has advantages:

Allow users in different locations to access the data.
Give the system the ability to work even if one of the nodes is down, another node will work instead and serve the users, because replication provides the redundancy.
Improve and Increase throughput.

So how we can implement this type of distributing data, we have several ways we'll talk only about the first simple architecture, which called Leaders and Followers

Leaders and Followers

this way provide nodes, called replica, this way also called leader-based replication.

The components of the above architecture

Leader (called active) has the replication log.
Follower (called read replicas) they are the other replicas.

How it works

When a user need to write its data to the application, data forwarded to the leader which is the write-only replica, then the leader saves the changes and send them to the all followers using a log to tell them the changes must be applied to the database, and so far we have the same data in all nodes.
and if the user want to read its data again, the request forwarded to one of the followers.

Used in

replication used in databases like: PostgreSQL, MySQL, Oracle Data Guard and SQL
Also used in NoSQL databases like: MongoDB and Espresso

Glad you got here, this topic is an important topics for software engineers, especially for Data and Big Data Engineers, You need to read a book to gain the whole knowledge or watching a specialized course, to know more about distributed systems, so i recommend the best book as a start, which called Designing Data-Intensive Applications it is a really worth book to read.

Thanks a lot for reading this article, if you love the content, share it to help others to learn more. Bye Bye! 👋

HEADER IMAGE: Hackernoon.
LEADER-FOLLOWER IMAGE: Designing Data-Intensive Applications.

Calling by value & by reference in Python

Tawfik Yasser — Mon, 12 Apr 2021 15:38:45 +0000

Hello folks,

Let's test the following functions:


def double(arg):
    """ This function takes 'arg' object and multiply it by 2. """
    print('Before: ',arg)
    arg = arg * 2
    print('After: ',arg)

# Calling the function
flist = [10,20]
double(flist )
print('Original : ',flist )

The output will be like this:

Before: [10, 20]
After: [10, 20, 10, 20]
Original: [10, 20]

This means that the arg object passed to the function by value, and it's changed only within the function suite.
Put in your consideration that Python allow pass by value and pass by reference.

Second function


def change(arg):
    """ This function takes 'arg' object and add '30' to it. """
    print('Before: ',arg)
    arg.append(30)
    print('After: ',arg)

# Calling the function
slist = [10,20]
change(slist)
print('Original: ',slist)

The output will be like this:

Before: [10, 20]
After: [10, 20, 30]
Original: [10, 20, 30]

This means that the arg object passed to the function by reference, and it's changed within the function suite and in the original object (simply it is passed by address).

Let's explain what happens here...

As Python allow the two types of passing objects, why the above functions behave in different ways?

In Python if the passed object is Mutable like lists, dictionaries, and sets are always passed into a function by reference.

and for immutable like strings, integers, tuples are always passed into a function by value.

But it seems that there is an Error with the interpreter.

To understand what happened

Remember that in the first function double the arg object changed using assignment statement , so what happened that the right side of the assignment statement is executed and a new object created with value of arg * 2, then assigned to arg with only the function suite, However the original object still exits in the calling code.

On the other hand, because using .append() both lists in the function suite and the calling code affected by the append() function because both refer to the same object.

This explains what happened.

I hope this small article has been helpful.

Thanks

Sync a GitHub forked repository

Tawfik Yasser — Thu, 11 Feb 2021 07:37:19 +0000

After forking a repository on GitHub, You need to make some changes as a contributions, So you starting with make updates, Then commit it, And finally push them and send a Pull Request, But the problem that the repository maintainer comment on your PR and tell you that your changes are a head.

So what is the problem?

Usually the problem that your copy of the repository is older than the original repository, In another words, Some changes made to the repository after you forked it and you don’t synced it yet.

So all what you need to do is to sync it, and we will use CLI to make this.

Step.1

Change the directory to your local repository:

cd <repo-name>

Step.2

Add the remote to your repo. and call it upstream:

git remote add upstream <original-repo-link>

Step.3

Fetch all the remote branches:

git fetch upstream

Step.4

Merge your master or main with changes:

git merge upstream/master or main

Step.5

Now you can push the updated changes to your remote forked repo:

git push

Make sure that you are on the master or main branch

I hope this be useful folks :)

Have a nice time.

Regex in Java

Tawfik Yasser — Sun, 22 Nov 2020 05:33:54 +0000

Introuction

Our use of Java increases with time, and because of this, we must know more needs that help us with the code and give the code less of our products, and examples of these needs
The Regular Expression or Regex
And we will talk about it in Java

The Regex is a set of specific letters that we write in order to search for a specific pattern in the input, times when it becomes a letter or two and other times to be very complicated pattern.

In general, Regex has many expressions, and when you know them, you can apply them in any language, depending on the syntax you write in.

Examples of Regex:

\ d
This means that you are rotating any number from 0 to 9
\ w
It means that you are running a burn, whether it is an upper case, lower case, or a number
\ s
This means space
[]
This is used if you want to roll a letter or number in a specific range

Example: [a-n] This means that you only rotate the lower case letter from a to n

Ok, if I want, for example, the user, the input, enters a number from 4 to 9, but it is necessary to enter a number at least, and it is possible to enter a lot, but it is necessary to enter at least one number in the form of this + [9-4]
Thus, the regex does not have many needs that you can search for and use in the code instead of what we do.

As an example in Java:

If I want to check the input, it has a number in the first from 1 to 5, then any letter from m to r, then any number from 2 to 4

Scanner scanner = new Scanner (System.in);
String input = scanner.nextLine ();
Pattern pattern = Pattern.compile ("[1-5] [m-r] [2-4]");
Matcher matcher = pattern.matcher (input);
boolean found = matcher.find ();
if (found) {
System.out.println ("Pattern found:" + input);
} else {
System.out.println ("Pattern not found.");
}