DEV Community: Aderibigbe Samuel

Automate Your Code Reviews With AI: CodiumAI vs Github Copilot

Aderibigbe Samuel — Fri, 08 Dec 2023 14:38:21 +0000

Have you ever found yourself struggling to remember the modifications you made to a forked project? Maybe the changes were extensive, and despite your efforts, you worry that you might have missed capturing all the details in the pull request comment. Or perhaps you've been reviewing changes in a codebase and felt lost because the contributors didn't provide sufficient context for their modifications. In this post, I will demonstrate an AI tool that can help you review PRs more quickly and effectively.

In the world of software development, Code reviews are not just a checkbox or an unpleasant routine to add more work, they are important to maintain a quality, reliable, and consistent codebase especially when working as a team. Imagine you just built an app to power the next big thing, picture this without a code review, it's like an artist sending a masterpiece into the hands of users without a final polish, a spellcheck, or a friendly critique. It might work, but chances are, there could be a hidden bug, or even a potential failure waiting to happen.

Pull Request

A pull request is used in version control systems such as Git to propose changes to a codebase. A Developer working on a local branch of a codebase, implementing new features, fixing bugs, or making improvements, will need to make a pull request to merge those changes into the main or target branch, including a comment to provide context.
This pull request now becomes the focal point for code reviews. The good news is that there are AI tools that can assist you in reviewing PRs more quickly and efficiently.

CodiumAI PR_Agent Vs GitHub Copilot

We've seen the use of AI in virtually everything in the tech space, with the rise of GPT, a lot of solutions to everyday problems are been made.CodiumAI is one of the interesting solutions that caught a lot of developers' attention and I will be comparing its features with Github Copilot helping you choose the right tool for your next pull request.

What is CodiumAI's PR-Agent?

CodiumAI has developed a powerful tool, known as PR-Agent, designed to assist developers in speeding up and enhancing the efficiency of their pull request (PR) reviews. This AI agent automatically scrutinizes the commits and the PR itself, offering various types of valuable feedback:

Auto-Description: Automatically generates a PR description, including details such as the name, type, summary, and a walkthrough of the code.

PR Review: Provides feedback on the main theme of the PR, its type, relevant tests, potential security issues, and other suggestions to improve the PR content.

Question Answering: Capable of answering free-text questions related to the PR, offering insights and information.

Code Suggestion: Offers committable code suggestions aimed at enhancing the overall integrity of the PR, from bug identification to providing meaningful tests.

The interesting thing about this tool is that it's free, it's open-sourced, it supports six command prompts and it supports all git environments!

Github Copilot for Pull Requests

GitHub Copilot's pull request summaries, an AI-powered feature, empower users to craft a comprehensive overview of changes in a pull request. This includes detailing the impacted files and guiding reviewers on key focus areas during the review process.

Upon a user's request for a summary, Copilot meticulously scans the pull request. It presents an overview of the changes in a narrative format, supplemented by a concise, bulleted list specifying the changes and their respective impacted files.

Leverage GitHub Copilot seamlessly to generate pull request summaries directly on GitHub.com. This functionality serves a dual purpose—assisting reviewers in understanding modifications and providing a quick grasp for users conducting a pull request review.

GitHub Copilot's analysis of the pull request ensures a detailed overview in narrative form and a succinct, bulleted list outlining changes and their impacted files. This summary feature is conveniently accessible in various locations, offering flexibility in its utilization.

Feature-by-Feature Comparison

	CodiumAI's PR Agent	GitHub Copilot
Price💰	free for individual developers.	Paid
Open-source	✅	❌
No of commands	Multiple🚀	One1️⃣
Git Platform Supported	All Git platforms✅	Only Github1️⃣
Supported Languages	all major programming languages ✅	all major programming languages✅
Supported IDEs	VS Code, JetBrains IDEs, Vim	Neovim, JetBrains IDEs, VS Code, Azure Data Studio
Code Analysis	Yes✅	Yes✅
No of features	Multiple🚀	One1️⃣

Real-world Use Cases

Currently, Copilot Pull request summaries is in beta and is only available to a limited number of users, however, I would what I found on their website.

CodiumAI's PR-Agent

Picture this: we're a dynamic team on a mission to fortify our website with an impenetrable password validator. We're tasked with crafting a program that takes a string as input and decides if it's a rock-solid password. Now, what makes a password truly formidable? Well, we've set some ground rules: it should boast a minimum of 2 numbers, 2 special characters from the elite squad ('!', '@', '#', '$', '%', '&', '*'), and a length of at least 7 characters. If a password passes this litmus test, it earns the prestigious title of 'Strong'; otherwise, it's dubbed 'Weak.'

Let see our eager junior dev, who dives straight into the code fray with this valiant attempt:

string = input()
num_count = 0
char_count = 0
char  = ["!","@","#","$","%","&","*"]
nums  = ["1","2","3","4","5","6","7","8","9","0"]

for var in string:
    if var in char:
        char_count  += 1
    if var in nums:
        num_count  += 1


if (char_count>1 and num_count>1) and (len(string)>6):
    print("Strong")

