DEV Community: Abanoub Asaad

Top 7 LeetCode extensions

Abanoub Asaad — Tue, 01 Feb 2022 20:09:43 +0000

We all know that LeetCode is so useful for problem-solving or preparing for interviews, but you can do a few tweaks to make it more fun and useful while solving problems. Some of these extensions will help you increase your productivity, and some of them will help you to have good open-source contributions. So in this blog, I'll be talking about six useful leetcode extensions for browsers, and one more we can use with VS Code. Enjoy :)

1. LeetCode Video Solutions

Through this extension, you will enjoy:

Watching free helpful LeetCode video solutions on the problem page itself, the solutions are in different programming languages and cover different solving techniques and algorithms
Not being distracted by watching cat videos on YouTube when you should be solving a LeetCode problem!
Seeing the solution videos' duration, upload date, views, channel, and other information.

🔗 It's available for Google Chrome and Mozilla Firefox.

2. LeetCode Enhancer

This extension can boost your productivity by hiding unnecessary visual elements from the screen, enabling you to focus on what is important. You can change your preferences from the popup menu and find out what best suits your needs.

It has the following features:

Hide problem difficulty
Hide locked problems from the table
Hide / Show any table column
Highlight solved problems
Hide solved problems.

🔗 It's available for Google Chrome, Mozilla Firefox, and Microsoft Edge.

3. LeetHub

With this extension, you can automatically integrate and push your Leetcode submissions to GitHub when you pass all tests on a Leetcode problem.

This extension is beneficial because:

Recruiters want to see your contributions to the Open Source community, be it through side projects, solving data structures/algorithms, or contributing to existing OS projects
It would be so easy to access your leetcode problems and solutions in one place, and you will not spend any time pushing your code to GitHub!

🔗 It's available for Google Chrome.

4. Leetcode Timer

Easily time your leetcode practice sessions with automatic time setting based on difficulty.

It has the following features:

Set time for difficulty levels to increase your solving speed
Automatically detects difficulty and sets the time accordingly
Alert when time is over.

🔗 It's available for Google Chrome.

5. LeetCode Timer

Don't worry, I'm not repeating myself :) It's a different extension.

It has the following features:

Track time when solving problems on LeetCode
Auto start timer functionality
Automatically, pause timer on successful submission
Hide acceptance rate and more other features.

🔗 It's available for Google Chrome.

6. LC Predictor

This extension for predicting leetcode contest rating. It shows approximate rating delta after contests on leetcode itself on the right side
After participating in Leetcode contests, you wait too long for seeing your new rating. so this extension will be helpful here.

🔗 It's available for Google Chrome.

7. LeetCode "VS Code extension"

Solve LeetCode problems in VS Code
Filter problems by company, difficulty, or topic.

You can also watch this video to know how to install the extension.

Conclusion

In this blog, I discussed some useful LeetCode extensions that I know. If you know any other useful extensions, it would be great to share them with us :)

Which extension do you like more? Let me know!

Shortest way to find a buggy commit with Git

Abanoub Asaad — Tue, 16 Nov 2021 14:23:37 +0000

A couple of days ago, one of my colleagues at robusta recommended an interesting git command to use, and it was my first time hearing about it. I started searching, and then I decided that I would write a summary about it.

Have you ever been into a situation where you are writing your code, and you push commits after commits, and after a while, you go around your project and find a bug, Now this bug could happen anytime between your last commit and the last 1000 commits, so this makes it extremely hard to track down what happened and from where did you know the bug occurred? So instead of going one commit by one commit, which is time-consuming and will probably frustrate you because it's a linear search, git bisect will be your answer.

In this blog, we will explore the git bisect command, how it works, how to use it, and other useful commands to reduce your time of debugging and make you a Git Geek 😎

What is git bisect?

git bisect is a way to use a binary search algorithm to find the commit that introduced a bug easily and quickly. It's a very useful command to help you in your process of tracing and debugging. Imagine you have N commits, by using this command, you will find the buggy commit in only log(N) steps!

If you know the Binary Search concept, you can skip the next section.

Quick overview about Binary Search

Binary Search is an efficient algorithm for finding an item from a sorted list of items. It works by repeatedly dividing in half the portion of the list that could contain the item until you've narrowed down the possible locations to just one.

The example below explains the concept of binary search, we need to find 47 as fast as possible. We can achieve that by:

