DEV Community: Kibe🔌💻

The Ultimate Guide to Backend and Frontend Testing: Breaking Down the Essentials for a Flawless Application

Kibe🔌💻 — Wed, 12 Feb 2025 07:06:19 +0000

In today’s fast-paced digital world, the quality of your application can make or break your success. Whether you're a developer, QA engineer, or a tech enthusiast, understanding the intricacies of backend and frontend testing is crucial. This blog will dive deep into the world of testing, breaking down the essentials to help you build robust, secure, and user-friendly applications. Let’s break the internet with knowledge!

Why Testing Matters

Testing is the backbone of any successful application. It ensures that your software works as intended, delivers a seamless user experience, and remains secure against vulnerabilities. Without proper testing, even the most beautifully designed app can crumble under real-world usage. Let’s explore the key types of backend and frontend testing that every developer should master.

Backend Testing: The Hidden Hero of Your Application

The backend is the engine that powers your application. It handles data processing, business logic, and integrations with other services. Here’s how to ensure it runs smoothly:

1. Functionality Testing

What it is: Ensures that API endpoints, business logic, and workflows function as expected.
Why it matters: A single bug in the backend can disrupt the entire application. Functionality testing validates that every feature works correctly.
Pro Tip: Use tools like Postman or Swagger to automate API testing and ensure consistent results.

2. Performance Testing

What it is: Measures response time, load handling, and scalability under various conditions.
Why it matters: Slow or unresponsive backends can frustrate users and lead to lost revenue.
Pro Tip: Tools like JMeter or LoadRunner can simulate heavy traffic and help you identify bottlenecks.

3. Unit Testing

What it is: Tests individual functions, methods, or classes in isolation.
Why it matters: Unit testing catches bugs early in the development cycle, saving time and resources.
Pro Tip: Frameworks like JUnit (Java) or pytest (Python) make unit testing efficient and scalable.

4. Security Testing

What it is: Checks authentication, authorization, data protection, and vulnerability resistance.
Why it matters: A secure backend protects user data and prevents breaches.
Pro Tip: Use tools like OWASP ZAP or Burp Suite to identify and fix security vulnerabilities.

5. Integration Testing

What it is: Ensures different modules (e.g., database, third-party services) work together seamlessly.
Why it matters: Even if individual components work, they might fail when integrated.
Pro Tip: Mock external services to test integrations without relying on live systems.

6. Database Testing

What it is: Verifies data integrity, schema validation, indexing, and query performance.
Why it matters: A faulty database can lead to data loss, corruption, or poor performance.
Pro Tip: Use SQL queries and tools like SQLMap to test database functionality and security.

Frontend Testing: The Face of Your Application

The frontend is what users interact with, and it’s critical to ensure it’s intuitive, responsive, and bug-free. Here’s how to test it effectively:

1. User Interface (UI) Testing

What it is: Ensures elements like buttons, forms, and layouts function properly.
Why it matters: A broken UI can frustrate users and lead to high bounce rates.
Pro Tip: Use tools like Selenium or Cypress to automate UI testing across different browsers and devices.

2. Usability Testing

What it is: Evaluates user experience, navigation ease, and design clarity.
Why it matters: A user-friendly interface keeps users engaged and satisfied.
Pro Tip: Conduct usability tests with real users to gather actionable feedback.

3. User Acceptance Testing (UAT)

What it is: Tests the frontend from an end-user perspective to ensure it meets requirements.
Why it matters: UAT ensures the application aligns with user expectations and business goals.
Pro Tip: Create detailed test cases and involve stakeholders in the UAT process.

4. Regression Testing

What it is: Ensures new UI changes don’t break existing features.
Why it matters: Frequent updates can introduce unintended bugs.
Pro Tip: Automate regression testing using tools like TestComplete or Katalon Studio.

5. Performance Testing

What it is: Tests rendering speed, responsiveness, and UI load performance.
Why it matters: A slow frontend can drive users away.
Pro Tip: Use Lighthouse or WebPageTest to analyze and optimize frontend performance.

Best Practices for Effective Testing

Automate Where Possible: Automation saves time and ensures consistency, especially for repetitive tests.
Test Early and Often: Integrate testing into your development process to catch issues early.
Collaborate Across Teams: Developers, QA engineers, and designers should work together to ensure comprehensive testing.
Prioritize Security: Regularly test for vulnerabilities to protect user data and maintain trust.
Gather User Feedback: Real-world usage can reveal issues that automated tests might miss.

Conclusion: Testing is Not Optional

Backend and frontend testing are not just technical necessities—they are critical to delivering a high-quality application that users love. By mastering these testing techniques, you can build software that is reliable, secure, and user-friendly. So, whether you're a seasoned developer or just starting out, make testing a priority. Your users (and your reputation) will thank you.

Additional Resources

What is a Test Case?: A beginner-friendly guide to understanding test cases.
Test Cases for Manual Testing: Learn how to write effective test cases for manual testing.
Effective Test Case Templates: Explore templates and ex

Let’s break the internet—not with bugs, but with flawless, high-performing applications!

Exploratory Testing - Cars.ng User Journey Analysis

Kibe🔌💻 — Tue, 04 Feb 2025 08:23:24 +0000

Cars.ng is a platform designed to simplify the car-buying experience. In this post, I’ll walk you through my exploratory testing journey, where I evaluated Cars.ng’s core user flows to identify bugs, usability issues, and potential improvements. By sharing these findings, I aim to provide actionable feedback to enhance the platform’s overall functionality and user experience.

Introduction

User experience is critical for any online platform, especially in the automotive marketplace. As part of this analysis, I focused on Cars.ng’s main functionalities, including navigation, filtering, and user actions like viewing car details, submitting forms, and interacting with dashboards. Testing involved both desktop and mobile views, ensuring insights are relevant for diverse user needs.

Methodology

My exploratory testing process was divided into three phases:

Environment Setup
Tested on both desktop (Windows 10, Chrome v120) and mobile (Android 13, Chrome v120).

Used the latest versions of browsers (Chrome and Firefox).

Documented all findings using a structured bug report template.
Core User Flows Tested

Navigating and filtering car listings.

Interacting with the dashboard functionalities.

Testing the footer links and other essential interactions like “Pricing” and “Submit” buttons.
Reporting & Categorizing