else:
    print("Weak")

Bravo, right? Well, not quite. There's a little hiccup. The code's loyalty to the "in" operator is a bit too exclusive—it checks only one value in a sequence and refuses to mingle with "and" to check multiple values.

But fear not! Another team member, ever watchful for such nuances, stepped in, wrote a test code to unveil the error, and gracefully submitted a pull request. let's see PR-Agent in play:

One good aspect of the PR-Agent tool is its user-friendly nature. To initiate any command, simply tag @CodiumAI-Agent and choose from the available commands: /describe, /review, /improve, or /ask. Let's kick things off with a review:

This is incredible! CodiumAI's PR_Agent provided a thorough review, giving the team a clear understanding of the situation.

Imagine the possibilities if we could engage PR-Agent to assist us with addressing the issues. This versatile tool not only helps in crafting detailed summaries but can also contribute to code improvements. All it takes is a simple comment to tap into its capabilities, Let's ask for help with improving the code:

"@CodiumAI-Agent /improve --pr_code_suggestions.extra_instructions="make the code a function and correct the validator's logic"

I've just tagged the PR-Agent tool, issued a command to enhance the code, and included specific instructions to turn it into a function and rectify the logic. I'm simply delegating all the work to PR_Agent. Check this out—it's pretty cool!

Not only have I saved time by avoiding the need to explain my actions in a comment, but now I also have a tool that can assist me in refining my code on the fly.

Let's ask PR_Agent to help us with naming the file, considering that well-chosen filenames can greatly enhance context:

GitHub Copilot

Currently, the GitHub Copilot Pull request summary is in beta and is only available to a limited number of users, however, I have read through their docs and I will share the capabilities available with the tool.
Sure, let's break it down:

Start on GitHub:
- Go to GitHub.com, where you can manage and collaborate on your code.
Create or Open a Pull Request:
- If you're making a new set of changes, create a pull request. If there's already one in progress, find and open it.
Blank Description is Best:
- Make sure the description of your pull request is blank. GitHub Copilot works best when starting with a clean slate.
Find the Summary Field:
- Locate the place where you want to add a summary. This could be in the description when creating a new pull request, in the opening comment of an existing one, or as a separate comment at the bottom of the pull request page.
Adding a Summary:
- In the field where you're typing, look for options at the top. Find the one that looks like a bullet point, and click on it. This is where you'll find the option to add a summary.

.
It's important for users participating in a beta to be aware that the feature may still have some rough edges, and unexpected issues may arise. Beta testing is a collaborative effort between developers and users to refine and polish a feature before it reaches the broader user community in a stable and fully released version.

Which tool is best for me?

The choice of the right tool depends on various factors mentioned in the post. Considerations such as pricing preference, whether for a paid or free tool, play a role. While some may lean towards open-source tools, it's essential to evaluate specific features. Open-source tools, like the ones I prefer, offer accessibility to the source code, fostering transparency and community collaboration. This approach allows for code review, audits, and suggested improvements, expediting the identification and resolution of security vulnerabilities.

Another aspect to ponder is the range of supported commands in both tools. If you only need a bulleted list of changes, GitHub Copilot could be a suitable choice. However, if you require additional features like assistance in improving your work or seeking guidance through an 'AI Assistant' for specific code aspects, PR-Agent may be more suitable.

PR-Agent provides developers and repository maintainers with valuable information, streamlining the PR approval process. It also offers actionable code suggestions to enhance the quality of the PR. This integrated approach allows developers to assess the impact of their work without leaving their preferred Git provider environment, whether it's GitHub, GitLab, or another platform.

Conclusion

Deciding among these tools depends on what you need, what your project aims to achieve, and what you like. Whether opting for the collaborative power of open source or the concise capabilities of a dedicated code summarization tool, there are now different options to make coding even better. The important thing is to adapt to new tools that fit your project and team well. Whether you lean towards the detailed insights of PR-Agent or the succinct summaries of GitHub Copilot, the overarching goal remains the same: to help developers and make reviewing code together easier and more effective.

BIG O Notation: A Quick Introduction

Aderibigbe Samuel — Tue, 04 Jul 2023 16:44:13 +0000

When approaching problems in coding, we often come up with an algorithm, which is a set of instructions for solving a problem. To make you understand algorithms, Imagine you have a bunch of unsorted numbers, and you want to find the largest number among them. Here's a straightforward algorithm to solve this:

Start with the first number in the list and call it the "current largest number."
Compare the "current largest number" to the next number in the list.
If the next number is larger than the "current largest number," update the "current largest number" to be the next number.
Move to the next number in the list and repeat steps 2 and 3 until you have compared all the numbers.
At the end, the "current largest number" will be the largest number in the list.

There you have it! a simple algorithm to solve the problem. some algorithms are faster and more efficient than others, especially when dealing with large amounts of data. Consider that there are two ways to arrange a stack of papers. One approach is to examine each paper individually, compare them, and rearrange them until they are in the correct order. The alternative procedure entails cutting the pile in half, sorting each half independently, and then combining them. Which approach do you believe would proceed more quickly as the pile gets bigger? We can respond to questions like these using Big O notation. It enables us to gauge how an algorithm's resource or time requirements change with the size of the input. You can select the right algorithms for various tasks by having a solid understanding of the Big O notation.

