DEV Community: Hafid Saadi

How can and why should accounting automate its processes?

Hafid Saadi — Mon, 13 Mar 2023 12:19:40 +0000

The accounting profession has traditionally been known for its meticulous attention to detail and manual data entry. However, with the advent of new technologies and automation tools, accounting departments can now automate many repetitive tasks, allowing them to focus on more strategic activities.

After experiencing the inefficiencies of accounting processes and data processing, I decided to get into computer programming. The goal was to equip myself with the necessary skills to help companies make the digital shift.

In this article, we'll take a look at some of the reasons why accounting departments should consider automating repetitive tasks:

Increased Efficiency

By automating repetitive tasks, accounting departments can reduce the time and effort required to perform these tasks. This can free up staff time to focus on more strategic activities such as financial analysis and business planning.

Reduced Errors

Manual data entry is prone to errors, which can result in costly mistakes and delays. By automating repetitive tasks such as data entry and report generation, accounting departments can reduce the risk of errors and ensure greater accuracy and consistency.

Improved Compliance

Compliance regulations such as GAAP and SOX require companies to maintain accurate financial records and provide timely reporting. Automation can help accounting departments to comply with these regulations by ensuring that data is accurate, consistent, and up-to-date.

"Automation is not a silver bullet, but a key enabler for growth, customer experience, and cost savings." - Shantanu Ghosh

Cost Savings

By automating repetitive tasks, accounting departments can reduce labor costs and increase efficiency. This can result in significant cost savings for companies, particularly those with large accounting departments.

Scalability

As companies grow, their accounting needs become more complex. Automation can help accounting departments to scale their operations and handle larger volumes of data and transactions without adding more staff.

Improved Decision Making

By automating repetitive tasks, accounting departments can provide real-time data and insights to business leaders, enabling them to make more informed decisions.

"Automation is a mindset, not a technology." - Scott Berkun, Author and Speaker

Here are some examples of tasks that accounting departments can automate:

Data entry
Bank reconciliations
Invoice processing
Expense tracking and reporting
Budgeting and forecasting
Financial analysis and reporting

There are many automation tools available to accounting departments, including accounting software such as QuickBooks and Xero, OCR technology, RPA, APIs, and workflow automation software.

In conclusion, accounting departments can benefit from automating repetitive tasks by increasing efficiency, reducing errors, improving compliance, and providing real-time data and insights. Automation can also result in cost savings and enable accounting departments to scale their operations as companies grow. By leveraging automation tools and technologies, accounting departments can focus on more strategic activities and provide greater value to their organizations.

How to use GetForm.io to manage your website forms without having to build a backend?

Hafid Saadi — Fri, 10 Mar 2023 02:10:00 +0000

How to Use Getform.io for Form Backends

Introduction

Getform.io is a form backend platform that allows developers to easily create custom forms and receive form submissions without having to build a backend system from scratch. In this guide, we'll walk you through the steps to set up a form and receive form submissions using Getform.io.

Prerequisites

Before you begin, you'll need the following:

A Getform.io account
A website or application where you want to add a form
Basic knowledge of HTML and JavaScript

Step 1: Create a Form

To create a form in Getform.io, follow these steps:

Log in to your Getform.io account.
Click the "Create a Form" button.
Enter a name for your form and click "Create".
Customize your form by adding fields, changing labels, and selecting field types.
Click "Save" to save your changes.

Step 2: Embed the Form

Once you've created your form in Getform.io, you can embed it into your website or application using the provided code snippet. To do this, follow these steps:

Copy the code snippet provided in the "Embed" tab of your form in Getform.io.
Paste the code snippet into your website or application's HTML code where you want the form to appear.

<form action="https://getform.io/f/{your-form-endpoint}" method="POST">
  <input type="text" name="name">
  <input type="email" name="email">
  <input type="text" name="message">
  <button type="submit">Send</button>
</form>

Step 3: Receive Form Submissions

After your form is embedded, you'll need to set up where you want to receive form submissions. Getform.io allows you to receive form submissions through email or webhook. To set this up, follow these steps:

Option 1: Receive Submissions via Email

In the "Settings" tab of your form in Getform.io, click the "Add Notification" button.
Enter the email address where you want to receive form submissions and click "Save".