Identified and documented issues using categories: High, Medium, and Low severity.
Provided visual proof (screenshots) and actionable steps to reproduce the issues.

Findings

During the testing phase, I documented six key issues, which highlight usability gaps and potential bottlenecks in user interactions. Below are a few notable findings:

Broken Links in the Footer

Links for "Most Researched Car" in the footer section either do not work or redirect to a 404 page.
Unresponsive Dashboard Actions

The "View Request" button does not respond when clicked, leaving users unable to view request details.
Non-Responsive Dashboard Design

The dashboard layout breaks on smaller screens, making it nearly impossible to navigate on mobile devices.
Filtering and Pricing Failures

Clicking on “Pricing” for similar models does not display any information.
Filtering by “Similar Models” redirects users to a 404 page.
404 Error on Form Submission

Submitting an email in the “Do you want to be notified” section redirects to a 404 page instead of confirming the subscription.

Each issue was categorized by severity and detailed in my bug report, which you can access here.

Suggested Improvements

Based on the findings, here are six actionable recommendations to improve the platform:

Fix Broken Links in the Footer

Ensure all footer links redirect to the correct pages. This enhances user trust and usability.
Add Logout Functionality

Implement a logout option to improve security and allow users to manage their sessions effectively.
Introduce Pagination on the Dashboard

Adding pagination to the dashboard improves performance and user navigation for accounts with many requests.
Optimize Dashboard Responsiveness

Redesign the dashboard to ensure it adapts seamlessly to various screen sizes for a better mobile experience.
Add a Chat Feature

Introduce a chat option to allow users to contact sellers easily, improving engagement.
Save User Filters

Save user-applied filters for the session to reduce frustration and repetitive actions.

Conclusion

Exploratory testing provided valuable insights into Cars.ng’s strengths and weaknesses. While the platform offers promising features, addressing the issues and implementing the suggested improvements will greatly enhance user satisfaction and engagement.

To explore the platform and see the current state, visit Cars.ng. For a detailed bug report and actionable feedback, view the complete report here.

Note: Testing is an ongoing process, and iterative improvements are key to creating a seamless user experience.

Creating Users and Groups with a Bash Script: An Automated Approach

Kibe🔌💻 — Mon, 01 Jul 2024 16:35:31 +0000

As a SysOps engineer, efficiently managing user accounts and groups is crucial for maintaining a secure and organized system environment. Automating the user creation process not only saves significant time but also reduces human errors. This article introduces a Bash script, create_users.sh, designed to read a text file with user information, create users and groups, set up home directories, generate random passwords, log actions for auditing purposes, and securely store passwords.

Script file is located in this link

Overview of the Script Functionality

The Bash script automates the following tasks:

Reading User Data: Reads a text file (users.txt) containing usernames and associated groups. Each line in the file is formatted as username;groups, where groups are comma-separated.
Creating Users and Groups:

-   Each user gets a personal group with the same name as the username.
-   Additional groups specified in the file are created if they do not exist.
-   Users are added to their personal group and any additional groups.

Setting Up Home Directories: Creates home directories for each user with appropriate permissions and ownership.
Generating Random Passwords: Utilizes openssl to generate random passwords for each user and securely sets them.
Logging Actions: Logs all script actions to /var/log/user_management.log for audit and troubleshooting purposes.
Storing Passwords Securely: Stores generated passwords securely in /var/secure/user_passwords.csv with strict file permissions.
Error Handling: Includes robust error handling for scenarios such as existing users or groups.

Key Features

Verbose Mode: Enables detailed output during execution with the -v option.
Dry Run Option: Simulates user creation without making changes using the -d option.
Backup Existing Password File: Safeguards the existing password file by creating a backup before modifications.

Usage

sudo ./create_users.sh users.txt

For verbose output:

sudo ./create_users.sh -v users.txt

For a dry run (simulation):

sudo ./create_users.sh -d users.txt

Ensure your users.txt file is formatted correctly:

light;sudo,dev,www-data

idimma;sudo

mayowa;dev,www-data

Benefits of Automation

Automating user creation offers numerous benefits:

Efficiency: Saves time by automating repetitive tasks.
Consistency: Ensures uniform user setup across systems.
Security: Generates strong, random passwords and stores them securely.
Auditing: Logs all actions for accountability and auditing purposes.

Conclusion

The create_users.sh script provides a reliable solution for automating user management tasks, enhancing system security, and maintaining consistency. By securely storing passwords and logging all operations, it supports accountability and facilitates efficient system administration.

For internship opportunities, explore the HNG Internship program and discover top tech talent through HNG Hire. These platforms offer valuable resources for skill development and career advancement in the tech industry.

For the complete script and detailed implementation, visit the GitHub repository.

By leveraging automation tools like Bash scripting, you can streamline system administration tasks, bolster security, and improve overall operational efficiency in managing your infrastructure.

Tackling Inadequate Monitoring: My Journey as a Backend Developer

Kibe🔌💻 — Sat, 29 Jun 2024 18:24:40 +0000

Tackling Inadequate Monitoring: My Journey as a Backend Developer

As I embark on my journey with the HNG Internship, I reflect on a recent challenge I faced in backend development. This experience not only tested my technical skills but also reinforced the importance of effective monitoring in creating robust applications. Here’s a detailed account of how I resolved the issue of inadequate monitoring using Nginx, Gunicorn, and Django.

The Challenge: Inadequate Monitoring

In one of my recent projects, I encountered a significant issue with inadequate monitoring. This problem manifested in various ways: missed alerts for critical issues, lack of insight into application performance, and difficulty in diagnosing problems. I knew that resolving this issue would be critical in improving the overall stability and reliability of the application.

Steps i followed to tackle the Challenge

Step 1: Identifying the Problem

The first step in solving any problem is recognizing it. During the testing phase, I noticed that critical issues were going undetected because there was no monitoring in place. This meant that any downtime or performance issues were only discovered after users reported them, which was far from ideal.

Step 2: Analyzing the Existing Setup

I started by reviewing the existing infrastructure. The application was running on a Django framework, served by Gunicorn as the WSGI HTTP server, and Nginx as the reverse proxy. Despite this robust stack, there was no centralized logging, performance metrics, or alerting system in place.

Step 3: Implementing Centralized Logging