What is Big O?

Big O is a way to measure the efficiency of an algorithm or the speed at which it runs, it helps us understand how the algorithm's performance changes as the amount of data it handles grows.

Oftentimes, interviewers would ask questions about big o or ask you to write codes and then evaluate how fast or efficient is your code.

Time Complexity vs Space Complexity

Let's say you have a stopwatch and you have written two codes, Code A and Code B. If you run code A and start the stopwatch and it took 20 seconds for code A to run, you reset the stopwatch and you run code B and it took 40 seconds for code B to run, based on this you would say code A runs faster than code B that is, you can measure it, This is called Time Complexity . A very interesting yet confusing thing about Time complexity is that it is not measured in time but in number of operations that it takes to complete a task. Imagine you took code B(from the example above) and run it on a computer have a processor thrice as fast, it will complete before code A but it does not mean the code B is faster or more efficient, it just means the computer is better, so we use the number of operations instead of time to evaluate Time Complexity.

Space Complexity on the other hand, refers to the amount of memory or storage space an algorithm requires to solve a problem. It measures how the memory usage of an algorithm changes with the size of the input.

why is space complexity also important? we mostly prioritize speed when writing codes but why do we need to consider space complexity too?

Again from the comparison between code A and code B, let's say, while code A runs faster, it requires more memory space but code B requires less memory space even though it runs slower. There will be some occasions when memory space will need to be considered, so it is important to consider space complexity too while writing codes.

Big O (O), Omega (Ω) and Theta (Θ)

These are the commonly used notations in time and space complexity and they represent the following:
Big O (O): The Big O notation represents the upper bound or worst-case scenario of an algorithm's time or space complexity.
Omega (Ω): The Omega notation represents the lower bound or best-case scenario of an algorithm's time or space complexity.
Theta (Θ): The Theta notation represents both the upper and lower bounds of an algorithm's time or space complexity.

The way I like to think of these notations is having a list of seven items and I write a for loop to iterate through these items to find a particular one.

Let say you are looking the number 1, that is your best-case scenario (Omega (Ω)) because you will get the first item in the list in just one operation but if you want to get the number, 7, that is your worst-case scenario (O) because 7 is the last item in the list and you have to go through the entire list to get through it. To get number 4, that's your average-case (Theta (Θ)) because it's between your best-case and worst-case.

Common Time complexities

O(n):

This is the simplest to understand. Consider being tasked with counting the oranges in a basket. Let's say you count the 10 oranges you have one by one. You need 10 units of time or effort to finish the job. Now, if you had 20 oranges instead of 10, it will roughly take you twice as long or as much work to count them.

O(n), where "n" stands for the input size, is a mathematical representation of this linear relationship. It shows that the time or effort needed to complete the activity rises at the same rate as the input size (number of oranges). It takes about twice as much time or effort if you have two times as many oranges.

A simple code example of this:

def print_items(n):
    for i in range(n):
        print(i)
print_items(5)

output:

The code printed five (5) items because we passed the argument n = 5, so it took 5 units of effort to get the task done, so whatever n was, that would be the number of operations. It means that the time it takes to complete an algorithm or operation increases linearly with the size of input.
let's look at the graph of O(n):

O(n^2):

In simple terms, O(n^2) means that the time or space complexity of an algorithm grows quadratically with the input size. To illustrate this with a code, let's write a 'for loop' inside another 'for loop'

def print_items(n):
    for i in range(n):
        for j in range(n):
            print(i,j)



print_items(5)

output:

so from 0,0 to 4,4 we have 25 items printed, the input size n = 5 but we got n * n = n^2 items printed which is 25, hence illutrating the quadratic relationship. 'for loop' inside another 'for loop'is a good example of O(n^2)
The graph:

0(1):

O(1) means that the time or space complexity of an algorithm remains constant regardless of the input size. This constant relationship is represented by O(1), also known as "constant time complexity." It means that the time or effort required to perform the task remains the same, regardless of the input size. Addition of the same number is an example of this:

def add_num(n):
    return n + n

add_num(1)


add_num(2000)

output:

2

4000

The other operations we've seen, as the input size increase, so does the number of operations but this constant time complexity is different. even if n = 100000000, there's just one operation to be done i.e, n + n = 100000000 + 100000000 = 200000000 and that is o(1), the constant time.
on the graph:

o(1) is represented by the horizontal blue line on the graph and this is the most efficient of big O, anytime you can optimize your code to O(1), that is the most efficient you can have it.

o(logn)

O(log n) indicates that an algorithm's time or space complexity increases logarithmically as the amount of the input increases.

Let's use the example of looking up a word in a dictionary to further comprehend this. Instead of starting from the first page and flipping through each page one by one, you can use a more efficient strategy. You might open the dictionary roughly in the middle and check if the word you're looking for comes before or after that page. Based on the result, you can eliminate half of the remaining pages and repeat the process. You may easily zero in on the place by repeatedly 'halfing' the search area.