Option 2: Receive Submissions via Webhook

In the "Settings" tab of your form in Getform.io, click the "Add Webhook" button.
Enter the URL where you want to receive form submissions and click "Save".

Conclusion

Congratulations! You've successfully set up a form and are now ready to receive form submissions using Getform.io. If you have any issues or questions, be sure to check out the Getform.io documentation or contact their support team for assistance.

learn more:
getFrom
getFrom-Docs

What is Docker and how it can make your life way easier?

Hafid Saadi — Tue, 28 Feb 2023 18:10:07 +0000

While working on a project for my degree at 42 Quebec, I discovered DevOps and thus a new passion. This little tutorial is the first of a series talking about Docker, Kubernetes, Ansible, Teraform and many other tools needed to become a great DevOps engineer. So let's start With Docker, but what is Docker and why is learning it such a big deal?

Docker and Its Utility

Docker is a containerization platform that allows you to build, ship, and run applications in a consistent and portable way. It is used to package an application along with its dependencies into a container, which can then be deployed on any system that has Docker installed. Docker containers are lightweight, fast, and isolated, making them an ideal choice for deploying applications in production.

How Docker Works

Docker works by using a layered file system and image-based containerization. Each Docker container is built from an image that includes all the dependencies needed to run the application. Images are built using a Dockerfile, which is a text file that contains the instructions for building the image. The Dockerfile specifies the base image, the commands to install the dependencies, and any additional configuration needed to run the application.

Once the image is built, it can be used to create Docker containers. Each container runs in its own isolated environment and has its own file system, network interfaces, and processes. Containers can communicate with each other through a shared network, making it easy to deploy and manage multiple applications on a single system.

Benefits of Docker

There are several benefits to using Docker for application deployment:

Portability

Docker containers are portable, meaning that they can be run on any system that has Docker installed. This makes it easy to move applications between development, staging, and production environments without worrying about dependencies or configuration issues.

Consistency

Docker containers are consistent, meaning that they provide the same environment for running an application regardless of the host system. This eliminates the "works on my machine" problem that can arise when developing and deploying applications on different systems.

Scalability

Docker containers are lightweight, meaning that they can be quickly spun up or down to meet changes in demand. This makes it easy to scale applications horizontally by adding or removing containers as needed.

Isolation

Docker containers are isolated, meaning that they provide a secure environment for running applications without affecting the host system. This makes it easy to run multiple applications on a single system without worrying about conflicts or resource contention.

Getting Started with Docker

To get started with Docker, you'll need to install Docker on your system. Docker provides installers for Windows, macOS, and Linux. Once Docker is installed, you can start building Docker images using a Dockerfile and creating Docker containers from those images.

Here's an example Dockerfile for a simple Node.js application:

FROM node:14-alpine

WORKDIR /app

COPY package*.json ./

RUN npm install

COPY . .

EXPOSE 3000

CMD ["npm", "start"]

This Dockerfile specifies that we want to use the node:14-alpine base image, set the working directory to /app, copy the package.json and package-lock.json files to the container, install the dependencies using npm, copy the application files to the container, expose port 3000, and start the application using npm start.

To build the Docker image, run the following command:

docker build -t my-node-app .

This command tells Docker to build a Docker image with the tag my-node-app using the Dockerfile in the current directory (.).

To create a Docker container from the image, run the following command:

docker run -p 3000:3000 my-node-app

This command tells Docker to create a Docker container from the my-node-app image and map port 3000 on the host system to port 3000 in the container.

Conclusion

Docker is a powerful tool for building, shipping, and running applications in a consistent and portable way. Its benefits include portability, consistency, scalability, and isolation, making it an ideal choice for deploying applications in production. With Docker, you can easily package your application along with its dependencies into a container and deploy it on any system that has Docker installed. Whether you're a developer, system administrator, or IT professional, Docker can help simplify your workflow and streamline your application deployment process. Give Docker a try and see how it can help you build and deploy applications more efficiently.

Learn more:
Docker.com
tutorialspoint

Tutorial: 1

Mastering Polymorphism in C++: Understanding and Implementing Virtual Functions and Template Classes

Hafid Saadi — Fri, 13 Jan 2023 04:20:25 +0000