To address this, I decided to implement centralized logging using Nginx and Gunicorn's logging capabilities.

Nginx Logging Configuration:

In the Nginx configuration file, I enabled access and error logs to capture detailed information about incoming requests and server errors.

http {
    ...
    log_format main '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log /var/log/nginx/access.log main;
    error_log /var/log/nginx/error.log warn;
    ...
}

Gunicorn Logging Configuration:

For Gunicorn, I configured the logging settings to ensure all application-level logs were captured.

gunicorn --log-level debug --access-logfile /var/log/gunicorn/access.log --error-logfile /var/log/gunicorn/error.log myproject.wsgi:application

Step 4: Setting Up Monitoring Tools

With centralized logging in place, the next step was to set up monitoring tools to visualize performance metrics and send alerts for critical issues. I chose Prometheus for monitoring and Grafana for visualization.

Prometheus Configuration:

I configured Prometheus to scrape metrics from both Nginx and Gunicorn. This involved exposing metrics endpoints and setting up Prometheus to collect data.

Nginx Metrics Exporter:

I used the Nginx Exporter to expose metrics to Prometheus.

nginx-prometheus-exporter -nginx.scrape-uri=http://localhost:8080/stub_status

Gunicorn Metrics Exporter:

For Gunicorn, I used the gunicorn-prometheus-metrics library to expose metrics.

pip install gunicorn-prometheus-metrics
gunicorn --config gunicorn_conf.py --prometheus-dir /metrics myproject.wsgi:application

Prometheus Scrape Configuration:

In the Prometheus configuration file, I added scrape jobs for Nginx and Gunicorn metrics.

scrape_configs:



job_name: 'nginx'

static_configs:


targets: ['localhost:9113']



job_name: 'gunicorn'

static_configs:


targets: ['localhost:8000']

Step 5: Visualizing Metrics with Grafana

I set up Grafana to visualize the collected metrics. By creating dashboards for Nginx and Gunicorn, I could monitor the application's health, response times, error rates, and more in real-time.

Step 6: Setting Up Alerts

To ensure critical issues were promptly addressed, I configured alerts in Prometheus. Alerts were set up for high error rates, slow response times, and server downtime. These alerts were sent to Slack for immediate notification.

alerting:

  alertmanagers:

    - static_configs:

        - targets: ['localhost:9093']

alert_rules:

  groups:


name: alert.rules
rules:


alert: HighErrorRate
expr: rate(http_requests_total{status=~"5.."}[5m]) > 0.05
for: 1m
labels:
severity: critical
annotations:
summary: "High error rate detected"
description: "More than 5% of requests are failing with server errors."

The Outcome

By implementing centralized logging and setting up robust monitoring and alerting, I significantly improved the stability and reliability of the application. I could now detect and resolve issues promptly, ensuring a smoother user experience.

Looking Forward: The HNG Internship

As I prepare to start the HNG Internship, I am excited about the opportunities to further develop my skills and tackle more challenging problems. This internship represents a significant step in my journey as a backend developer. It offers a platform to work on real-world projects, collaborate with experienced professionals, and learn from their expertise.

I am particularly motivated to join the HNG Internship because of its focus on hands-on learning and mentorship. I believe that this experience will not only enhance my technical skills but also help me grow as a professional. I am eager to contribute to impactful projects, learn from industry experts, and take my backend development skills to the next level.

conclusion

Solving the issue of inadequate monitoring was a valuable learning experience. It reinforced the importance of robust monitoring in building reliable applications. As I embark on this new journey with the HNG Internship, I am excited about the challenges ahead and look forward to the growth and learning opportunities that lie ahead.

Connect with me LinkedIn for more insights on backend development and technology trends.

Building RESTful APIs with Express.js

Kibe🔌💻 — Wed, 12 Jun 2024 20:29:18 +0000

Welcome to a journey into the world of web architecture! Whether you're a seasoned developer or just dipping your toes into the vast sea of software development, understanding the core concepts and tools that power the web is essential. In this article, we'll embark on an exploration of two fundamental components that underpin modern web services: REST and Express.js.

1. What is REST?

In the realm of web interactions, there exists a crucial architectural style known as REST, which stands for Representational State Transfer. REST is like the conductor of a symphony, bringing harmony and structure to the chaos of web communication between computer systems.

This article is your ticket to exploring the world of RESTful systems, where concepts like statelessness and the segregation of client and server responsibilities reign supreme. But before we dive in, let's demystify REST and understand why it plays such a vital role in the web's infrastructure.

RESTful systems adhere to six fundamental constraints, as initially articulated by Roy Fielding in his doctoral dissertation. These constraints serve as the building blocks of the RESTful style:

Uniform Interface: Creating a common language for both clients and servers.
Stateless: No storage of session information on the server between requests.
Cacheable: Explicitly stating whether responses can be cached.
Client-Server: Keeping client and server concerns separate.
Layered System: Composing systems with multiple layers.
Code on Demand: Providing the option to extend a client's functionality by transferring logic.

REST's appeal lies in its use of HTTP requests for CRUD operations (Create, Read, Update, Delete), making it a straightforward and standardized approach to interact with web services.

2. What is Express.js?

Express is a fast, assertive, essential and moderate web framework of Node.js. You can assume express as a layer built on the top of the Node.js that helps manage a server and routes. It provides a robust set of features to develop web and mobile applications.

Let’s see some of the core features of Express framework:

It can be used to design single-page, multi-page and hybrid web applications.
It allows to setup middleware to respond to HTTP Requests.
It defines a routing table which is used to perform different actions based on HTTP method and URL.
It allows to dynamically render HTML Pages based on passing arguments to templates.

3. Express.js Architecture

3 Why Choose Express.js?

Speedy I/O Operations: It handles data quickly.
Works Smoothly with Asynchronous Tasks: It handles multiple tasks without getting stuck.
Organized Like MVC: Makes your code neat and organized.
Easy Routing with a Strong API: Helps you guide your web traffic effortlessly.

4 Tools and Tech You Need

Node.js
MongoDB
A Text Editor (like Notepad++, Sublime, Atom, or VSCode)
Postman (for testing your work) ## What You Need Before We Start Before we dive in, make sure you have these two essentials installed: Node.js MongoDB

Form Handling in Flask: Unleashing the Power of Flask-WTF