O(log n), where "n" is the input size, represents this logarithmic relationship. It means that the task's time or effort requirements rise, but not proportionally, as the size of the input expands. As an alternative, it rises logarithmically. Let's write a traditional binary search in python

def binary_search(arr, target):
    low = 0
    high = len(arr) - 1

    while low <= high:
        mid = (low + high) // 2  # Find the middle index

        if arr[mid] == target:  # if the the middle element is the target
            return mid
        elif arr[mid] < target:  # If the target is greater, search the right half
            low = mid + 1
        else:  # If the target is smaller, search the left half
            high = mid - 1

    return -1  # Target not found

# Example usage
arr = [2, 5, 7, 12, 16, 21, 28, 36]
target = 16
result = binary_search(arr, target)
if result != -1:
    print("Target found at index", result)
else:
    print("Target not found")

The binary_search function in this code runs an O(log n)-time complicated binary search on a sorted list. The search space is divided in half repeatedly until the target element is located or the search space is used up.

The input parameters for the function are an array (arr) and a target value (target). Two pointers, low and high, are initialized to maintain track of the search range. It determines the middle index (mid) and compares the middle element with the desired value within the while loop. It updates the low and high search parameters in accordance with the comparison. It returns the index if the target can be found; else, it gives -1 to show that the target is not in the array.
The binary search algorithm exhibits the O(log n) time complexity property in that the number of iterations grows logarithmically as the size of the list increases.

Conclusion

Even if you are not preparing for an interview but you are interested in developing effective code, learning Big O notation is very helpful. Big O notation enables you to comprehend algorithm efficiency, make wiser software development decisions, and interact with other developers. It is a helpful tool for increasing performance and developing software that is more effective.

I published an article detailing how I used Python to solve the LeetCode challenge "Two Sum". I came up with two methods, the first of which was my first strategy. I was simply interested in getting the code to function; I didn't care about how much space it took up or how quickly it ran. By using my understanding of Big O, I was able to create a second, more effective approach. The article is accessible here. Two Sum - LeetCode problem 1 solution in python

here's also Big O cheatsheet

say hi to me on Twitter @Sammie_savvie

How I solved an ImportError Issue in Django

Aderibigbe Samuel — Fri, 09 Jun 2023 00:45:11 +0000

I was trying to create a URL shortener app in Django. So, I started with the basic setup. However, when I attempted to start a new project using the command "django-admin startproject ", I encountered an error message: "ImportError: cannot import name 'Iterator' from 'collections' (/Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/collections/init.py)".

From the error message, it is obvious that there is something wrong with importing the Iterator class from the collections module.

What is the Iterator class

In Python, the Iterator class is a built-in class that represents an iterator object. An iterator is an object that implements the iterator protocol, which consists of two methods: iter() and next().

An iterator is a Python object that facilitates iterating through a group of things one at a time. Consider it a means to perform a specified action on each item in a collection or access them all at once.
Python comes with a built-in class called Iterator that gives you the ability to make your own unique iterators. Two unique methods, iter() and next(), create a set of rules that an iterator must abide by.

The iterator's beginning is similar to the procedure iter(). It gets the iterator ready to start the iteration process or restart it.
The next item is obtained from the iterator using the next() method. It hands you the current item before moving on to the following one. It notifies you if there are no more items by raising a unique signal known as the StopIteration exception.
You can specify how you wish to iterate over a collection of things or include your own custom logic by building your own iterator. An iterator could, for instance, count from 0 to a specified number, carry out certain operations on each item, or iterate over your own unique objects.

Here is a straightforward illustration of how an iterator functions:

Consider that you wish to examine each marble in your bag of colorful marbles one by one. You could accomplish it with the iterator. When you request the marble, it gives it to you while keeping track of the existing marble. When you reach the last marble, it tells you that there are no more marbles left.
An example of a custom iterator that counts from 0 to a specified number:



class MyIterator:
    def __init__(self, max_num):
        self.max_num = max_num
        self.current = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.current < self.max_num:
            num = self.current
            self.current += 1
            return num
        else:
            raise StopIteration()

To use the custom Iterator,



my_iterator = MyIterator(5) 
for num in my_iterator:
    print(num)

Understanding iterators will allow you to use them with loops, such as for loops, to quickly iterate across collections of things. Additionally, a lot of Python objects, including lists, strings, and dictionaries, are already iterable, which means you can use an iterator with them.

so, back to the error

I did a little research online and I got to know that this error is usually encountered when using Python 3.10 or higher, as the Iterator class was moved to a different location in the Python standard library starting from Python 3.10.

You can fix this problem by changing the import statement in your Django project's source code. What you can do is:

Find the file containing the problematic import statement. /Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/collections/init.py, an internal Python library file that is generally not a file you would edit, is mentioned in the error message.

Open the error-related file or any other file in your project that makes use of the collections.Iterator import.

To import Iterator from the proper location, modify the import statement. Import it from collections.abc rather than from collections. Substitute the following import statement for the current one:



from collections.abc import Iterator

Save the file and try running your Django project again. The error should no longer occur.

You may ensure compatibility with Python 3.10 and later versions, where the Iterator class was moved to the collections.abc module, by importing Iterator from collections.abc rather than collections.

Now if I type django-admin startproject in my terminal, There will be no more error and the code works

when I open my text editor, the project is now created

A less nerdy method to solve this same problem is to:

Verify Django version compatibility: Make sure the Django version you're running is compatible with the Python version you have installed. To figure out which version to use, look over the Django documentation or the project requirements.

Run the following command in your terminal to verify the version of Python you have installed:

python --version

Update Django: If the problem still exists even though you are using the right version of Python, try updating your Django installation to the most recent version that is compatible. To update Django, use the following command:

pip install --upgrade django

Now you can try creating the django project again and it will run without any error.

Thanks for reading,

say hi to me on twitter @Sammie_savvie

Linux terminal for beginners - A quick guide

Aderibigbe Samuel — Tue, 23 May 2023 18:27:38 +0000

Do you know that there was a time when computers only display texts and the only input device to tell the computer what to do was the keyboard? Yeah, computers were used by the few who understood how to input commands and then interpret the text information displayed on the computer screen. Here was the workflow, users could only interact with the command line by typing text-based commands and an action is performed or a text information is displayed. Back then, users had to be very careful with typing commands because one wrong command can perform an unwanted action or delete a file or even close the command line program. So the use of computer was limited in a way until the invention of mouse in 1964 and Ivan Sutherland's invention of a computer program called sketchpad which was regarded as the first Graphical User Interface program. Graphical User Interface GUI makes use of graphical icons and audios to help users interact well with the computer.

when you want to open your browser, you would click on the browser icon with your mouse or trackpad on your pc, right? But you could do the same on your command line by typing some texts. let's say I want to open safari (a web browser) from the command line, I will type the following texts:

open -a safari

So, which is easier? clicking icon or typing texts? yeah, it's straight forward GUI is easier but not necessarily faster.

Shell while GUI and Command line interface(CLI) are the ways we can the interact with the computer, Shell is really the program responsible for helping the operating system understand the commands. you would hear words like Window shell and Bash (Bourne Again Shell). BASH Linux is very popular because it's open source and free. Windows operating system comes with it's own shell called windows shell but you can also install Linux on Windows, click here on how to install linux on windows

Now, let's learn how to perform some operations using Linux commands

Windows users: Open PowerShell or Windows Command Prompt
Mac Users: Open the Terminal app

Here are some of the frequently used commands:
• cd (change down a directory)
• mkdir (make directory)
• cd .. (change up a directory)
• ls (list files in your current directory)
• pwd (print working directory)
• touch (create a new file)

Making a directory mkdir :
I'm sure on your desktop you have some folders and inside those folders you have kept some files there. Making a directory is doing the same thing, so for the purpose of this tutorial think of making directories and creating folders (even though a directory is different from a folder). The first thing you would determine is the location to create your folder, maybe on desktop, downloads or even inside another folder. Let's say I want to create a directory(folder) on my desktop, so the desktop is the location I want to keep the folder. First thing is to navigate to the location by typing:

 cd ~/desktop

So I have navigated into my desktop location, I can then create the directory, let's assume the directory name is "projects", I will use the mkdir command :

 mkdir projects

if you correctly typed this command, you wouldn't see anything change but if you minimize your powershell or terminal and go to your desktop, you will see a folder called "projects" created.

Create Files inside a Folder:
Imagine you need to create a file in a folder, remember we've created directory called projects? now, let's create a file say "homepage.html" (the .html is the file extension for html documents). first navigate into the "projects" directory which is the location where you want to store your file:

 cd projects

Now we've changed our directory from "desktop" to "projects", we can then create the file by using the touch command:

touch homepage.html

again, if you go on your desktop and open the "projets" folder, you will see a file named "homepage.html". Notice how we navigated from desktop → projects, usually if you are using a GUI you can easily see which location you are, be looking at some icons but if you want to know which current directory you are on the command line, you need to ask by using the pwd command:

pwd

you would see something like this:

(base) Savvies-MBP:desktop sammiesavvie$ cd projects
(base) Savvies-MBP:projects sammiesavvie$ pwd
/Users/sammiesavvie/desktop/projects
(base) Savvies-MBP:projects sammiesavvie$

/Users/sammiesavvie/desktop/projects is the path to the current directory I am working on and it also means that I am in the "projects" directory.
often times when your see paths like /sammiesavvie/desktop/projects, it means the destination is "projects" but "projects" folder is inside desktop directory while "desktop" is also inside "sammiesavvie" directory.

Now that I am in the "projects" directory, Let's imagine I want to go back to the desktop, desktop ← projects. In GUI, you would usually see a go back icon but on the command line you need to type this command:

cd ..

Now I have navigated back to my desktop directory

List all files in a directory:

To see all the files in a particular directory, make sure you have navigated into the directory and then type this command:

ls