1. Dividing the array into two parts, and now the mid is 14, so 14 < 47
2. I will divide the right part and the mid is 45, so 45 < 47
3. I will divide the right part again, and the mid will be 47, so 47 = 47.

Now we found the desired number 47 in only 3 steps using a binary search.
©️ GIF source: Brilliant.org

How git bisect works?

After understanding the concept of binary search, git bisect works in the same way. It allows you to use binary search to find buggy commits. Binary search makes finding things faster, instead of looking at all commits one by one, you would divide your list of commits into two equal parts, you then look at each part and see which part contains the bug, you then continue on this process until you arrive at a single commit. The below image explains that!

Scenario of git bisect

Let's assume I have a website, and we released the second release yesterday. For example, a button on this website ran successfully in the first version 2 months ago, but it does not work now. And the history has about 300 commits, so how can I know the buggy commit quickly using git bisect?

1. start the git bisect session
2. mark a commit as bad "for example, the current one" if this version is broken
3. mark a commit as good, choose a commit that you know is working correctly and mark it as good
4. the git bisect will start to recommend commits "according to the binary search algorithm", and you should mark them as good or bad by compiling the checked-out version and testing it. Until you find the specific commit which makes the bug to fix it in your current release
5. exit from the git bisect tool and start to fix the bug.

The commands of these steps are below in the next two sections!

©️ Image source: datree.io

How to use git bisect?

✶ Start the git bisect

$ git bisect start
This starts the bisect process on our current commit which is "Head".

✶ Let git bisect know about a bad commit

$ git bisect bad
The bug is present, so we need to designate it as a bad commit
or you can type:
$ git bisect bad <commit_id>
for example, the commit_id is 3acea60.

✶ Let git bisect know about a good commit

$ git bisect good <commit_id>
If this commit is working correctly.

✶ Exit the bisect tool

$ git bisect reset
After a bisect session, clean up the bisection state and return to the original HEAD.

✶ Automate the bisect tool

$ git bisect run
If you want to automate the bisect tool, you can use the above command and also read the official docs.

PS: I know how to use it manually, not automatically😅

7 Awesome debugging git commands

1️⃣ git blame

If you need to examine the content of any file line by line, you need to use git blame. It helps you to determine who made the changes to a file.
$ git blame <your_file_name>

2️⃣ git reset

If you want to reset the current HEAD to a specified state or commit.
$ git reset --hard <commit_id>
To push these changes, you should force them by using:
$ git push -f

3️⃣ git log

To show commit logs in detail or in an organized way.
$ git log
or
$ git log --oneline
or
$ git whatchanged

4️⃣ git checkout

To restore a specific commit or switch to another branch
$ git checkout <commit_id>
or
$ git checkout <branch_name>

5️⃣ git show

To see what's actually changed in a specific commit.
$ git show <commit_id>

6️⃣ git citool

It is a graphics alternative of git commit.
$ git citool

7️⃣ git help

There are many commands in Git, and if you need more help with any command, you can use git help at any time from the terminal.
$ git help
or
$ git help <git_command>

Conclusion

I tried to tell you about this useful command "git bisect" and also some other important git commands to help you to reduce debugging time. If you know any other ways to make the debugging process faster, it would be great to share them with us :)

Operating Systems Concepts: Processes

Abanoub Asaad — Sat, 31 Jul 2021 23:10:14 +0000

A couple of weeks ago I came across a very interesting book titled Operating Systems Concepts or "the dinosaur book" by Abraham Silberschatz, Greg Gagne and Peter B. Galvin, which has a very good reputation, and it's one of the best operating system textbooks. The book discusses a number of different concepts related to Processes, Threads, CPU Scheduling, Deadlocks, Memory, Storage, File-Systems, Security and more.

One of my friends on Twitter recommended it to me a few days ago, so I said that it's a good time to start reading it!

I started reading, and then I decided that it would be better to write a form of summaries or personal notes, so to speak based on the book, I'll start summarizing from chapter 3 because the first two chapters are talking about an introduction to the operating systems and its structure. So without further ado, let's Get Started!

✍ Processes

Early computers allowed only one program to be executed at a time. This program had complete control of the system and had access to all the system’s resources. In contrast, contemporary computer systems allow multiple programs to be loaded into memory and executed concurrently.

The process is a program in execution and the unit of work in a modern computing system. Although its main concern is the execution of user programs, it also needs to take care of various system tasks that are best done in user space, rather than within the kernel space.

📌 Process Concept