Kibe🔌💻 — Thu, 30 Nov 2023 07:59:58 +0000

Handling forms is a crucial aspect of web development, and Flask, a lightweight and powerful web framework for Python, offers an excellent extension called Flask-WTF that simplifies form handling. Flask-WTF seamlessly integrates with WTForms, a flexible form handling library, providing features like form validation, CSRF protection, and form rendering. In this guide, I will walk you through the process of handling forms in Flask using Flask-WTF, empowering you to effortlessly create and process forms in your Flask applications.

What is Flask-WTF?
Flask-WTF is a built-in module of Flask that provides an alternative way of designing forms in Flask. It seamlessly integrates with WTForms, a flexible form handling library for Python.

Features of Flask-WTF:
Flask-WTF offers several features that simplify form handling in Flask, including:

Global CSRF protection: Flask-WTF provides built-in protection against cross-site request forgery (CSRF) attacks, ensuring the security of your forms.

Integration with web forms: Flask-WTF allows you to define form classes using WTForms, making it easy to create and manage form fields, validation rules, and rendering.

reCAPTCHA support: Flask-WTF supports the integration of reCAPTCHA, a popular anti-bot service, into your forms, enhancing security and preventing spam.

File upload support: Flask-WTF works seamlessly with Flask Uploads, enabling easy handling of file uploads in your forms.

Creating a Simple Contact Form using Flask-WTF
To illustrate how to use Flask-WTF, let's create a simple contact form. Here are the steps involved:

Environment set up
Install virtual environment (virtualenv)
Virtualenv is a highly useful tool that allows Python developers to create isolated environments for their projects. By isolating the environment, it ensures that the project dependencies are separate from the global Python installation, preventing conflicts between different projects.
To install Virtualenv, you can use the following command:

pip install virtualenv

After installing Virtualenv, you can proceed to create a new virtual environment within a specific folder. For example, let's create a folder called "flaskforms" and navigate into it:

$ mkdir flaskforms
$ cd flaskforms

Next, create the virtual environment by running the following command:

$ virtualenv venv

Please note that the above command creates a virtual environment named "venv" in the current directory.

In case you are using Windows, you can activate the virtual environment with the following command:

$ venv\Scripts\activate

On other operating systems like macOS or Linux, the activation command will be slightly different:
shell

$ source venv/bin/activate

Once the virtual environment is activated, you can proceed to install Flask, a popular web framework for Python, by using the following command:

pip install flask

To leverage the power of WTForms, a library for form handling in Flask, you need to install the flask-wtf library. You can install it by running the following command:

pip install flask-wtf

With these steps completed, you are now equipped with a virtual environment containing Flask and Flask-WTF installed, allowing you to handle forms seamlessly in your Flask application.

Step 1: Import necessary modules

from flask import Flask, render_template, request
from flask_wtf import FlaskForm
from wtforms import StringField, TextAreaField, SubmitField
from wtforms.validators import DataRequired, Email

Here, you import the required modules for your Flask application. The Flask module handles the web application, render_template is used to render HTML templates, and request is used to handle HTTP requests. The FlaskForm class from flask_wtf is imported to create the form, while the field types (StringField, TextAreaField, SubmitField) and validators (DataRequired, Email) from wtforms are imported to define form fields and validation rules.
Step 2: Create Flask application and set secret key

app = Flask(__name__)
app.secret_key = 'secret_key'

You create a Flask application instance and set the secret key. The secret key is used to protect against security vulnerabilities like Cross-Site Request Forgery (CSRF).

Step 3: Define the ContactForm class

class UserContactForm(FlaskForm):
    Firstname = StringField('firstname', validators=[DataRequired()])
    Lastname = StringField('lastname', validators=[DataRequired()])
    email = StringField('Password', validators=[DataRequired(), Email()])
    text_message = TextAreaField('message', validators=[DataRequired()])
    send = SubmitField('Send')

Here, you define the ContactFormclass that inherits from FlaskForm. Each field (Firstname, Lastname, email, text_message) is assigned a field type and associated validators. The field types (StringField, TextAreaField, SubmitField) define the input type, while validators (DataRequired, Email) specify the validation rules for each field.

Step 4: Define the contact route

@app.route('/user-contact', methods=['GET', 'POST'])
def user_contact():
    form = UserContactForm()

    if form.validate_on_submit():
        return 'Form  has been succesfully submitted'

    return render_template('user_contact.html', form=form)

This code defines the /user-contact route for your Flask application, which can handle both GET and POST requests. Inside the user_contact function, an instance of the UserContactForm class is created. If the form is submitted and passes the validation (form.validate_on_submit()), the string 'Form submitted'is returned. Otherwise, the user_contact.html template is rendered with the form object passed to it.

Step 4: Create the HTML template
Certainly! Here's an example of how you can render the UserContactForm in an HTML template:


<!-- contact.html -->

<html>
<head>
    <title>User Contact Form</title>
    <link rel="stylesheet" href="static/css/style.css">
    <style>
        body {
            background-color: #f2f2f2;
            font-family: Arial, sans-serif;
        }

        .container {
            max-width: 400px;
            margin: 0 auto;
            padding: 20px;
            background-color: #fff;
            border-radius: 5px;
            box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
        }

        .form-control {
            margin-bottom: 20px;
        }

        .form-control label {
            font-weight: bold;
            display: block;
        }

        .form-control input, .form-control textarea {
            width: 100%;
            padding: 10px;
            border: 1px solid #ccc;
            border-radius: 4px;
        }

        .form-control input[type="submit"] {
            background-color: #4CAF50;
            color: #fff;
            border: none;
            cursor: pointer;
        }

        .form-control input[type="submit"]:hover {
            background-color: #45a049;
        }
    </style>
</head>
<body>
    <div class="container">
        <h1>Contact Us</h1>
        <form method="POST" action="{{ url_for('user_contact') }}" class="form-control">

            {{ form.csrf_token }}

            <label>{{ form.Firstname.label }}</label>
            {{ form.Firstname }}
            <br>
            <label>{{ form.Lastname.label }}</label>
            {{ form.Lastname }}
            <br>
            <label>{{ form.email.label }}</label>
            {{ form.email }}
            <br>
            <label>{{ form.text_message.label }}</label>
            {{ form.text_message }}
            <br><br>
            {{ form.send }}

        </form>
    </div>