You can see the files I have in my project folder is listed, there are some hidden files that is excluded tho. to include the hidden files use:

ls -a

Rename and Delete files:
If a file named homepage.html is inside my projects folder and the projects folder is inside the desktop directory, the path to the file will look like this ~/desktop/projects/homepage.html. To rename a file use mv . for example to rename homepage.html to about.html

~/desktop/projects/homepage.html ~/desktop/projects/about.html

This will rename the file. while this method works, it can also be tricky in that you need to be able to provide the correct path and the file name. usually I will just nagivate my way to the file from desktop → projects:

cd ~/desktop

note that you do not need this command if you are already on your desktop

cd projects

Now to rename the file:

mv homepage.html about.html

Now, I do not see any prompt that the file has been renamed but if I look at the "projects" folder, I will see that the file has been renamed, I can also do see this by using the ls command:

I now see the file renamed as "about.html"

Delete a file:
To delete a file i will use the rm command but be sure that you are in the right directory when the file is located:

rm about.html

so far, I have talked about:

[x] cd -to change directory
[X] mkdir -make directory
[X] ls -list files
[X] pwd -print working directory
[X] touch -to create a new file
[X] cd .. -change up directory
[X] mv -to rename a file
[X] rm -delete a file

This are most of the Linux commands for working with files.

In this article, You have learnt the two ways we interact with the computer and how you can use Linux commands to work with files using CLI. Although, Command Line interface may seems difficult and stressing but understanding it is important as it is very powerful and fast.

How to create a stores Rest API using Flask

Aderibigbe Samuel — Wed, 29 Mar 2023 07:42:06 +0000

In this tutorial, I'll show you how to build an API using the RESTful architecture and here's what the API will be able to do; receive requests from a client(such as a web application) and respond with some data. Using the API, clients will be able to create store and create items within a store. One of the main benefits of REST APIs is that they rely on the HTTP standard, which means you can use XML, JSON, HTML, etc for processing data. This makes REST APIs fast, and lightweight-which is necessary for web apps.

Article Summary

What is an API?
What makes an API Restful?
Creating a store Restful API
Initial set up for Flask App
Defining the API endpoint
Testing the API
Create New Stores
Conclusion

What is an API?

API stands for Application Programming Interface, which is a way for two or more computer programs to communicate with each other. APIs are more like a contract, they tells us how to use them and what sort of data we should expect to receive, they are meant to make your work as a developer easier by providing abstraction from what happens underneath. Think of a simple website, it has HTML, CSS, and Javascript, all working together to give you a web page. An API is just the data, and you often need to combine data with HTML, CSS, and Javascript. In its basic form, an API is a data-only communication between the server and the client.

What makes an API Restful?

The term REST is an acronym for Representational State Transfer and it is an architectural style that describes the architecture of the web. It is a set of rules or conventions on how to structure an API. When you follow this set of rules to create an API, it gives your API some properties which then make the API restful. The REST architectural style defines six guiding constraints which are:

client-server communication
stateless communication
caching
uniform interface
layered system
code on demand

Creating a store Restful API

Let's build a store API

Prequisites:

You'll need:

pip installed on your pc
Python 3.10 on your Windows or Mac
A Text Editor
Insomnia(an API testing tool)

Installing Python 3.10 on Windows OS:

Before you can start this tutorial, you need python 3.10 or a later version installed on your pc. There are different ways to get python installed on your pc but I will be explaining the easiest way. You can download and install the Python 3.10 installer from the Python download page here, choose either the 32-bit or 64-bit version depending on your PC (check your PC's information) and make sure to add python 3.10 to path.

To check if the installation was successful, You can go into your command prompt and type the following:

$ python --version

it should output the version of python installed on your pc.

Installing Python 3.10 on Mac OS:

For mac users, the easiest way is probably using a macOS 64-bit universal2 installer. Just go to https://www.python.org/downloads/release/python-3100/ and choose the macOS 64-bit universal2 installer, download the installer, and run it on your mac. You can just click this link to start the download right away.

To check which python version you have, type the following on your command prompt:

$ python3 --version

Initial set up for Flask App

First, you need to create a virtual environment and install the dependencies. Before we proceed, you should have created a project folder and navigated to that folder on your terminal or powershell.
To create the virtual environment type:

python3.10 -m venv .venv

Depending on the text editor you are using, you need to select which interpreter to use and it should be the one that has the path to your virtual environment. Do not know how to do this? A quick google search will help you. for Visual studio code( a popular text editor) the shortcut is command+shift+P.

let step is to install flask:

pip install flask

Now that You have flask installed, let's create a boiler plate. Go into your text editor and create a file, let's call it app.py and the follow lines of code

from flask import Flask 

app = Flask(__name__) #this creates a flask app

make sure that your file name(app.py) is consistent with the name of your variable 'app' (remember python is case-sensitive).
The next step is to run the flask app, you can do these from your terminal or powershell. Make sure you are in the app.py directory and your virtual environment is activated. To run the flask app:

flask run

you should see something like this:

you get the information of where your app is running in our example, it is running on http://127.0.0.1:5000

Defining the API endpoint

When an API interacts with another system, the touchpoints of this communication are considered endpoints. The place that APIs send requests and where the resources are stored is called an endpoint. simply put, An endpoint is one end of a communication channel.
We need to define where we will store our data. Usually, you will make use of databases but for this tutorial we will store our data in a python list. So, you will create a list of stores that consists of one dictionary per store.

from flask import Flask

app = Flask(__name__)

stores = [
    {
    "name": "Ekaabo Cosmetics",
    "items":[
    {"name" : "lip gel",
     "price" : 20.36
     },
    {"name" : "moisturizer",
     "price" : 38.90
     }, 
     {"name" : "hair wigs",
      "price" : 50.89
      },
      {"name" : "Body Cream",
       "price": 12.46}]
    }
    ]
    }
]