When we read about processes, we may face some other terminologies like job or task, they can be all considered the same thing, it really depends on the context. A “job” often means a set of processes, while a “task” is often a part of a job – sometimes the only part.

🧱 Memory layout of a process

It's typically divided into multiple sections, these sections include:

Text section: the executable code, this is read-only and might be shared by a number of processes
Data section: containing global variables
Heap section: containing memory dynamically allocated during the program run time
Stack section: containing temporary data (such as function parameters, return addresses, and local variables)

Memory layout of a C program:

Notice that the sizes of the text and data sections are fixed, as their sizes do not change during program run time. However, the stack and heap sections can shrink and grow dynamically during program execution, for example, in case of sending parameters or returning from a function.

🆚 Program Vs. Process

A program is a passive entity, such as a file containing a list of instructions stored on disk (often called an executable file).
A process is an active entity, with a program counter specifying the next instruction to execute and a set of associated resources.

A program becomes a process when an executable file is loaded into memory.

⚙️ Process State

The state of a process is defined in part by the current activity of that process. A process may be in one of the following states:

• New: the process is being created
• Running: instructions are being executed
• Waiting: the process is waiting for some event to occur (such as an I/O completion or reception of a signal)
• Ready: the process is waiting to be assigned to a processor
• Terminated: the process has finished execution.

📦 Process Control Block

For each process there is a Process Control Block(PCB) – also called a task control block, which stores the following process-specific information:

Process State – running, waiting, etc., as discussed above
Process Number "PID" – is a number used by most operating system kernels to uniquely identify an active process
Program counter – the counter indicates the address of the next instruction to be executed for this process
CPU Registers – tell us the particular registers that are being used by a particular process
CPU-Scheduling information – this information includes a process priority, pointers to scheduling queues, and any other scheduling parameters
Memory-Management information – e.g., page tables or segment tables, depending on the memory system used by the operating system
Accounting information – they are the resources that are used by a specific process e.g., the amount of CPU and real time used, time limits, account numbers, job or process numbers, and so on
I/O Status information - e.g., a list of I/O devices allocated to the process, a list of open files, and so on.

🐧 Process Representation in Linux

The process control block in the Linux operating system is represented by the C structure task_struct, which is found in the Linux repository through this path include/linux/sched.h The following structure contains all the necessary information for representing a process.

long state; /* state of the process */
struct sched_entity se; /* scheduling information */
struct task_struct *parent; /* this process’s parent */
struct list_head children; /* this process’s children */
struct files_struct *files; /* list of open files */
struct mm_struct *mm; /* address space */

Within the Linux kernel, all active processes are represented
using a doubly linked list of task_struct. The kernel maintains a pointer current to the process currently executing on the system, as shown below:

If current is a pointer to the process currently executing, its state is changed with the following:

current->state = new state;

📌 Process Scheduling

The objective of multiprogramming is to have some processes running at all times, to maximize CPU utilization
The objective of time sharing is to switch the CPU among processes so frequently that users can interact with each program while it is running

To meet these objectives, the process scheduler selects an available process (possibly from a set of several available processes) for program execution on the CPU.

Each CPU core can run one process at a time
If there are more processes, the rest will have to wait until the CPU is free and can be rescheduled.

📅 Scheduling Queues

Job Queue – As processes enter the system, they are put into a job queue, which consists of all processes in the system
Ready Queue – The processes that are residing in main memory and are ready and waiting to execute are kept on a list called ready queue
Device Queue – Processes waiting for a device to become available or to deliver data are placed in device queues.

The above figure is a Queueing-diagram representation of process scheduling.

🔄 Process Swapping

Some operating systems have an intermediate form of scheduling, known as swapping, whose key idea is to remove a process from the memory or loading the process again from disk back to memory.

🔗 Context Switch

When an interrupt occurs, the system needs to save the current context of the process currently running on the CPU so that it can restore that context when its processing is done, essentially suspending the process and then resuming it, this process is known as a context switch

Interrupts cause the operating system to change a CPU from its current task "process" to run a kernel routine
Such operations happen frequently on general-purpose systems
The context is represented in the PCP Process Control Block of the process
Context Switch time is an overhead because the system does no useful work while switching
Its speed varies from machine to machine, depending on the memory speed, the number of registers that must be copied, and the existence of special instructions (such as a single instruction to load or store all registers).

📱 Multitasking In Mobile Systems (Android)