</body>
</html>

In the above HTML template, we define a form that uses the POST method to submit the data to the /user-contact route. We include the CSRF token {{ form.csrf_token }} for security purposes.

Each field of the form is rendered using the {{ form.field_name }} syntax, where field_name corresponds to the fields defined in the UserContactForm class (Firstname, Lastname, email, text_message, send). The labels for each field are accessed using {{ form.field_name.label }}.

Exceptions and Errors in Python

Kibe🔌💻 — Mon, 19 Dec 2022 09:15:55 +0000

In Python, an error indicates a problem that occurs while the program is executing, while an exception is a signal that indicates an exceptional condition that has occurred.

Errors are typically caused by problems with the code itself, such as syntax errors, name errors, or type errors. These are usually detected by the interpreter before the program starts running, and the interpreter will display an error message indicating what went wrong.

Here's an example of a syntax error in Python:

def foo():
    print('Hello')
    return

foo()

If you try to run this code, you'll see an error message like this:

File "example.py", line 6
    foo()
    ^
IndentationError: expected an indented block

Exceptions, on the other hand, are events that occur during the execution of the program and can be handled by the code. Exceptions are used to signal a variety of conditions, such as division by zero, file not found, or invalid input. When an exception occurs, the interpreter raises (or "throws") an exception object.

Here's an example of how you can catch and handle an exception in Python:

try:
    x = int(input('Enter a number: '))
    print(1 / x)
except ZeroDivisionError:
    print('You cannot divide by zero!')

If the user enters a number other than zero, the code will execute without any problems. If the user enters zero, however, the interpreter will raise a ZeroDivisionError exception, which will be caught by the except clause and the appropriate message will be printed.

In summary, errors are problems that occur when the code is incorrect and cannot be executed, while exceptions are events that occur during execution and can be handled by the code.

When do we need to use exceptions?

Exceptions are used in Python to signal a variety of exceptional conditions that can occur during the execution of a program. Some common examples of when exceptions might be used include:

Handling runtime errors: Exceptions can be used to handle runtime errors, such as division by zero or out-of-bounds array access, which would otherwise cause the program to crash.
Validating user input: Exceptions can be used to validate user input and ensure that it meets certain criteria. For example, you might use an exception to ensure that a user has entered a valid email address or phone number.
Dealing with external resources: Exceptions can be used to handle errors that occur when interacting with external resources, such as reading from or writing to a file, or connecting to a network server.
Handling unexpected conditions: Exceptions can be used to handle unexpected conditions that may arise during the execution of a program. For example, you might use an exception to handle the case where a user attempts to access a resource that does not exist.

Overall, exceptions are a useful tool for handling errors and exceptional conditions in a clean and robust way. They allow you to write code that is more resilient to failure and can gracefully
handle a variety of error scenarios.

How to correctly handle an exception

To handle an exception in a program, you can use a try-except block. The try block contains the code that may throw an exception, and the except block contains the code that will handle the exception if it occurs. Here's an example:

try:
   # code that may throw an exception
except ExceptionType:
   # code to handle the exception

You can specify a particular type of exception to handle by replacing ExceptionType with the name of the exception class. For example, to handle a ZeroDivisionError, you can use:

try:
   # code that may throw a ZeroDivisionError
except ZeroDivisionError:
   # code to handle the ZeroDivisionError

You can also handle multiple exception types by using multiple except blocks. For example:

try:
   # code that may throw an exception
except ZeroDivisionError:
   # code to handle a ZeroDivisionError
except ValueError:
   # code to handle a ValueError

If you want to handle all exception types, you can use the Exception class as the exception type:

try:
   # code that may throw an exception
except Exception:
   # code to handle any exception

It's generally a good idea to be specific about which exception types you want to handle, rather than catching all exceptions, because this can help you identify and fix errors in your code.

Finally, you can use the finally block to include code that should always be executed, whether or not an exception occurs. For example:

try:
   # code that may throw an exception
except ExceptionType:
   # code to handle the exception
finally:

   # code that should always be executed

What’s the purpose of catching exceptions

The purpose of catching exceptions is to handle errors that may occur during the execution of a program. When an error, or exception, occurs in a program, it can cause the program to crash or produce incorrect results. By catching exceptions, you can prevent these issues and gracefully handle the errors in your program.

There are several benefits to catching exceptions:

Improved stability: Catching exceptions can help prevent your program from crashing or producing incorrect results when an error occurs. This can improve the stability of your program and make it more reliable.
Improved user experience: If your program crashes or produces incorrect results, it can be frustrating for the user. By catching exceptions, you can provide a better user experience by handling errors in a way that is more user-friendly.
Debugging: Catching exceptions can also help you identify and fix errors in your program. When you catch an exception, you can print out a message or log the error to help you understand what went wrong and how to fix it.

In summary, the purpose of catching exceptions is to handle errors that may occur during the execution of a program, improve the stability and reliability of the program, and provide a better user experience.

When do we need to implement a clean-up action after an exception

You may need to implement a clean-up action after an exception if your program has performed some action that needs to be undone or resources that need to be released.

For example, consider a program that opens a file, reads from it, and then closes the file. If an exception occurs while reading from the file, the file may not be closed properly. In this case, you would want to include a clean-up action in the except block to ensure that the file is closed properly.

You can use the finally block to include code that should always be executed, whether or not an exception occurs. The finally block is useful for performing clean-up actions, such as releasing resources or closing open files.

Here's an example of how you can use the finally block to perform a clean-up action after an exception:

try:
   # code that may throw an exception
except ExceptionType:
   # code to handle the exception
finally:
   # clean-up action

In this example, the clean-up action will be executed whether or not an exception occurs. This ensures that the clean-up action is always performed, even if an exception occurs.

Creating and Using Dynamic Libraries ( C )

Kibe🔌💻 — Tue, 13 Dec 2022 12:54:38 +0000

I provided a thorough description of how to make and use static libraries in the post linked to below. Please take a look at it if you need a refresher. I'll concentrate on detailing how to develop and use dynamic libraries in the C programming language in this article.