what we've done is simple, dictionaries consist of key-value pair. For the example above, there's a name key and the value is the actual name of the store. The confusing part would be the items, the key is "items", the value consists of a list which in turn consist of dictionaries of name and price pair, hope it sinks.

Now let's create an endpoint that will return data when a client requests for it. Add the following lines to your code:

@app.get("/store")
def get_stores():
    return {"stores" : stores}

The endpoint is the "/store" while the function associated with it is the get_stores().
Since our app is running on http://127.0.0.1:5000, go to your browser and enter http://127.0.0.1:5000/store to access the page, but before that run the flask application again in the terminal:

flask run

Now you can open the link on your browser:

Note that the data displayed is in JSON format and ordering does not matter as seen above that the order does not follow how we wrote the data.

Testing the API

To verify that the API works, you need to test it, by making requests and check that the responses match what we expect. There are tools you can use to test your API e.g Postman, Locust, Insomnia,etc. For the purpose of this tutorial, We'll use Insomnia, it has a free trial and ids easy to use. You can can download it by clicking here

Now that the app is runnning on your pc, let's test our API, click on the + icon to select "HTTP Request", then enter the url http://127.0.0.1:5000/store in the GET search bar. You must ensure your flask app is running before you enter the URL and click send

After entering the URL in the GET search bar, you can output like this:

You should see the data that your API returns. It means the API's GET request is working fine.

Create New Stores

To create new store in our API,we will be receiving JSON from our client(Insomnia App), We'll receive the stored data and add it to our stores list, so that it then stays and the client can make requests to retrieve them. Instead of using a GET request, You will use a POST request and you need to include some JSON data

Now go into your text editor and add the following lines of code in the 'app.py' file:

from flask import Flask, request #I modified this line


app = Flask(__name__)

stores = [
    {
    "name": "Ekaabo Cosmetics",
    "items":[
    {"name" : "lip gel",
     "price" : 20.36
     },
    {"name" : "moisturizer",
     "price" : 38.90
     }, 
     {"name" : "hair wigs",
      "price" : 50.89
      },
      {"name" : "Body Cream",
       "price": 12.46}]
    }
    ]


@app.get("/store")
def get_stores():
    return {"stores" : stores}


@app.post("/store")
def post_store():
    request_data = request.get_json() # you need to import json
    new_store = {"name": request_data["name"], "items":[]}
    stores.append(new_store) #append new store to the list
    return new_store, 201 #return the store and status code

Now run the flask application in the terminal or powershell and then go to the Insomnia app and make a POST request.

Let's include some JSON data:

Now, hit the send button and you will the output:

You get a status message "successfully created".

Conclusion

In this article, we covered what APIs are and what makes an API Restful. You now understand how APIs helps with interaction between the client and the server. You built a simple stores API and tested it using Insomnia.

Two Sum - LeetCode problem 1 solution in python

Aderibigbe Samuel — Wed, 15 Mar 2023 18:15:12 +0000

In this article, I will be sharing my approach to solving the Two sum problem on LeetCode. Like every other problem, the important thing is how you approach the problem or what we call an algorithm in programming, it does not really matter the language used. The approach in this tutorial can be used in any programming, not just python alone.

Motivation: I spend most of my free time on hackerRank and leetCode trying out different problems. This will help improve your problem-solving skills.

Two sum problems: Link to problem on leetCode

My First Approach The simple approach is to use two nested loops. when we have two nested loops, one is the outer loop while the other is the inner loop. Since the first input is a list, the outer loop iterates over all the elements of the list, and the inner loop iterates from the current index of the outer loop up to the end of the list. here's the part where you want to grab a pen and paper and write a simple algorithm

⏩ Writing the Code

✅ ✅ ✅ The code works

while the solution passed all the cases, You can see that the time complexity is not good enough and the code can be improved to execute faster. here the complexity is quadratic O(N²) which means the performance is proportional to the square of the size of the input elements. The code can be written efficiently if we make use of a dictionary and iterate over the list just once

✏️✏️ The Algorithmn

⏩ The code

✅ ✅ ✅ The code works: this time the code didn't just work but it was more faster

The complexity of this algorithm is O(n) which is faster than the one we implemented previously