Polymorphism is a fundamental concept in object-oriented programming that allows a single function or object to have multiple forms. In this blog post, we will explore polymorphism in the C++ programming language and provide examples of how it can be implemented.

One way to achieve polymorphism in C++ is through the use of virtual functions. A virtual function is a member function that is declared as virtual in the base class and can be overridden by derived classes. When a virtual function is called through a base class pointer or reference, the program will determine at runtime which version of the function to execute based on the type of the object being pointed to or referenced.

Here's an example of a simple base class, "Shape," that has a virtual function "draw()":

class Shape {
public:
    virtual void draw() = 0;
};

We can then create two derived classes, "Circle" and "Rectangle," that override the "draw()" function:

class Circle : public Shape {
public:
    void draw() {
        // code to draw a circle
    }
};

class Rectangle : public Shape {
public:
    void draw() {
        // code to draw a rectangle
    }
};

We can then create a pointer of type "Shape" and point it to an object of type "Circle" or "Rectangle." When we call the "draw()" function through the pointer, the program will determine at runtime which version of the function to execute:

int main() {
    Shape* shape1 = new Circle();
    shape1->draw();  // calls Circle::draw()

    Shape* shape2 = new Rectangle();
    shape2->draw();  // calls Rectangle::draw()
}

Another way to implement polymorphism in C++ is through the use of template classes. A template class is a generic class that can work with different data types. This allows a single class or function to have multiple forms based on the type of data it is working with.

Here's an example of a simple template class, "Stack," that can hold elements of any data type:

template <typename T>
class Stack {
    T* data;
    int size;
public:
    Stack(int size) {
        this->size = size;
        data = new T[size];
    }
    void push(T element) {
        // code to add element to stack
    }
    T pop() {
        // code to remove and return top element from stack
    }
};

We can then create objects of the "Stack" class for different data types, such as "Stack" and "Stack":

int main() {
    Stack<int> intStack(5);
    intStack.push(1);
    intStack.push(2);
    intStack.pop();  // returns 2

    Stack<string> stringStack(5);
    stringStack.push("hello");
    stringStack.push("world");
    stringStack.pop();  // returns "world"
}

As we have seen in these examples, polymorphism in C++ can be achieved through the use of virtual functions and template classes. These features of the language allow a single function or object to have multiple forms, making the code more flexible and reusable.

Learn more about polymorphism:
wikipedia
stackify.com

Creating a Chatbot that Answers like Bart Simpson using Python3 and the OpenAI GPT Model.

Hafid Saadi — Tue, 10 Jan 2023 02:11:07 +0000

In this tutorial, we will build a chatbot using the OpenAI API and Gradio. Our chatbot will be based on the character Bart Simpson from The Simpsons and will be designed to have a mischievous and rebellious personality.

Prerequisites

To follow along with this tutorial, you will need the following:

A text editor like VsCode
Python 3.6 or higher
The OpenAI API key from openai.com
Git (optional)

Setting up the Project

First, let's create a new project directory and set up our virtual environment:

mkdir chatbot
cd chatbot
python -m venv env
source env/bin/activate

Next, let's install the required dependencies:

pip install openai gradio

Writing the Code

Now, let's write the code for our chatbot. We will start by creating a file named gpt.py and adding the following code:

The prompt
get_response function that leverages the OpenAi Api to query the Davinci model and returns the answer in text.

import openai
import gradio as gr

PROMPT = """The following is a conversation with Bart Simpson. 
As Bart Simpson, I would describe myself as a mischievous, rebellious, and adventurous kid.
I'm always getting into trouble and finding new ways to have fun and cause chaos.

Me: Hello, who are you?
Bart: Hey, it's great to hear from you! Not much has changed here in Springfield. What about you, what have you been up to?
Me: """

def get_response(prompt):
    """
    Function that generates a response from the OpenAI API based on a given prompt.

    Parameters:
    - prompt (str): The prompt to generate a response for.

    Returns:
    - response (str): The response from the OpenAI API.
    """
    response = openai.Completion.create(
        model="text-davinci-003",
        prompt=PROMPT,
        temperature=0.9,
        max_tokens=150,
        top_p=1,
        frequency_penalty=0,
        presence_penalty=0.6,
        stop=[" Me:", " Bart:"]
    )
    return response.choices[0].text