I'll need to establish a few words before I can explain why using dynamic libraries is important. A function is first and foremost a piece of a program that is named and performs a certain task. By using the previously mentioned function to complete a task instead of having to rewrite that particular block of code later on in the program, functions may be used throughout the program to save time.

Despite the fact that static libraries can be used by numerous programs, once a program has been compiled, it becomes impossible to change the various pieces of object code in an executable file because all the code is contained in a single file that was statically linked during the program's compilation.

The topic of dynamic or shared libraries is now finally brought up. Dynamic libraries, in contrast to static libraries, are made up of independent files that each contain a unique piece of object code. A single object code file is created by dynamically linking these files together. Dynamic libraries also provide additional data that the operating system will need in order to link the library to other programs.

Because each application or program can access the dynamic library without needing a separate copy, as would be the case if we were using static libraries, the inference is that memory is conserved while utilizing dynamic libraries. Static libraries execute more quickly at run-time since the object code for the library's functions is already present in the executable file, even if dynamic libraries allow for source code changes without requiring a complete program recompilation. Multiple function calls are therefore dealt with more effectively than when using dynamic libraries.

How to Create a Dynamic Library (Linux)

Simply type the following command on Linux to build a dynamic library: Press return after typing gcc *.c -c -fPIC. Essentially, this operation generates one object file .ofor each source file. The -fPIC flag guarantees position independence for the code.

This implies that the location of where the computer loads the code into memory is irrelevant. Some processors and operating systems must create libraries from position-independent code so that they can choose where to load them into memory during runtime. The -c options just ensures that each .o file isn’t linked yet.

Next, type in the following command: gcc *.o -shared -o liball.so(substitute your desired library name with all) and hit return. The wildcard * tells the compiler to compile all the .o files into a dynamic library which is specified by the -shared flag. The naming convention for dynamic libraries is such that each shared library name must start with lib and end with .so . Other than that though, let your imagination run free when considering names for your dynamic libraries.

Finally, we’ll need to export the path for libraries so that programs know where to look for them by executing the following command: export LD_LIBRARY_PATH=$PWD:$LD_LIBRARY_PATH

How Do we use it?

First of all, we need to create a test file that uses our functions described in the library. convert that file into object code (in this case is not important to convert it into PIC because it won’t be requested from another directory).
gcc test.c -c

When we have already compiled it, we need to specify that we are linking it to a dynamic library. This could be done by running the command with the file that we are going to link followed by the flag -L. Telling the compiler to look for libraries in the current directory. After that we need to specify the name of the library, in this case, is “l_test”. Note that the name of the library passed is now shorten on the word lib. In this step, we can use that shortcut because the compiler is assuming that all the words beginning with l will be libraries. And as usual, we give a name to our executable program.

gcc test.o -L. l_test -o testlib

If we try to run our executable file that calls the functions that we have described. It will give us an error because by default the system will be searching for libraries in the native libraries directory of the system and our library is in the current directory. We can get away with this error in two ways. The first one is to copy our library to the default searching directory, /lib, /usr/lib, usr/local/lib. By doing that at the run time our library will be in the place that the system would search.

The second one is by giving the program the specific path of where is located the library we want to use before executing the file. In order to get the specific paths, we can run the command “pwd”. Copy and paste it after the following variable LD_LIBRARY_PATH . By doing this we are giving the address of our library for the file to link it at runtime.
LD_LIBRARY_PATH=”:/home/ubuntu/programs/libtest;$LD_LIBRARY_PATH” ./testlib

That is pretty much all, I hope you enjoyed this article and learned something new

Compiling C File With gcc

Kibe🔌💻 — Fri, 16 Sep 2022 07:02:36 +0000

What is c programming

C is a procedural programming language. It was initially developed by Dennis Ritchie in the year 1972. It was mainly developed as a system programming language to write an operating system. The main features of the C language include low-level memory access, a simple set of keywords, and a clean style, these features make C language suitable for system programmings like an operating system or compiler development.
For C to be executable it must first be compiled

Introduction to gcc

The original author of the GNU C Compiler (GCC) is Richard Stallman,the founder of the GNU Project.
gcc stands for GNU compiler collections which is used to compile mainly c and c++
To check gcc version present in you system use the following command
gcc -v
syntax
gcc [-C | -S | -E |] [-std = standard]
Compilation
Compilation refers to the process of converting a program from the textual source code, in a programming language such as C or C++, into machine code, the sequence of 1’s and 0’s used to control the central processing unit (CPU) of the computer. This machine code is then stored in a file known as an executable file, sometimes referred to as a binary
file.

A compiler is a computer program that translates the source code written in a high-level programming language(i.e C) to a low-level language such as machine code.

The compilation process
There are four main steps involved in the compilation process as mentioned below:

Preprocessing
Compiling
Assembling
Linking

Preprocessing
This is the first phase through which the source code is passed.

This phase includes:
Removal of comments
Expansion of included files
Conditional combination
inclusion of the code from the header files Its output is stored with a file extesion of .i

To view the output of the pre-processing stage, we can use the command gcc -E filename.c option as shown below.

root@DESKTOP-TI71NAL:~# gcc -E helloworld.c

Compiler
In this phase compilation of the filename.i happens in order to compile an output file of filename which is in an assembly level
username@hostname:~$ gcc -S filename.c
Assembler
Here is where filename.s is taken as input and turned into filename.o by the assembler.

gcc -c filename.c

Linker
This the final phase in which all the linking of function call with their definitions are done.
gcc by default does dynamic linking and so printf() is dynamically linked.
The tasks performed by the linker include:

Linking together all the object files from the different source files.
Linking function calls with their definitions. The linker knows the locations of the function definitions in the static or dynamic libraries. Option 1

Run the following command:

username@hostname:~$ gcc helloworld.c

When you run this command, the compiler generates an executable program called a.out. To run the executable program type the following command:

username@hostname:~$ ./a.out

Option 2
To give the executable program a different name, we can add the "-o" option to the gcc command after the name of the file we are compiling, as shown below:

username@hostname:~$ gcc helloworld.c -o helloworld

To run the executable program, use the command below:

username@hostname:~$ ./helloworld

## gcc options

-o this option is used for output
this will compile the filename.c , but instead of giving the default name it is executed using ./filename

gcc filename.c -o filename

-werror This compiles the source and show the warning if any error is present in the program.

gcc filename.c -werror -o filename