Since its origins, Android has supported multitasking and does not place constraints on the types of applications that can run in the background. If an application requires processing while in the background, the application must use a service, a separate application component that runs on behalf of the background process.

Consider a streaming audio application: if the application moves to the background, the service continues to send audio data to the audio device driver on behalf of the background application. In fact, the service will continue to run even if the background application is suspended. Services do not have a user interface and have a small memory footprint, thus providing an efficient technique for multitasking in a mobile environment.

Conclusion

In this article, we summarized chapter 3 – part 1, and talked about Process Concept, The memory layout of a process, Process State, PCB, Process Scheduling, Context Switch, and Multitasking in mobile systems. See you soon in the next article, and I will be talking about part 2 of chapter 3.

Top 10 Useful GitHub Browser Extensions

Top 10 Useful GitHub Browser Extensions

Abanoub Asaad — Thu, 24 Jun 2021 12:05:59 +0000

There are many types of addiction, but addiction to GitHub is a unique and interesting one. Although GitHub is a great tool for developers, using extensions to increase your productivity is greater. Let's get started with the extensions that I'm using.

1. Octotree

It shows a side panel to enhance code review and exploration. Here, it is easy to navigate between the files and folders of the repository.

2. Enhanced GitHub

It displays :
- The whole repository size and each file size
- Download link

You can copy file content directly to the clipboard.

3. GitHub Code Folding

It enables code folding in GitHub.

4. Sourcegraph

It makes you go to definition & find references (currently for Go, Java, TypeScript, JavaScript, and Python).

5. Notifications Preview for GitHub

This extension makes you :

Show the count of notifications on the bell icon
Preview the unread notifications using pop-overs on hover
Allow to perform actions like marking as read and unsubscribing on the notifications.

6. File Icons for GitHub and GitLab

It gives you different file icons in GitHub or GitLab.

7. OctoLinker

It makes navigating through the code more efficient by turning language-specific statements like include, require or import into clickable links.

8. GitHub Isometric Contributions

It allows you to toggle between the normal GitHub contribution chart and an isometric pixel art version.

2D Chart

3D Chart

9. GIFs for GitHub

It makes it easier to search GIPHY and add a GIF into any GitHub comment box.

10. Refined GitHub

This extension has a lot of features like :

Making whitespace characters visible
Adding one-click merge conflict fixers
Adding reaction avatars showing who reacted to a comment
Letting you hide every event except comments or unresolved comments in issues and PRs
Linking issue/PR references and URLs in code and conversation titles
Adding the option to wait for checks when merging a PR
Adding a button to revert all the changes to a file in a PR.

Conclusion

I tried to show some useful GitHub extensions that I know. There are a lot of other extensions you can use to enhance your experience. If you want to explore other awesome GitHub extensions, you can check this link.

Which GitHub extension do you like more? Let me know!

DEV Community: Abanoub Asaad

Top 7 LeetCode extensions

1. LeetCode Video Solutions

2. LeetCode Enhancer

3. LeetHub

4. Leetcode Timer

5. LeetCode Timer

6. LC Predictor

7. LeetCode "VS Code extension"

Conclusion

Previous Articles

Shortest way to find a buggy commit with Git

What is git bisect?

Quick overview about Binary Search

How git bisect works?

Scenario of git bisect

How to use git bisect?

✶ Start the git bisect

✶ Let git bisect know about a bad commit

✶ Let git bisect know about a good commit

✶ Exit the bisect tool

✶ Automate the bisect tool

7 Awesome debugging git commands

1️⃣ git blame

2️⃣ git reset

3️⃣ git log

4️⃣ git checkout

5️⃣ git show

6️⃣ git citool

7️⃣ git help

Conclusion

Previous Articles

Operating Systems Concepts: Processes

✍ Processes

📌 Process Concept

🧱 Memory layout of a process

🆚 Program Vs. Process

⚙️ Process State

📦 Process Control Block

🐧 Process Representation in Linux

📌 Process Scheduling

📅 Scheduling Queues

🔄 Process Swapping

🔗 Context Switch

📱 Multitasking In Mobile Systems (Android)

Conclusion

Previous Articles

Top 10 Useful GitHub Browser Extensions

1. Octotree

2. Enhanced GitHub

3. GitHub Code Folding

4. Sourcegraph

5. Notifications Preview for GitHub

6. File Icons for GitHub and GitLab

7. OctoLinker

8. GitHub Isometric Contributions

9. GIFs for GitHub

10. Refined GitHub

Conclusion