In this part, create a file named main.py and add the following code:

Cloning_gpt function that generates a response based on a given input and conversation history.
Opening the Gradio block that will give us the interface to interact with the chat bot.

import gradio as gr
from gpt import get_response


def cloning_gpt(input, history):
    '''
        Function that generates a response based on a given input and conversation history.

        Parameters:
        - input (str): The input to generate a response for.
        - history (list): A list of tuples containing previous inputs and outputs in the conversation.

        Returns:
        - history (list): The updated conversation history with the new input and output appended.
        - history (list): A copy of the updated conversation history.
    '''
    history = history or []  # if history is None, set it to an empty list
    past = list(sum(history, ()))  # flatten the history list
    past.append(input)  # add the current input to the history
    inputs = ' '.join(past)  # join the history into a string
    output = get_response(inputs)  # get the model's response
    history.append(
        (input, output))  # add the current input and output to the history
    return history, history  # return the history as both the output and the state


block = gr.Blocks()

with block:
    gr.Markdown("""<h1><center>ChatGpt "Bart version" </center></h1>""")
    chatbot = gr.Chatbot()
    message = gr.Textbox(placeholder="Hey I'm Bart Simpson, ask me anything!")
    state = gr.State()
    submit = gr.Button("SEND")
    submit.click(cloning_gpt,
                 inputs=[message, state],
                 outputs=[chatbot, state])

block.launch(
    debug=True, share=True
)  # debug=True to run locally and share=True to share the app publicaly

Laucnh the project

When launching the app, you can choose debug=True to run locally or share=True to share the app publicaly or both. USually the it can be accessible publicly for 72 hours.

Check out the Github repo

The Fundamentals of Floating Point Numbers in Computer Systems

Hafid Saadi — Mon, 09 Jan 2023 02:13:43 +0000

As a programmer, you may have heard the term "floating point number" thrown around, but may not fully understand what it means or how it is represented in a computer system. In this post, we'll explore floating point numbers and how they are represented in computer systems.

A floating point number is a type of numerical representation that allows us to represent a wide range of values with a fixed number of digits. It is called a "floating point" number because the decimal point can "float" and represent values with a fractional component.

In computer systems, floating point numbers are usually represented in a format known as IEEE 754. This standard defines how floating point numbers should be represented in a computer system in order to ensure consistent behavior across different hardware and software platforms.

The IEEE 754 standard uses a "scientific notation" approach to represent floating point numbers. Essentially, a floating point number is represented as a mantissa and an exponent. The mantissa represents the significant digits of the number, and the exponent determines where the decimal point should be placed.

For example, consider the number 123.45. In scientific
notation, this can be written as 1.2345 x 10^2. In this
representation, the mantissa is 1.2345 and the exponent is 2.

In IEEE 754 representation, the mantissa and exponent are stored as binary numbers. The mantissa is typically stored using a fixed number of bits (such as 23 bits), and the exponent is stored using a larger number of bits (such as 8 bits).

Note that it may be stored using a fixed number of bits (such as 52 bits), and the exponent is stored using a larger number of bits (such as 11 bits).

One important aspect of floating point numbers is that they have a limited precision. This means that they can only represent a certain number of significant digits, and numbers with more digits will be rounded off. This can lead to some loss of accuracy when working with floating point numbers.

In summary, floating point numbers are a type of numerical representation that allows us to represent a wide range of values with a fixed number of digits. They are represented in computer systems using the IEEE 754 standard, which stores the mantissa and exponent as binary numbers. While they offer a lot of flexibility, they do have a limited precision and can introduce some loss of accuracy.

Learn more on cprogramming.c

From Berkeley university

2's Complement 101: A Beginner's Guide

Hafid Saadi — Fri, 06 Jan 2023 15:02:02 +0000

As a new programmer, you may have heard the term "2's complement" thrown around, but may not fully understand what it means. In this post, we'll explore what 2's complement is and why it's useful in computer science.

In computer systems, we often need to represent negative numbers. One way to do this is to use a system called "signed magnitude representation," in which the leftmost bit represents the sign of the number (0 for positive and 1 for negative) and the remaining bits represent the magnitude.