-wall this not only checks the errors but any other kind of warning

gcc filename.c -wall -o filename

Thanks for reading

Shell I/O Redirection, The Shell Filters and Shell Expansion

Kibe🔌💻 — Wed, 07 Sep 2022 23:22:58 +0000

INTRODUCTION

There are many reasons why you should learn about I/O redirection, shell filters, and shell expansion. These concepts are essential for anyone who wants to use the command line effectively. Without an understanding of how these features work, it will be difficult to fully utilize the potential of the command line. Additionally, learning about these topics will give you a better understanding of how Linux works under the hood. Finally, being knowledgeable about I/O redirection, shell filters, and shell expansion will make it easier for you to troubleshoot any issues that might arise when using the command line.

I/O Redirections

Redirection is a feature in Linux that allows you to change the standard input/output devices when executing a command. The basic workflow of any Linux command is that it takes input and produces output.

Each command performs all terminal-related activities with three files that the shell makes available to every command:

Standard input (stdin): Represented by <, it is the information inputted into the terminal through the keyboard or input device.
Standard output (stdout): Represented by >, it is the information outputted after a process is run.
Standard error (stderr): It is an error message outputted by a failed process.

Output Redirection

The ">" symbol is used for output redirection.

root@537302f1e700:~/fruits# ls -l > listings 
root@537302f1e700:~/fruits# cat listings 
total 0                                                    
-rw-r--r-- 1 root root 0 Sep  7 13:46 apple                
-rw-r--r-- 1 root root 0 Sep  7 13:46 Apple                
-rw-r--r-- 1 root root 0 Sep  7 13:49 banana               
-rw-r--r-- 1 root root 0 Sep  7 13:48 Banana               
-rw-r--r-- 1 root root 0 Sep  7 13:47 cherry

The output of ls when redirected will be stored in the listings file. This is how you can redirect a command.

When you use the ">" operator to redirect to a file with the same name, the information in the file is overwritten.

root@537302f1e700:~/fruits# echo " welcome " > listings 
root@537302f1e700:~/fruits# cat listings 
 welcome

In this example, echo "welcome" > listings has overwritten the existing file.

To prevent overwriting a file, you can append to it using the output append operator >>.

root@537302f1e700:~/fruits# echo " welcome " > listings 
root@537302f1e700:~/fruits# cat listings 
 welcome                                                     
root@537302f1e700:~/fruits# echo "welcome again" >> listings 
root@537302f1e700:~/fruits# cat listings 
 welcome                                                     
welcome again

Input Redirection

The "<" symbol is used for stdin redirection.

For example:

$ wc -l users
2 users
$


$ wc -l < users
2
$

Note that there is a difference in the output produced by the two forms of the wc command. In the first case, the name of the file users is listed with the line count; in the second case, it is not.

In the first case, wc knows that it is reading its input from the file users. In the second case, it only knows that it is reading its input from standard input, so it does not display the filename.

Filters in Linux

Filters are programs that take in plain text as standard input, transform it into a meaningful format, and then return it as standard output. These include:

1. `cat`

The cat command displays the text of the file line by line.

cat [path]

root@537302f1e700:~/fruits# cat list 
apple                                                      
mango                                                      
banana                                                     
oranges

2. `head`

The head command displays the first n lines of a file. If the number of lines is not specified, it prints the first 10 lines by default.

head [lines-to-print] [path]

root@537302f1e700:~/fruits# head list 
apple                                                      
mango                                                      
banana                                                     
oranges                                                    
Melon                                                      
mandarin                                                   
Avocado                                                    
coconut                                                    
Cherry                                                     
lime                                                       
root@537302f1e700:~/fruits# head -3 list 
apple                                                      
mango                                                      
banana                                                     
root@537302f1e700:~/fruits#

3. `tail`

The tail command is the reverse of head, returning the lines from bottom to top.

root@537302f1e700:~/fruits# tail list 
mango                                                      
banana                                                     
oranges                                                    
Melon                                                      
mandarin                                                   
Avocado                                                    
coconut                                                    
Cherry                                                     
lime                                                       
Longan                                                     
root@537302f1e700:~/fruits# tail -3 list 
Cherry                                                     
lime                                                       
Longan

4. `sort`

The sort command is used to sort a file, arranging the records in a particular order.

sort [options] path

root@537302f1e700:~/fruits# sort list 
1mango                                                     
20melon                                                    
3lime                                                      
apple                                                      
Avocado                                                    
banana                                                     
Cherry                                                     
coconut

Options with sort command:

-r: Sorts in reverse order.
-n: Sorts the file numerically.
-nr: Sorts a file with numeric data in reverse order.
-k: Sorts the table based on any column.
-c: Checks if a given file is already sorted.
-u: Sorts and removes duplicates.
-M: Sorts a file on a monthly basis.

5. `uniq`

The uniq command is used to remove duplicate lines. For example, in this case, banana was duplicated, and the uniq command removed the duplicate item.

root@537302f1e700:~/fruits# cat list 
apple                                                      
mango                                                      
banana                                                     
banana                                                     
oranges                                                    
Melon                                                      
mandarin                                                   
Avocado                                                    
coconut                                                    
Cherry                                                     
lime                                                       
Longan                                                     
1mango                                                     
3lime                                                      
20melo                                                     
apple                                                      
root@537302f1e700:~/fruits# uniq list 
apple                                                      
mango                                                      
banana                                                     
oranges

6. `wc`

The wc command gives the number of lines, words, and characters in the data. By default, it displays four columnar outputs.

root@537302f1e700:~/fruits# wc list 
 17  17 112 list

wc [options] [path]

wc stands for word count.

With wc, you can pass more than one file.

Note: When more than one file is placed in the argument, it adds one more line that counts the total.

root@537302f1e700:~/fruits# wc list melon orange 
 17  17 112 list                                           
  0   0   0 melon                                          
  0   0   0 orange                                         
 17  17 112 total

wc options:

-l: Prints the number of lines in a file.
-w: Prints the number of words in a file.
-m: Displays the count of characters in a file.
-v: Displays the version of wc.

Some applications of the wc command:

To count all the files and folders present in a directory: ls list | wc -l

root@537302f1e700:~/fruits# ls list | wc -l 1

To display the number of word count only of a file: wc -w list