Conclusion In this short guide, I showed you two approaches I used to solve the Two sum problem on leetCode. The first solution was good but not efficient while the second solution was more efficient. I hope I was able to make you see the importance of writing out your algorithm first before solving the problem and finally this approach can be used in other languages too.

say hi to me on Twitter @Sammie_savvie

Upload files to Github - a comprehensive guide

Aderibigbe Samuel — Thu, 16 Feb 2023 17:08:23 +0000

You just finished a project on your local PC. You are looking for a place to keep it so that you can access it anywhere and anytime or you just started a new project and you will be developing over a long time with some of your friends but you need to make it accessible to them, Hold on this article is for you.

Over the years, GitHub has been the most popular internet hosting service for version control using Git. GitHub makes it easy for you to store your files, track changes made to your files and collaborate on software projects. Github also serves as a portfolio site where developers can showcase their work, ask others to review it and work on open-source projects. So I'm sure You would have known by now that using GitHub is a good idea for you.

In this article, I will be guiding you on how you can setup Git on your PC and start loading files to your GitHub account from your local computer.

Article Summary:

Create a GitHub account
Download and Setup Git
Upload files on Github
Other Git commands you'll need

Create a Github account

Before you can start using Git and GitHub, the first thing is to download a GitHub account. Go to your browser and search GitHub or click this link github.com

Click on the signup button and follow the steps to finish setting up your account. Now that you have an account, You need to create a new repository. A Git repository helps to save and track all the changes made to your files.
To create a new repository, click on repositories and click on new. You can decide to make the repository private or public. Public, if you want others to have access to it and private, if you want to keep the files to yourself.

Extra tips: Choose a file name that gives an intuition about what your project is about e.g myPortfolioWebsite, LearningApp, Hotel_landing_page, etc also include a readme file where you write a good description of your project.

Download and Install Git

Before you can start using Git, you need it installed on your pc. There are different ways to get git installed on your pc but I will be explaining some of the easiest ways.

Window Users
Download the latest version of Git and choose either the 32-bit or 64-bit version depending on your PC (check your PC's information).

Install the downloaded file. Once installed, launch the Git bash and finish the setup.
You can read more on installing Git on windows here

Mac Users
For mac users, the easiest way is probably using a binary installer. Just go to https://git-scm.com/download/mac and choose the binary installer option, download the installer, and run it on your mac

Linux Users
Linux distribution comes with a package management tool that makes it simple to install git
From your shell, install Git using:

$ sudo apt install git-all

Verify the installation was successful by typing:

$ git --version

Configure Git

Now that you have successfully installed Git on your system, You need to do some setup to customize your experience using Git.
Git Email and username: replace 'savviesammie' with your GitHub username

$ git config --global user.name "savviesammie"

$ git config --global user.email "savviesammie@gmail.com"

Upload Files on GitHub

Remember the repository You created at the beginning of the tutorial? You will be cloning it on your pc and interacting with Git from your terminal. So go to your terminal and follow the tutorial.
cloning a repository means you are copying the repository from GitHub to your local computer.

Step 1: Clone the repository
Go to the repository you created on GitHub, click the green "code" button, and copy the link to your repository from the drop-down.

Step 2: Go to your terminal and type
git clone

$ git clone https://github.com/savvieSammie/password_manager.git

Replace the "repository url" with the link you copied.
make sure you have a good internet connection on your pc as you will be downloading the directory.

Step 3: Put your files in the cloned repository:
Open the empty directory and add the files that you want to upload. Say for example, you have written some codes using a text editor and you have the file saved on your pc, transfer the file to the directory you cloned from GitHub and make sure to Confirm the list of files present

Step 4: Git add
Add the files to Git's staging area by typing

$ git add .

Step 5: Commit the files to Git by using the git commit command

$ git commit -m "some message"

replacing "some message" with a short description of the changes you made to the first. In your case, since it's the first time, you can just write "first commit"

Step 6: Set your remote repository
Earlier in step 1, you copied the url to your remote repository. You need it here to setup your remote repository, use the command
$ git remote add origin

for example:

 git remote add origin https://github.com/savvieSammie/password_manager.git

Step 7: Git to push
push those files to your GitHub by using the command
$ git push

$ git push -u origin master

The origin is your default remote repository name and the '-u' flag is upstream.
You will be prompted to fill in your GitHub username and password.

Now you can go to GitHub on your web browser, you will see the changes reflected.

Other Git Commands you need

git init - Initialize local a new repository
git status -shows what you have in your staging area
git add - adds files and folders to the staging area
git diff - compare and understand changes made to your files
git log - is used to view the log of the project's history.
git push - Takes a local repository and pushes to a remote repository (Github).
git show - to show the details of a specific commit
git pull - Pull latest changes from remote repository
*git clone *- Clone repo from GitHub

To view the official Git cheatsheet from Github, click Git cheat sheet

Conclusion

In this article, I have shown you how to create a GitHub account, setup Git on your PC and how to upload files from your local computer to GitHub. I also included some Git commands that you'll need.
By now, you should have Git running on your pc and also you have gained basic working knowledge of Git and Github.

Say hi to me on Twitter @Sammie_savvie