However, this system has a major drawback: there are two ways to represent zero (000000... for positive and 100000... for negative). This can lead to confusion and extra complexity when working with these numbers.

To solve this problem, we can use a system called "2's complement representation." In 2's complement, negative numbers are represented by the complement of their absolute value, plus 1. Confused? Let's take a closer look with an example.

Consider the number -5. In 8-bit 2's complement representation, it would be represented as follows:

First, we find the binary representation of the absolute value of -5, which is 5. This is 101 in binary.
Next, we take the complement of this value by flipping all of the bits. This gives us 010.
Finally, we add 1 to the result. This gives us 011, which is the 2's complement representation of -5.

To convert a 2's complement number back to its original value, we can follow the reverse process:

Take the complement of the number by flipping all of the bits.
Add 1 to the result.
If the leftmost bit is 1, the number is negative. If it is 0, the number is positive.

2's complement representation has several advantages over signed magnitude representation. It allows for easier arithmetic operations, as we only need to use the same techniques for positive and negative numbers. It also eliminates the problem of having two representations for zero.

In summary, 2's complement is a system for representing negative numbers in binary. It allows for more efficient arithmetic operations and eliminates the issue of having two representations for zero. As a new programmer, it's important to understand this concept as you may encounter it in your work.

Learn more Youtube Videos

Create a Youtube to MP3 Downloader with Python

Hafid Saadi — Thu, 05 Jan 2023 16:47:55 +0000

Python is a powerful programming language that can be used for many different purposes. One popular use for Python is creating a YouTube downloader, which allows you to save YouTube videos to your computer for offline viewing.

In this tutorial, we will walk through the steps of creating a YouTube downloader in Python using the youtube_dl library and a virtual environment (venv).

Prerequisites

Before we get started, make sure you have the following tools installed on your computer:

Python 3
pip (Python package manager)

Step 1: Create a Virtual Environment

A virtual environment is a separate Python environment that allows you to install packages and libraries specific to a particular project, without affecting the global Python environment on your computer.

To create a virtual environment in Python, open a terminal and navigate to the directory where you want to store your project. Then, run the following command:

python3 -m venv myenv

This will create a new directory called myenv in your current directory, which will contain the Python executable and all the necessary libraries for your virtual environment.

Step 2: Activate the Virtual Environment

To use the virtual environment, you need to activate it first. To do this, run the following command:

source myenv/bin/activate

You should now see (myenv) at the beginning of your terminal prompt, indicating that the virtual environment is active.

Step 3: Install the youtube_dl Library

Next, we will install the youtube_dl library, which provides the necessary functions for downloading YouTube videos. Run the following command to install youtube_dl

pip install youtube_dl

Step 4: Create the YouTube Downloader Script

Now that we have everything set up, we can create the script to download YouTube videos.

Create a new file called downloader.py and add the following code:

import youtube_dl

def download():
    video_url = input("please enter youtube video url:")
    video_info = youtube_dl.YoutubeDL().extract_info(url=video_url,
                                                     download=False)
    filename = f"downloads/{video_info['title']}.mp3"
    options = {
        'format': 'bestaudio/best',
        'keepvideo': False,
        'outtmpl': filename,
    }
    with youtube_dl.YoutubeDL(options) as ydl:
        ydl.download([video_info['webpage_url']])

    print("Download complete... {}".format(filename))

if __name__ == '__main__':
    download()

This script uses the youtube_dl library to download a YouTube video at the URL specified by the user. The video is saved in the downloads directory with the title of the video as the file name. The video is also converted to an MP3 file, which allows you to play the audio on any device that supports MP3 playback.

Step 5: Run the Script

To run the script, open a terminal and navigate to the directory where the script is located. Then, activate the virtual environment by running the following command:

check it on github

C++ is still widely used and popular, but why?

Hafid Saadi — Wed, 04 Jan 2023 16:01:27 +0000

C++ is a programming language that has been around for over four decades, and it is still widely used by developers today. In this post, we will explore why C++ remains relevant in the world of software development.

C++ is "doing very well", Tiobe CEO Paul Jansen, says in the company's September 2020 index for the world's most popular programming languages. C++ currently ranks fourth, behind C, Java, and Python