root@537302f1e700:~/fruits# wc -w list 17 list

7. `grep`

The grep command is used to search for particular information in a text file.

grep [options] pattern [path]

root@537302f1e700:~/fruits# grep banana list 
banana

Or:

root@537302f1e700:~/fruits# cat list | grep banana 
banana

grep options:

-v: Displays names not matching the specified word.
-i: Filters output in a case-insensitive way.
-A: Displays a line after the result.
-B: Displays a line before the result.
-C: Displays a line before and after the result.

8. `nl`

The nl command is used to print line numbers of the text file.

nl [file-path]

root@537302f1e700:~/fruits# nl list 
     1  apple                                               
     2  mango                                               
     3  banana                                              
     4  oranges                                             
     5  Melon                                               
     6  mandarin



root@537302f1e700:~/fruits# cat -n list 
     1  apple                                               
     2  mango                                               
     3  banana                                              
     4  oranges                                             
     5  Melon                                               
     6  mandarin                                            
     7  Avocado                                             
     8  coconut                                             
     9  Cherry                                              
    10  lime                                                
    11  Longan                                              
    12  1mango                                              
    13  3lime                                               
    14  20melon                                             
    15  apple                                               
    16  mango                                               
    17  apple

nl options:

-n: To display the number and file.
-s: To display number padding with space.
-b: To display line numbers when the pattern matches.

Some applications of nl command:

To print a certain section of a file:

root@537302f1e700:~/fruits# head -5 list | nl -b a 
     1  apple                                               
     2  mango                                               
     3  banana                                              
     4  oranges                                             
     5  Melon                                               
root@537302f1e700:~/fruits# head -n 3 list | nl -b a 
     1  apple                                               
     2  mango                                               
     3  banana

Shell Expansions

Shell expansion is the process of simplifying commands in order to get a return value from a shell prompt. The shell reads the command line and analyzes it to make it easier to understand.

The types of shell expansion include:

1. Pathname Expansion

This is also known as "globbing." Pathname expansion is performed by the shell when it encounters a wildcard pattern (e.g., *, ?, []). These wildcards are replaced with a list of matching files and directories.

For example, ls *.txt would list all .txt files in the current directory.

$ ls *.txt

file1.txt file2.txt file3.txt

2. Tilde Expansion

When the shell encounters a tilde (~), it expands it to the current user's home directory.

For example, cd ~ would change the directory to the user's home directory.

$ echo ~

/home/username

3. Arithmetic Expansion

Arithmetic expansion allows the evaluation of an arithmetic expression and its substitution into the command.

For example, echo $((2 + 2)) would output 4.

$ echo $((2 + 2))

4

4. Command Substitution

Command substitution allows the output of a command to replace the command itself. This is done using backticks () or$(...)`.

For example, echo "Today is $(date)" would output the current date.

$ echo "Today is $(date)"

Today is Mon Aug 28 10:37:26 UTC 2024

5. Brace Expansion

Brace expansion is used to generate arbitrary strings. It is typically used for creating multiple similar files or directories at once.

For example, echo file{1..3}.txt would output file1.txt file2.txt file3.txt.

$ echo file{1..3}.txt

file1.txt file2.txt file3.txt

6. Variable Expansion

Variable expansion allows the value of a variable to replace the variable name.

For example, if NAME="John", then echo "Hello, $NAME" would output Hello, John.

$ NAME="John"

$ echo "Hello, $NAME"

Hello, John

Conclusion

Learning about I/O redirection, shell filters, and shell expansion is essential for effective command-line usage. These features allow for powerful text manipulation and automation, enabling users to work more efficiently with files, processes, and data in a Linux environment. By mastering these concepts, you will be better equipped to harness the full potential of the command line and streamline your workflow.

DEV Community: Kibe🔌💻

The Ultimate Guide to Backend and Frontend Testing: Breaking Down the Essentials for a Flawless Application

Why Testing Matters

Backend Testing: The Hidden Hero of Your Application

1. Functionality Testing

2. Performance Testing

3. Unit Testing

4. Security Testing

5. Integration Testing

6. Database Testing

Frontend Testing: The Face of Your Application

1. User Interface (UI) Testing

2. Usability Testing

3. User Acceptance Testing (UAT)

4. Regression Testing

5. Performance Testing

Best Practices for Effective Testing

Conclusion: Testing is Not Optional

Additional Resources

Exploratory Testing - Cars.ng User Journey Analysis

Introduction

Methodology

Findings

Suggested Improvements

Conclusion

Creating Users and Groups with a Bash Script: An Automated Approach

Overview of the Script Functionality

Key Features

Usage

Benefits of Automation

Conclusion

Tackling Inadequate Monitoring: My Journey as a Backend Developer

Tackling Inadequate Monitoring: My Journey as a Backend Developer

The Challenge: Inadequate Monitoring

Steps i followed to tackle the Challenge

Step 1: Identifying the Problem

Step 2: Analyzing the Existing Setup

Step 3: Implementing Centralized Logging

Step 4: Setting Up Monitoring Tools

Step 5: Visualizing Metrics with Grafana

Step 6: Setting Up Alerts

The Outcome

Looking Forward: The HNG Internship

conclusion

Building RESTful APIs with Express.js

1. What is REST?

2. What is Express.js?

3. Express.js Architecture

3 Why Choose Express.js?

4 Tools and Tech You Need

Form Handling in Flask: Unleashing the Power of Flask-WTF

Exceptions and Errors in Python

When do we need to use exceptions?

How to correctly handle an exception

What’s the purpose of catching exceptions

When do we need to implement a clean-up action after an exception

Creating and Using Dynamic Libraries ( C )

How to Create a Dynamic Library (Linux)

How Do we use it?

Compiling C File With gcc

What is c programming

Introduction to gcc

Shell I/O Redirection, The Shell Filters and Shell Expansion

INTRODUCTION

I/O Redirections

Output Redirection

Input Redirection

Filters in Linux

1. cat

2. head

3. tail

4. sort

5. uniq

6. wc

7. grep

8. nl

Shell Expansions

1. Pathname Expansion

2. Tilde Expansion

3. Arithmetic Expansion

1. `cat`

2. `head`

3. `tail`

4. `sort`

5. `uniq`

6. `wc`

7. `grep`

8. `nl`