We can summarize the reasons in 4 points:

Performance

One of the main reasons C++ is still relevant is its performance. C++ is a compiled language, which means that it is generally faster than interpreted languages like Python and JavaScript. This makes it a good choice for performance-critical applications, such as games, operating systems, and scientific simulations.

"C++ is the most powerful programming language in the world. It can do absolutely anything you want it to do. And when it doesn't, you can use assembler." - John Carmack

Control

Another reason C++ is still relevant is the control it gives developers over their code. C++ allows developers to fine-tune the performance of their programs by manually managing memory and choosing when to use specific optimization techniques. This level of control is not possible with languages like Python and Java, which rely on garbage collection to manage memory.

Legacy code

There is a large amount of legacy C++ code in use today, and many organizations still rely on it to run their critical systems. This means that there is a demand for C++ developers who can maintain and update this code. If an organization has a large codebase written in C++, it may not be feasible to rewrite it in a different language, so they need C++ developers to continue supporting it.

"C++ is the work of the Devil. However, it is fast." - Linus Torvalds

Popularity

Despite the rise of other programming languages, C++ remains popular and is consistently ranked as one of the top languages by the TIOBE index and the PYPL index. This means that there are many job opportunities and resources available for C++ developers.

In conclusion, C++ is still relevant for a number of reasons, including its performance, the control it gives developers over their code, the large amount of legacy C++ code in use, and its continued popularity. It is likely to continue to be an important part of the software development landscape for the foreseeable future.

How Can Blockchain End Corruption?

Hafid Saadi — Tue, 03 Jan 2023 18:41:55 +0000

"Corruption is like a disease that attacks the body politic. It debilitates the government and weakens the popular will. It saps the strength of the nation, divides the people, and undermines justice." - Corazon Aquino, former President of the Philippines

According to Transparency International's Corruption Perceptions Index, which ranks countries based on the perceived level of public sector corruption, more than two thirds of countries score below 50 (on a scale from 0 to 100, with 0 being highly corrupt and 100 being very clean). This shows that corruption is a widespread problem that affects countries all over the world.

Here are a few examples of statistics on corruption:

In 2019, it was estimated that corruption costs the global economy around $3.6 trillion per year, or 5% of global GDP.
In 2018, the World Bank estimated that businesses and individuals in countries with high levels of corruption pay an average of 20% more for goods and services, due to bribes and other extra costs.
According to the World Economic Forum, corruption is one of the top risks facing businesses around the world. It can lead to increased costs, decreased efficiency, and reduced trust in institutions.
In a survey of over 1,000 businesses in Africa, Latin America, and Southeast Asia, almost half reported that they had lost business due to corruption.

These statistics demonstrate the significant economic and societal costs of corruption, and highlight the need for effective measures to combat it.

How the blockchain technology can play a role in combating corruption?

Blockchain technology has the potential to revolutionize many industries, including politics and government. One of the main ways it could do this is by helping to reduce corruption.

First, it's important to understand what blockchain is. Simply put, it is a decentralized, digital ledger that records transactions across a network of computers. It is secure, transparent, and immutable, which means that it is almost impossible to tamper with or alter the record once it has been added to the blockchain.

So, how can this technology help to end corruption? One way is by providing a permanent, unchangeable record of transactions. In a political or government setting, this could mean that all financial transactions and contracts are recorded on the blockchain. This would make it much harder for corrupt individuals to hide or alter financial records in order to cover up their wrongdoing.

Another way that blockchain could help to reduce corruption is by automating certain processes. Smart contracts, which are self-executing contracts with the terms of the agreement written into lines of code, could be used to automate the execution of contracts. This would make it much harder for corrupt individuals to manipulate the process in their favor.

"Corruption is like a ball of snow, once it's set a rolling it must increase." - Charles Caleb Colton

Finally, blockchain could help to increase transparency and accountability in government and politics. With all transactions and contracts recorded on the blockchain, it would be easier for citizens to see how their money is being used and hold their elected officials accountable for any mismanagement or corruption.

Overall, while blockchain technology is not a magic solution to corruption, it has the potential to significantly reduce it by providing a secure, transparent, and immutable record of transactions, automating certain processes, and increasing accountability.