DEV Community: Isah Jacob

Outreachy Call for June 2025 Cohort mentoring.

Isah Jacob — Sun, 23 Feb 2025 20:05:58 +0000

Open source communities thrive on collaboration, innovation, and mentorship. For those passionate about fostering diversity and inclusion in tech, there’s no better way to contribute than by mentoring the next generation of developers. Outreachy, a global initiative that provides paid internships to underrepresented groups in tech, is gearing up for its June 2025 cohort—and they need your help.

In this post, we’ll explore how you can get involved as a mentor, why mentorship matters, and how supporting Outreachy aligns with the values of open source. Whether you’re a seasoned contributor or new to the world of open source, this is your chance to make a meaningful impact.

Why Mentorship Matters in Open Source

Mentorship is the backbone of open source communities. It’s not just about writing code; it’s about sharing knowledge, building confidence, and creating opportunities for others to succeed. For many aspiring developers, especially those from underrepresented backgrounds, mentorship can be the bridge that connects them to a thriving career in tech.

Outreachy’s mission is to break down barriers and create a more inclusive tech industry. By mentoring an Outreachy intern, you’re not just helping one person—you’re contributing to a larger movement that values diversity and equity.

Check out our Hacktoberfest 2025 Guide to learn about one of the biggest open source events of the year.

Questions to ponder

Have you ever had a mentor who changed your career trajectory?
What skills or experiences could you share with someone just starting out in open source?

Key Dates for the June 2025 Outreachy Cohort

If you’re considering becoming a mentor, here are the important dates to keep in mind:

February 26, 2025: Community sign-up deadline
March 7, 2025: Mentor project description deadline
March 10 to April 8, 2025: Contribution period
June 2 to August 29, 2025: Internship period

Mark your calendars and start thinking about the kind of project you’d like to mentor. Whether it’s a coding project, documentation improvement, or community outreach, your expertise can make a difference.

How to Get Started as a Mentor

Becoming a mentor for Outreachy is easier than you might think. Here’s a step-by-step guide to help you get started:

Join an Open Source Community If you’re not already part of an open source community, now’s the time to get involved. Communities like Apache, Linux, and Mozilla are always looking for contributors. Check out our Apache Camel Tutorial with Spring Boot to see how you can start contributing to Apache projects.
Propose a Project Think about the kind of project you’d like to mentor. It could be something you’re already working on or a new idea that aligns with your community’s goals. Make sure your project description is clear, detailed, and accessible to beginners.
Engage with Applicants During the contribution period (March 10 to April 8), you’ll have the chance to interact with applicants. This is your opportunity to guide them, answer questions, and help them make meaningful contributions to your project.
Support Your Intern Once the internship begins, your role as a mentor will involve regular check-ins, code reviews, and providing feedback. Remember, your goal is to help your intern grow and succeed.

Questions to consider:

What challenges do you think new contributors face when joining open source projects?
How can you make your project more accessible to beginners?

The Impact of Mentorship: Stories from the Community

Mentorship isn’t just about teaching technical skills—it’s about building relationships and fostering a sense of belonging. Many Outreachy alumni have gone on to become leaders in their fields, and their stories are a testament to the power of mentorship.

For example, one former intern shared how their mentor helped them navigate their first open source contribution, which eventually led to a full-time job at a major tech company. Another alumna spoke about how the confidence she gained during her internship inspired her to start her own open source project.

These stories remind us that mentorship is a two-way street. As a mentor, you’ll not only help someone else grow but also gain new perspectives and insights that can enrich your own work.

How Open Source Drives Innovation Through Mentorship

Open source is more than just a way to build software—it’s a movement that thrives on collaboration and shared knowledge. By mentoring Outreachy interns, you’re contributing to a culture of innovation that benefits everyone.

If you’re curious about how open source is shaping the future of technology, check out our post on How Open Source is Driving Innovation. You’ll discover how open source projects are tackling some of the world’s biggest challenges, from climate change to healthcare.

Tips for Being an Effective Mentor

Mentoring can be incredibly rewarding, but it also comes with its own set of challenges. Here are some tips to help you be the best mentor you can be:

Be Patient

Remember that everyone learns at their own pace. Be patient and understanding, especially when your intern is facing challenges.

Communicate Clearly

Clear communication is key to a successful mentorship. Make sure your instructions are easy to understand, and don’t hesitate to ask for feedback.

Encourage Independence
While it’s important to provide guidance, you also want to encourage your intern to think for themselves. Give them the tools they need to solve problems on their own.
Celebrate Successes
Acknowledge your intern’s achievements, no matter how small. Celebrating milestones can boost their confidence and motivation.

Join the Movement: Share Your Thoughts and Experiences

Mentorship is a powerful way to give back to the open source community, and Outreachy provides the perfect platform to do so. If you’re ready to take the plunge, visit the Outreachy blog to learn more about the
June 2025 cohort and how you can get involved.

We’d love to hear from you! Have you ever mentored someone in open source? What was your experience like? Share your thoughts in the comments below, and don’t forget to share this post with your network. Together, we can create a more inclusive and innovative tech industry.

Stay Updated and Keep Learning

The world of open source is constantly evolving, and staying informed is key to being an effective mentor. Check out our Hacktoberfest 2024 Guide to learn about one of the biggest open source events of the year.

And if you’re looking to deepen your technical skills, our Apache Log4j Tutorial is a great resource for understanding one of the most widely used logging frameworks in Java.

Final Thoughts

Mentorship is more than just a responsibility—it’s an opportunity to shape the future of open source. By supporting Outreachy’s June 2025 cohort, you’re not only helping individuals achieve their dreams but also strengthening the open source ecosystem as a whole.

So, what are you waiting for? Sign up to be a mentor today and make a difference in someone’s life. And don’t forget to share this post with your community. Together, we can build a brighter, more inclusive future for tech.

I want to hear from you

What excites you most about mentoring in open source?
How do you think mentorship can help bridge the diversity gap in tech?
Leave your thoughts in the comments, and let’s keep the discussion going!

Best Open Source CRM

Isah Jacob — Sun, 23 Feb 2025 18:28:32 +0000

Navigating the world of customer relationship management (CRM) can be daunting, especially with the myriad of options available. For businesses seeking flexibility and cost-effectiveness, open-source CRM solutions present a compelling choice. This guide aims to address common questions and concerns about open-source CRMs, providing insights to help you make an informed decision.

Check out our comprehensive guide on Hacktoberfest 2024: What You Should Know and What You Should Do.

Open Source CRM

What is an Open-Source CRM?

An open-source CRM is a customer relationship management system whose source code is publicly available. This openness allows businesses to modify, customize, and enhance the software to fit their specific needs without licensing fees.

Why Choose an Open-Source CRM?

Many businesses grapple with the decision between proprietary and open-source CRM systems. Common concerns include:

Cost: Proprietary CRMs often come with hefty licensing fees.
Customization: Limited flexibility to adapt the software to unique business processes.
Vendor Lock-in: Dependence o n a single vendor for updates and support.

Open-source CRMs address these issues by offering:

Cost Savings: No licensing fees mean reduced expenses.
Flexibility: Access to source code allows for extensive customization.
Community Support : Active communities contribute to continuous improvements and support.

You might be interested in our comprehensive guide on How Open Source Is Driving Innovation in Software Development.

Addressing Common Concerns

Is Open-Source CRM Secure?

Security is a valid concern when adopting any software. Open-source CRMs benefit from community scrutiny, leading to rapid identification and resolution of vulnerabilities. However, it's crucial to:

Regularly Update: Keep the software up-to-date to incorporate security patches.
Implement Best Practices: Use strong passwords, encrypt data, and restrict access based on roles.

What About Support and Maintenance?

While open-source solutions may not offer official support, many have active communities and third-party providers offering assistance. Engaging with these communities can provide valuable insights and solutions.

How Do I Ensure the CRM Aligns with My Business Processes?

Customization is a significant advantage of open-source CRMs. With access to the source code, businesses can:

Modify Workflows: Adapt the system to mirror existing business processes.
Integrate with Other Tools: Ensure seamless data flow between the CRM and other business applications.

Real-World Example: A Small Business's Journey with Open-Source CRM

Consider a small retail business struggling to manage customer interactions and sales processes. They implemented SuiteCRM and experienced the following benefits:

Improved Customer Tracking: Centralized customer information led to better service.

Enhanced Sales Processes: Automated workflows reduced manual tasks.

Cost Savings: Eliminated licensing fees allowed investment in other areas.

This example illustrates how open-source CRM solutions can be tailored to meet specific business needs effectively.

I will love to hear about your experiences with CRM systems. Have you tried an open-source CRM? What challenges or successes have you encountered? Share your thoughts in the comments below!

Keeping Your CRM Up-to-Date

Regular updates are vital to maintain security and functionality. To ensure your CRM remains current:

Monitor Releases: Stay informed about new versions and updates.
Test Before Implementing: Ensure updates are compatible with your customizations.
Engage with the Community: Participate in forums and discussions to learn from others' experiences.

By staying proactive, you can maximize the benefits of your open-source CRM.

For more insights on enhancing your business's digital infrastructure, explore our comprehensive guide on The Ultimate Guide to Becoming a Web UI Developer.

Note: This article is for informational purposes only. Always consult with a professional to determine the best CRM solution for your business needs.

Frontend and Backend Integration with RESTful APIs in Python and Django

Isah Jacob — Tue, 05 Nov 2024 21:25:09 +0000

Integrating frontend and backend systems is a very important skill for web developers, It enable seamless data flow and dynamic interactions on modern websites. This tutorial focuses on using RESTful APIs for frontend-backend integration in Python and Django, breaking down important steps to help beginners and intermediate developers create smooth, efficient communication between the frontend and backend.

What is Frontend-Backend Integration?

Frontend-backend integration involves creating a bridge between the part of a web application users see and interact with (frontend) and the part that handles data processing, logic, and storage (backend).

The frontend sends data requests to the backend, which processes these requests and returns the relevant data, allowing for dynamic user interactions. RESTful APIs are one of the most popular methods for managing this integration, especially when using frameworks like Django in Python.

Introduction to RESTful APIs and How They Work

RESTful APIs (Representational State Transfer) are a style of web services that follow a standard set of conventions for requesting and transmitting data. In RESTful architecture, data is accessed via HTTP methods (GET, POST, PUT, DELETE), each serving a different purpose:

GET retrieves data.
POST submits new data.
PUT updates existing data.
DELETE removes data.

When integrating a frontend with a backend, RESTful APIs enable the frontend to make HTTP requests, which are handled by API endpoints on the backend. These endpoints process the request, perform the necessary actions, and return the response, usually in JSON format. Let’s look at setting up a RESTful API in Django and using it in a frontend application.

Setting Up a RESTful API in Django

Step 1: Set Up Your Django Project

Start by creating a virtual environment and activating it. Navigate to the folder for your project.

Creating a virtual environment in django

python -m venv virtual_name

activate virtual environment on windows

virtual_name\Scripts\activate

activate virtual environment on linux

source virtual_name\bin\actiavte

Create new Django project and app in Django.

pip install django

django-admin startproject myproject

python manage.py startapp myapp

Open settngs.py and add myapp to the INSTALLED_APPS section in your settings.py file to ensure Django recognizes the app.

Your file Structure should look like this:

Step 2: Install Django REST Framework (DRF)

Django REST Framework (DRF) is a powerful toolkit that simplifies creating APIs in Django.

pip install djangorestframework

After installing, add rest_framework to INSTALLED_APPS in your settings.py.

Step 3: Create a Model

For this example, let’s assume we’re building an app where users can view and create "tasks." Here’s a simple model for Task.

myapp/models.py

from django.db import models

class Task(models.Model):
    title = models.CharField(max_length=100)
    description = models.TextField()
    completed = models.BooleanField(default=False)

    def __str__(self):
        return self.title

In the above code, we are importing models from Django. the model define the important fields and how our data will be stored in the database. The Task will be table name and fields e.g. title are used to define the attributes of a model, representing the columns in the database table.

What are the migrations in Django?

Migrations are Django's way of propagating changes you make to your models (adding a field, deleting a model, etc.) into your database schema.

Run the following commands to create and apply migrations:

python manage.py makemigrations
python manage.py migrate

Step 4: Create a `Serializer` File in Myapp folder

Serializers convert Django models to JSON format, which is important for REST APIs.

myapp/serializers.py

from rest_framework import serializers
from .models import Task

class TaskSerializer(serializers.ModelSerializer):
    class Meta:
        model = Task
        fields = ['id', 'title', 'description', 'completed']

From the above code, we need to convert our model to JSON format for readability.

Step 5: Define Views

Django views handle incoming requests and return responses. Using DRF’s APIView makes it easy to define RESTful methods.

myapp/views.py

from rest_framework import generics
from .models import Task
from .serializers import TaskSerializer

class TaskListCreate(generics.ListCreateAPIView):
    queryset = Task.objects.all()
    serializer_class = TaskSerializer

class TaskDetail(generics.RetrieveUpdateDestroyAPIView):
    queryset = Task.objects.all()
    serializer_class = TaskSerializer

Step 6: Configure URLs

Create a urls.py file in myapp folder and map your views to URLs so that the frontend can access these API endpoints.

myapp/urls.py

from django.urls import path
from .views import TaskListCreate, TaskDetail

urlpatterns = [
    path('tasks/', TaskListCreate.as_view(), name='task-list-create'),
    path('tasks/<int:pk>/', TaskDetail.as_view(), name='task-detail'),
]

Open your url.py file in your project folder and include this myapp URL configuration in your main urls.py file.

myproject/urls.py

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include('myapp.urls')),
]

With these steps, your Django backend is ready to handle frontend requests for viewing, creating, and updating tasks through RESTful API endpoints.

Integrating the Frontend with the Django Backend

Let’s move to the frontend and demonstrate how to interact with the Django RESTful API using a JavaScript framework/library like React.

Step 1: Fetching Data (GET Request)

To retrieve tasks from the backend, make a GET request to the /tasks/ endpoint. Get the code from HERE

Steps 2 and 3: Sending Data (POST Request) and Updating Data (PUT Request)

To show you understands this article do this part yourself. in the folder

Common Challenges in Frontend-Backend Integration

When integrating frontend and backend applications, you might encounter a few common challenges:

Cross-Origin Resource Sharing (CORS): Ensure that CORS is configured correctly in Django to allow frontend requests.
Data Serialization Errors: Make sure your serializers are configured to accurately represent your data.
Authentication: For secure applications, implement authentication (e.g., JWT or OAuth) to ensure only authorized users can access sensitive endpoints.

Conclusion

Frontend and backend integration using RESTful APIs in Django enables seamless communication and dynamic functionality in web applications. By setting up a Django REST API and making HTTP requests from the frontend, developers can achieve efficient, scalable frontend-backend interactions.

How to Build an Online Banking System – Python Object-Oriented Programming Tutorial

Isah Jacob — Mon, 25 Mar 2024 11:33:41 +0000

Object-oriented programming is a programming paradigm that's based on objects & classes.

And what better way to learn about it than by building a project?

Here, I teach you key OOP concepts in Python while building an online banking system.

Exploring the Basics of Objects and Methods in Java

Isah Jacob — Sun, 19 Mar 2023 09:41:38 +0000

When you're first learning to program in Java, one of the most important concepts to learn and understand is objects and methods. Objects and methods form the foundation of object-oriented programming (OOP) in Java, which is a powerful programming paradigm that allows you to write more organized, efficient, and reusable code. In this article, I'll explain the fundamentals of Java objects and methods and help you understand how they work.

Before continuing with this article, it is important that readers have a good understanding of basics of Java. If you need to brush up on your basic programming skills in Java, I recommend reading the basics of Java here.

What are objects in Java?

Java is an object-oriented programming (OOP) language.
What this means is that every class in Java is supposed to be a blueprint for an object with the same name. Think of an object as an instance of a class, which is a blueprint for creating objects.
The syntax to declare a new object

<object_type> <object_name>;

String myCar;

To initialize an object, you have to create it using the keyword new:

<object_name> = new <class_name>();

myCar = new Car();

You can declare and initialize the same type like this:

<object_type> <object_name> = new <class_name>();

String Car = new Car();

An object in Java is also known as an instance, and the process of creating an object is called instantiation.

Objects can store values in the form of attributes and execute instructions in the form of methods. The idea of objects is that they each have a different value for a common characteristic.

To declare an instance attribute, create a variable outside the main method (example below). This allows Java to recognize the syntax, and every object you create will have a copy of that variable that can store a different value in each object.

To access the value of an attribute, refer to the object's name, then type a dot and the attribute's name. You may modify this value just as you do with a usual variable, but remember that you will be changing the value of that attribute for the object you are referring to.

The word private below means that the attribute can only be accessed by this class.

Here's an example of a simple class with attributes in Java.

public class Car {
    private String make;
    private String model;
    private int year;
}

From the above class definition, "Car defines a Car object, which has three attributes (information): make, model, and year. These attributes or pieces of information represent the make, model, and year of the car, respectively.

To create an object of this class, you use the new keyword and the class constructor, like this:

Car myCar = new Car();

This creates a new Car object and assigns it to the variable myCar. You can then set the attributes of the object like this:

myCar.make = "Toyota Camry";
myCar.model = "Civic";
myCar.year = 2022;

This sets the make, model, and year attributes of the myCar object.

Let's see a simple Java program.

public class Car
{   
     private String model;
     private String make;
     private int year;
  public static void main(String[] args)   
{     
    Car myCar = new Car();
    myCar.model = "Civic";      
    myCar.make = "Toyota Camry";      
    myCar.year = 2022; 
//creating a different object with different attributes      
    Car ourCar = new Car();      
    ourCar.model = "City";      
    ourCar.make = "Honda";      
    ourCar.year = 2023;      
//accessing values of attributes of objects      
   System.out.println("My car's model is " + 
   myCar.model);      
   System.out.println("My car's make is " + 
   myCar.make);      
   System.out.println("My car's year is " + myCar.year);
   System.out.println();      
   System.out.println("Our car's model is " + 
   ourCar.model);      
   System.out.println("Our car's model is " + 
   ourCar.make);      
   System.out.println("Our car's model is " + ourCar.year);   
  }
}

Output:::
My car's model is a Civic.
My car's make is a Toyota Camry.
My car's year is 2022. 

Our car's model is City.
Our car's make is Honda.
Our car's year is 2023.

Take a look at the code above; notice any repetitiveness? How is the process of creating an object and assigning values to its variables carried out? There's a solution for that. It's constructors.

What is a constructor in Java?

Constructors tell Java how to create an object when you already know the values you want to assign to its attributes.

A constructor is a special method that is used to initialize objects in a class. It is called automatically when an object of the class is created, and it is responsible for setting initial values for the object's attributes. The constructor has the same name as the class and is defined within the class.

The main purpose of the constructor is to ensure that all objects of a class are created with a valid initial state. This helps to prevent errors and ensures that the object is ready to be used in the program.

The syntax is

public <class_name> ( <parameters> ) { 
values assignation 
}

Never place them inside the main method.
The keyword public allows any class to access it, be it a class or an attribute.

Now, let's look at a simple example in Java to understand how constructors work:

public class Car{
    private String model; 
    private String make;  
    private String year;

    // Constructor
    public Car(String model, String make, int year) {
        this.mode = model;
        this.make = make;
        this.year = year;
    }
}

In the example above, we have defined a class called Car with three attributes: model, make, and year. We have also defined a constructor that takes three parameters: model, make, and year.

Within the constructor, we use the this keyword to refer to the current object being created and set the initial values for the model, make, and year attributes.

Now, when we create a new object of the Car class, the constructor is called automatically and sets the initial values for the object's attributes.

Here's an example:

// Create a new Car object in the main method.
public static void main(String[] args)
{   
    Car ourFamilyCar = new Car("City", "Honda", 2023);   
    Car daddyCar = new Car("Civic", "Toyota Camry", 2022);
}

In this example, we have created two new Car objects called "ourFamilyCar" and "daddyCar," which passed in the values "City", "Honda" and 2023 for ourFamilyCar, and "Civic", "Toyota Camry" and 2022 for daddyCar as the model, make, and year attributes, respectively.

Constructors are an essential part of object-oriented programming, as they ensure that objects are created with valid initial states and are ready to be used in the program.

What Are Methods in Java?

Methods are blocks of code that perform a specific task. In Java, methods are defined within classes, and they can be called on objects of that class.

Another useful thing you can do with objects is to make them execute certain instructions. A method is essentially a piece of code that is only executed when the name of the method is called (or invoked).

Apart from executing a block of code, methods have the property of returning (or giving you) values. And just as with any other variable in Java, you must specify what type of thing it is.
The syntax is

public <return_type> <name_of_method> (arguments) { 
code to execute when it is called 
}

The arguments are certain values that may be required to carry out the code's logic. Arguments are not necessary, but beware: even if you don't ask for arguments, you must put them in parentheses () because they're part of every method's syntax.

Void Method in Java

In case you do not want to get a value from the method, the return type should be set as void. Like in the code here.

public void start() {
    System.out.println("The car is starting.");
}

When this method is called, start() which is the method name simply prints a message to the console.

To invoke this method on a Car class object, use the dot notation, as shown in the main method below.

public static void main(String[] args){   
Car myCar = new Car("Civic", "Toyota Camry", 2022);   
myCar.start(); //apply method to myCar object 
}

When the code above runs it calls the start() method on the myCar object, and the message "The car is starting." is printed to the console.

Output:::
The car is starting.

Parameters and return values in methods

Methods can also take parameters and return values. Parameters are inputs to the method, and return values are outputs from the method.

It is commonplace to code a method that does some calculation and then gives you (returns you) that value. In that case, you must know beforehand what type of data you expect to get and place it in the <return type> part of the method's definition instead of void. Here's an example of a method with parameters and a return value:

public int accelerate(int speed) {
    int newSpeed = speed + 10;
    return newSpeed;
}

This method, called accelerate(), takes an int parameter called speed and returns an int value. The method adds 10 to the speed parameter and returns the result.
To call this method on an object of the Car class, you pass in a value for the speed parameter and store the return value in a variable, like this:

public static void main(String[] args)
{   
   Car myCar = new Car("Civic", "Toyota Camry", 2022);   
   myCar.start();
   System.out.println("current speed: " + 
   myCar.accelerate(50));
}

Output:::
current speed: 60

This calls the accelerate() method on the myCar object, passing in a value of 50 for the speed parameter. The return value of the method (60) is stored in the newSpeed variable.

Wrapping-up

Objects and methods are fundamental concepts in Java and OOP. Understanding how to create and use objects and methods is essential for writing effective and efficient Java code. By following the examples provided in this article, you should be well on your way.

Your feedback is highly appreciated.
you can follow me on twitter and linkedIn

A Beginner's Guide to Java Basics

Isah Jacob — Wed, 15 Mar 2023 15:17:15 +0000

Java is a popular programming language that is widely used for developing various applications such as web applications, mobile applications, desktop applications, and more. Understanding the basics of Java is essential for anyone who wants to start programming in Java. This article covers the fundamental concepts of Java, including syntax and structure, data types and variables, operators, and control statements.

Java Syntax and Structure

Java is a case-sensitive programming language, which means that uppercase and lowercase letters are treated differently; the same is true of quotation marks. "" is not the same as ''. Java programs are written in plain text files and saved with the .java file extension.

A Java program starts with a class definition that includes the keyword "class," followed by the name of the class, and the opening and closing curly braces.

public class ClassName{ 
}

The braces { } above indicate the scope of the structure involved, like a class.

If you want your Java file to do something, then you should place a main method inside that class. The main method is where your code is executed.The code below shows you the appropriate syntax for a simple Java program.

The class, as well as the file, is called Classes in Java.

public class ClassName 
{
  //The main method;
  public static void main(String[] args)
{
  //This is a comment, ignored by Java.
  //Place statements here.
 }
}

Print Statement in Java

For you to print out to the console in Java, you will make use of the command below. Inside the main method, you can place two types of print statements.

System.out.print()

Prints a message in the console.

System.out.println()

Prints a message in the console, then ends the line.

After every command, like the one above, you must place a semicolon ; at the end of the line. A semicolon is compulsory in Java. See examples below:

public class PrintingStatements
{   
   public static void main(String[] args)
{      
   System.out.println("I am learning Java");      
   System.out.print("Java is interesting");   
  }
}

Data Types and Variables

In Java, there are eight primitive data types: byte, short, int, long, float, double, char, and boolean. These data types are used to define the type of data that a variable can hold.

A variable is a storage location that holds a value of a specific data type. To declare a variable in Java, you need to specify its data type, followed by its name and an optional value.

It is possible to save information inside a Java program. To do so, you must first tell Java what type of data it contains. The most commonly used data types are:

int to store "integers," that is, numbers without decimal digits.
double to store numbers with decimal digits.
boolean to store true or false values.
string to save literal messages.

The syntax to declare a variable is

<data type> <variable name>;

int age;

After being declared,you can set the variable's value:

<variable name> = <variable value>;

age = 36;

You can initialize and declare a variable at the same time:

<data type> <variable name> = <variable value>;

int age = 36;

Let's see a simple Java program:

public class ClassVariable 
{   
   public static void main(String[] args)
{          
   double amount = 3000.00;      
   boolean male;      
   String programmingLanguage;
   int hoursInADay = 24;
   male = true;
   programmingLanguage = "Java";
   
   System.out.println("Hours in a day: " + hoursInADay);     System.out.println("The amount is " + amount);      
   System.out.println("Is Jacob male?: " + male);      
   System.out.print("The programming language we're learning is " + programmingLanguage);   
  }
}

Output:
Hours in a day: 24
The amount is 3000.0
Is Jacob male?: true
The programming language we're learning is Java.

Operators

Operators are used to perform operations on variables and values in Java. Java has several types of operators, including arithmetic, assignment, relational, logical, and bitwise operators.

Arithmetic operators are used to perform basic mathematical operations such as addition, subtraction, multiplication, and division. Example:

int a = 7 `+` 3; addition
int b = 7 `-` 3; subtraction
int c = 21 `/` 3; division
int d = 7 `*` 3; multiplication

Assignment operators are used to assign values to variables.
Relational operators are used to compare two values.
Logical operators are used to perform logical operations such as AND, OR, and NOT.
Bitwise operators are used to perform operations on the bits of binary numbers. Let's see example:

Assignment operators

int a = 7;
int b = 3;
b += a; // equivalent to b = b + a, b is now 10

In the above code, we've used assignment operator (=) to assign a value to a variable (a = 7, b = 3).

Relational operators

if (a < b) {
  printf("b is less than a");
}

In the above code, we've also used relational operator (<) to compare two values (a < b).

Logical operators

in c = 20
if ((a < b) && (b < c)) {
  printf("b is less than a and b is less than c");
}

we've also used Logical operator (&&) in the above code to combine multiple conditions ((a < b) && (b < c)).

Bitwise operators

unsigned int x = 0x0F; // binary 00001111
unsigned int y = 0xF0; // binary 11110000
unsigned int z = x & y; // binary 00000000

In the above code, we've used the following Bitwise operator (&) to perform bitwise AND operation (x & y).

Control statements (if, while, and loops)

Control statements are used to control the flow of a program in Java. Java has several types of control statements, including if statements, while, and loops.

If Statement

If statements are used to perform different actions based on different conditions,You can select the way a program develops depending on the value of some variable or an input. After an if, there must be a pair of parentheses enclosing a condition that simplifies into a single boolean value. When the code reaches a conditional statement, if the condition is equivalent to true, the block of code enclosed by braces after it will be executed. Let's see example:

if (condition) {
    // code to be executed
}

System.out.print("Enter a number: ");
int num = input.nextInt();
if (num % 2 == 0) 
{
   System.out.println("The number is even.");
} else {
   System.out.println("The number is odd.");
 }

While-loop

A while loop is a control statement used to execute a block of code repeatedly while a certain condition is true. The syntax of a while loop is as follows:

while (condition) {
    // code to be executed
}

int i = 1;
while (i <= 10)
{
  System.out.println(i);
  i++;
}

In the example above, the condition i <= 10 is checked before each iteration of the loop. As long as i is less than or equal to 10, the code inside the loop is executed, which prints the value of i and increments its value by 1. This process continues until i becomes 11, at which point the condition becomes false and the loop terminates.

for Loop

In Java, a for loop is a control statement used to execute a block of code repeatedly for a fixed number of times. The syntax of a for loop is as follows:

for (initialization; condition; update) {
    // code to be executed
}

The initialization part is executed once before the loop starts and is used to initialize the loop counter variable. The condition is a boolean expression that is checked before each iteration of the loop. If the condition is true, the code inside the loop is executed. The update part is executed after each iteration of the loop and is used to update the loop counter variable.

Here's an example of a programme that prints the first 10 positive square numbers:

for (int i = 1; i <= 10; i++) 
{
    int square = i * i;
    System.out.println(square);
}

Do-while Loop

In Java, a do-while loop is a control statement used to execute a block of code at least once and then repeatedly as long as a certain condition is true. The syntax of a do-while loop is as follows:

do {
    // code to be executed
} while (condition);

The code inside the do block is executed once before the condition is checked. If the condition is true, the code inside the do block is executed again. This process continues until the condition becomes false, at each point the loop is terminated and the program continues with the next statement after the loop.

Here's an example of a do-while loop in Java that prompts the user to enter a positive integer and repeats the prompt until a valid input is entered:

int number;
do {
    System.out.print("Enter a positive integer: ");
    number = input.nextInt();
 } 
    while (number <= 0);
    System.out.println("You entered " + number);
   }
}

In this example, the do block prompts the user to enter a positive integer and reads the input from the console.

The while condition checks whether the input is less than or equal to 0. If the input is not valid (i.e., less than or equal to 0), the loop repeats the prompt. This process continues until the user enters a valid input (i.e., a positive integer), at which point the loop terminates and the program continues with the next statement after the loop.

To learn more about Java iterations, you can check my previous article here

Wrapping-Up

Understanding Java basics is essential for anyone who wants to start programming in Java. In this article I have been able to cover the fundamental concepts of Java, including syntax and structure, data types and variables, operators, and control statements. By understanding these concepts, you will be able to write basic Java programs and build a strong foundation for your Java programming skills.

Your feedback is highly appreciated.
you can follow me on twitter and linkedIn

Understanding APIs: A Beginner's Primer

Isah Jacob — Thu, 02 Mar 2023 16:27:23 +0000

Application Programming Interface, or API for short, is a buzzword we hear every day in the tech space. It is crucial in web development, software development, and app development. Taking the time to break it down to understand what is meant by "application programming interface, its purpose, and why the term keeps popping up every day

In this article, I will be explaining what an API is, how APIs work, the importance of API, the types of APIs, and examples of APIs.

What is API?

An API, or application programming interface, is a set of rules and protocols that allow different software applications to communicate with each other. It essentially acts as a bridge or intermediary between different programs, allowing them to exchange data and information.
This can be useful in a variety of situations, such as when a website needs to access data from a third-party service or when one app needs to share data with another app.

API is essentially the component that enables the communication between two applications, and these applications can be completely different from each other. What this means is that an application that is developed using Java and uses Postgres as its database can interact with an application developed with ReactJS with the help of the API.

Before we delve into explaining API, let's explore the meaning of the last letter. We will be looking at the last letter "I". The I stands for an interface. Everywhere around us, there are interfaces. Think of the car. There is an interface. The remote you use to control the television has an interface. Your computer has an interface that allows you to move files, rename files, and reduce or increase volume. You do this without knowing what is going on internally, but the interface allows you to control the computer, the car, or the remote.

The importance of APIs in Modern Technology

APIs are crucial to modern technology for several reasons:

APIs provide a way for different software applications and services to connect and communicate with each other. This enables developers to integrate multiple systems and create new applications that leverage the functionality of existing ones.
APIs can streamline and automate processes, reducing the need for manual data entry or other repetitive tasks. This can save time and resources, allowing organizations to focus on higher-level tasks.
APIs allow developers to build new products and services on top of existing platforms and services. This encourages innovation and fosters a collaborative ecosystem where different organizations can work together to create new solutions.
APIs can help organizations scale their services more effectively. By providing access to their functionality through APIs, services can be used by a wider range of applications and users without the need for additional infrastructure or resources.
APIs enable developers to create more engaging and personalized experiences for users. This can improve customer satisfaction and loyalty and ultimately lead to increased revenue.

How APIs Work in Modern Technology

An online travel service, for example, can communicate with different airline service applications that enable you to book a flight. This is made possible with the help of API. APIs work by allowing software applications to interact with each other and exchange data.

The request from the online travel app and the response from different airline service apps are made possible by the online travel app giving access to their databases and getting information through their public API. This API prevents unauthorized access to any third-party application accessing their information for security and other obvious reasons. Here are some key concepts involved in how APIs work:

Request-Response Cycle

APIs use a request-response model, where one application (the client) sends a request to another application (the server), and the server responds with a resource or information. This cycle typically involves HTTP methods such as GET, POST, PUT, and DELETE.

API Endpoints

An API endpoint is a URL that allows a client to access a specific function or resource provided by an API. Endpoints can be designed for various purposes, such as retrieving data, creating data, updating data, or deleting data. For example, an API endpoint for a weather service might be

api.weather.com/v1/forecast

and it would allow developers to access different methods for retrieving weather data, such as current conditions, hourly forecasts, and daily forecasts.

Data Formats

APIs use data formats such as JSON (JavaScript Object Notation), XML (Extensible Markup Language), and others to exchange data between applications. These formats provide a standardized way of structuring and representing data so that it can be easily understood by different systems.

API Authentication and Authorization

APIs often require authentication and authorization to ensure that only authorized users or applications can access them. Authentication involves verifying the identity of the client, while authorization involves determining what actions the client is allowed to perform.

Types of APIs

When you talk to your friend over the phone, the phone is the medium, and the language, e.g., English, you both speak is the format. For requests and responses between APIs to be possible, there has to be a medium and format of communication.

APIs can communicate with each other using different communication protocols or mediums. Here are some common mediums of communication between APIs:

REST API

REST (Representational State Transfer) is a widely used architectural style for building APIs. REST APIs communicate over HTTP(S) using a request-response model. In this model, the client sends a request to the server using HTTP methods (GET, POST, PUT, DELETE), and the server responds with a representation of the resource (in JSON, XML, or other formats) along with a status code.

SOAP API

SOAP (Simple Object Access Protocol) is another popular protocol for API communication. SOAP APIs use XML for data exchange and rely on a messaging model where the client sends a request in the form of an XML message and the server responds with an XML message.

GraphQL API

GraphQL is a query language and runtime for APIs. In a GraphQL API, the client specifies the data it needs, and the server responds with exactly that data in a JSON format. GraphQL APIs can be used over HTTP/S, but they are not tied to any specific transport protocol.

Message queues

APIs can also communicate with each other using message queues. In this model, one API sends a message to a queue, and another API consumes the message from the queue. This can be useful for decoupling APIs and improving scalability.

Direct API calls

Finally, APIs can communicate with each other directly using library calls. In this model, one API directly calls the functions or methods of another API. This approach can be faster than other methods, but it can also create tight coupling between the APIs.

Examples of APIs

Social Media APIs

Facebook Graph API: Allows developers to access data and functionality from Facebook, such as user profiles, pages, posts, and messages.
Twitter API: Provides access to Twitter's data and functionality, such as tweets, timelines, and user accounts.
LinkedIn API: Enables developers to access LinkedIn's professional data, such as user profiles, companies, and jobs.

Payment APIs:

PayPal API: Allows developers to process payments and manage transactions using PayPal's platform.
Stripe API: Provides a way for developers to accept payments and manage subscriptions, using Stripe's payment gateway.

Weather APIs:

OpenWeatherMap API: Provides access to weather data and forecasts for various locations around the world.
Weather Underground API: Allows developers to retrieve weather data and forecasts, including historical data and satellite imagery.

Other API Examples:

Google Maps API: This enables developers to integrate Google Maps into their applications and provide features such as directions, traffic information, and search functionality.
Twilio API: Allows developers to build messaging and voice applications using Twilio's cloud communications platform.
Amazon Rekognition API: Provides image recognition capabilities, allowing developers to analyze and identify objects, faces, and text within images.

Wrapping Up

In conclusion, APIs are an essential part of modern technology, enabling developers to create new and innovative applications and services. By providing a standardized way of communicating and exchanging data between systems, APIs help to connect disparate software applications and services, enabling new workflows and use cases. As technology continues to evolve, APIs are likely to play an even more significant role, powering innovations and unlocking new possibilities.
Your feedback is highly appreciated.
You can follow me on Twitter and LinkedIn

Git Commit Message: My Personal Experience

Isah Jacob — Fri, 16 Dec 2022 12:42:41 +0000

Writing a good Git commit message is one great thing that has happened to me on my learning journey this year. As simple as it seems, not everyone knows exactly how to write a good commit message. In this article, I'll explain what Git and Github are all about. What exactly is a repository? Why a git commit message, how to write a great git commit message, and tools that can help you write a great commit message

What is a Git?

Git is a version control system that is used for tracking changes to files and coordinating work on those files among multiple people. It is commonly used for source code management in software development, but it can be used to track changes to any set of files. Git allows multiple developers to work on the same codebase simultaneously and helps to resolve conflicts that can arise when changes to the same files are made by different people.

What is a Github?

GitHub is a web-based platform for hosting and collaborating on Git repositories. It provides a user-friendly interface for working with Git, and it allows users to easily share their code and collaborate with others on projects. Many open-source software projects are hosted on GitHub, and it is a popular platform for developers to share and collaborate on code.

What is a Git Commit Message?

The commit message is used to explain what changes were made in a git repository, why those changes were made, and any other relevant information about the changes. The commit message is important because it provides context and information about the changes that were made, and it makes it easier for other people who are working on the same codebase to understand the history and progress of the project.

What is a Git repository?

It is a data structure that stores all of the information about a project, including all of the files, the entire history of changes to those files, and metadata about the project and its contributors. A Git repository is typically stored on a remote server and can be accessed by multiple people, allowing them to collaborate and work on the project simultaneously. A Git repository can be used to track changes to any set of files, but it is commonly used for source code management in software development.

Why is the Commit Message Important?

Git commit messages are an important part of a project's collaboration and documentation processes. It is good practise to write clear, descriptive commit messages that accurately reflect the changes made in a commit and provide context for other developers.
Git commits provide details for the changes made in a commit. By reading the commit message, other people who are working on the project can understand why a particular change was made and how it fits into the overall development of the project.
Git commit serves as a way to document the history of the project. When you look back through the commit history of a project, the commit messages can provide valuable details and insight into the decisions that were made and the thought process behind the development of the project.
Git commit can be used to generate change logs or release notes. Many projects will use tools to automatically generate a list of changes made between versions, and the commit messages are often used as the source of this information. Employers always do this.

How to Write a Good Commitment Message

Adopting an Atomic Git Commit Strategy

Atomic commits refer to the practise of making changes to a Git repository in a way that ensures that each commit is a self-contained unit of work. In other words, every line of code that is doing a specific task should have a commit message; a function or method that is going to achieve a specific task should have a commit message.

An atomic commit should contain only related changes that can be reviewed and understood independently from other commits. This is your best option as compared to making multiple unrelated changes in the same commit or making a series of commits that are not independent and require each other in order to be understood.

Adopting an Atomic Git Commit Strategy

There are several benefits to using atomic commits:
They make it easier to understand the history of a project. By reviewing a series of independent commits, it is easier to see the progression of a project and understand how it has evolved over time.

They make it easier to review changes. By reviewing a single commit, it is easier to understand the purpose and impact of the changes that were made. This can make code review more efficient and help identify problems earlier in the development process.

They make it easier to revert changes. If a commit is self-contained and independent, it is easier to revert just that commit without affecting any other changes. This can be useful if a problem is discovered after a commit or if a change needs to be undone for any reason.

Overall, using atomic commits can help to improve the clarity, readability, and maintainability of a Git repository. It is a good practise to strive for when working on a project, especially when working with a team of developers.

How To Write Good Commit Message?

Keep the message short and to the point. A good commit message should be brief and focus on the key changes that were made in the commit.
Use the present tense and imperative mood. A good commit message should use the present tense (e.g., "change" instead of "changed") and the imperative mood (e.g., "fix" instead of "fixes").
Be specific and describe the changes in detail. A good commit message should provide a clear and detailed description of the changes that were made, including any relevant details about why the changes were necessary and how they were implemented.
Use clear and descriptive language. A good commit message should use language that is easy to understand and that accurately describes the changes that were made. Avoid using technical jargon or abbreviations that may not be familiar to everyone who is working on the project.
provide context and background information. A good commit message should provide any relevant context or background information that will help other people understand the changes that were made and why they were necessary. This can include information about the problem that the changes are intended to solve or any relevant background information about the code or the project.

Tools That Can Help You Write a Great Commitment Message

There are tools out there that can help you write great commit messages. We will just few below

GitLens: GitLens is an extension that I enjoy using; I have it installed on PyCharm, InteliJ, and Visual Studio. It enhances the built-in Git capabilities in Visual Studio Code. It allows me to visualise code authorship at a glance via Git blame annotations and code lens, seamlessly navigate and explore Git repositories, gain valuable insights via powerful comparison commands, and so much more. GitLens supercharges the Git capabilities built into Visual Studio Code.

Git Commit -v: This one allows you to write the commit message and the commit message body at the same time, in the same file. This can be useful because it allows you to include more detailed information about the commit in the message body.

Commitlint: This is a tool that checks your commit messages for style and formatting errors. It can enforce rules such as requiring a certain format for the subject line or requiring that the subject line be a certain length.

Conventional Commits: This is a specification for commit messages that defines a standard format for commit messages. It can be used with tools like commitlint to enforce a consistent style for commit messages.

Commitizen: This is a command-line tool that helps you write commit messages using a prompt-based workflow. It can guide you through the process of writing a commit message and enforce rules such as requiring a certain format for the subject line.

Wrapping-Up

The key to writing a good commit message is to provide clear and concise information about the changes that were made and why they were necessary. It's a good idea to follow best practises for writing commit messages, such as keeping the subject line short and to the point and including a detailed explanation of the changes made in the commit message body. This can help you read and understand your commit history.
This will help other people who are working on the same codebase understand the history and progress of the project, which will make it easier for them to collaborate and contribute to it.

Your feedback is highly appreciated.
you can follow me on twitter and linkedIn

What I Learned While Building the Learning Log

Isah Jacob — Tue, 22 Nov 2022 21:27:47 +0000

I had the chance to become familiar with essential Django framework concepts while developing the learning log app, and I will go through those concepts in this article.

The Learning Log app is an online journaling application that allows users to record their learning on specific subjects. Users can keep track of the subjects they are interested in and write entries in their journals as they learn more about each one. Users are required to log in or register on the Learning Log home page after the site's description. A user has the ability to add new subjects, edit existing ones, and add new entries.

The Virtual Environment Is Critical

I install packages and isolate them from all other Python packages in a virtual environment on my computer. This is because it prevents installing Python packages everywhere in the system, which can damage other projects or my system tools, and separates my project libraries from those of other projects.

I discovered that making a folder to store everything is the first thing to do.
I discovered that installing a virtual environment is the first step because this is my first time working with Django.

Python3 -m pip install –user virtualenv

Create a virtual environment

I created a virtual environment by running the following command.

python -m venv ll_env

Activate virtual environment

I activated my virtual environment by running the following command

source learning_env/bin/activate

This is specifically for Linux.

Install Django

Once I activate my virtual environment.
I install Django with pip

pip install Django

Creating Project in Django.

I forget the full stop at the end of the command below and I ran into many errors. The full stop prevents folder duplication and makes it easier to deploy your app.

django-admin startproject  learning_logs .

Creating Database

Django uses SQLite to store most of the information for a project in a database.

Viewing Project

python manage.py runserver

The command above launch the development server and allow me to see how well my app functions on my system. When a URL request comes in, the Django server replies by creating the necessary page and sending it to the browser.

Launching an App

A Django project is structured as a collection of unique apps that interact with one another to function as a whole.

python manage.py startapp learning_logs

This command instructs Django to build the foundation necessary to develop an app.

Setting Up Models

Django is organized on how to handle the data via a model that will be kept in the application. A model is just a code class with logics, features and procedures, like every class you've ever encountered in python.

Activating Models

Grouping apps together in a project helps to keep track of them as the project grows to include more apps. Whenever I want to modify the data that my app manages, I will need to follow these three steps

To activate the models run the command below

python manage.py makemigrations

The command makemigrations tells Django to figure out how to modify the database so it can store the data associated with any new models I defined.

python manage.py migrate

The command above lets Django know that it will prepare the database to store the information needed to handle administrative and authentication tasks.

The Django Admin Site

Django makes it easy to work with your models through the admin site. Only the site’s administrators use the admin site, not general users.

Creating a super user

Django allows you to create a "superuser," a user who has all privileges available on the site. A user’s privileges control the actions that user can take.
Run the following code to create super user and follow the promt.

python manage.py createsuperuser

The Django Shell

The Django shell is the interactive environment, which is excellent for testing and troubleshooting project. I can use the Python interpreter that is launched by the command

python manage.py shell

to browse the data included in the database for my project when it is run in an active virtual environment.

Create Pages

Django has three steps for creating web pages: creating URLs, creating views, and creating templates. Any order would do for these. The structure of a URL is described by a URL pattern. In order for Django to know which page to return, it also instructs it on what to check for when comparing a browser request with a site URL.

The view function retrieves and modifies the information required for that page, mapping each URL to a specific view. A template that contains the page's overall structure is frequently used by the view function to render the page.

Creating URLs

I am made to choose which URLs are required since users access pages by typing URLs into browsers and clicking links. The first URL is the home page's. It serves as the default URL for accessing the project. The fact that the default Django site is currently returned by the base URL, http://localhost:8000/, indicates that the project's setup was successful.

In the url.py in my project folder. I perform the following operations inside this file:

urlpatterns = [
path('admin/', admin.site.urls),
path('', include('app_name.urls')),
]

In my app folder I created urls.py, import path and views and write the following inside.

from django.urls import path
from . import views
app_name = 'name_of_your_app'
urlpatterns = [
# Home page
path('', views.index, name='index'),
]

Composing a View

A view function receives data from a request, prepares it so that it can be used to create a page, and then delivers it back to the browser, frequently using a template that specifies how the page should look.

Open views.py in your app folder and enter the following code:

from django.shortcuts import render
def index(request):
"""The home page"""
return render(request, 'name_of_app/index.html')

The index() function in the views.py file is what Django looks for when a URL request meets the pattern I described. The request object is then passed by Django to this view method. The only code in the method in this scenario is a call to render because we don't need to handle any data for the page.

The original request object and a template that can be used to generate the page are the two arguments passed to the render() function in this case.

Establishing a Template

Every time a page is requested, Django fills in the pertinent information according to the template's description of how the page should look. You have access to all of the view's data through a template.
Make a templates folder inside the app folder. In the

<p>Welcome to Django</p>

Why Is a List the Best Python Data Structure?

Isah Jacob — Thu, 06 Oct 2022 07:28:43 +0000

In Python, the most flexible data structure is the list. Python's data structures include four types: lists, tuples, sets, and dictionaries.

Depending on what you're building, you can use these Python data structures to solve specific tasks. This built-in data structure comes in handy when creating real-world applications.

I'll go over LIST in Python in this article. How to use it, where to use it, and how to manipulate data in a list.

What exactly is a LIST?

A List is defined by using square brackets []. Lists are used to store multiple items in a single variable. A list can have many different data type.

strings = ["John", "Garri", "Butter", "Maize"],

numbers = [1, 2, 3, 4, 5],

bolean = [True, False]

A List can have list inside a list

List = [[1,2], [2, 3]]

Each item in this list above is a list itself. it is also called a two dimentional list.

Repetition of a List item

If, for instance, we want 5 in 50 times, The best way is to define the number we want, in this case 5, and multiply it by the number of times we want it, say 50, as shown in the example below.

repeating_number = [5] * 50
"""
Output: [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
"""

We use the asteric * to reapeat a number in a list.

List concatenation

To concatenate a List, use a plus sign +.

repeating_number = [5] * 5
strings = ["John", "Garri", "Butter", "Maize"]
add_together = repeating_number + strings
print(add_together)
"""
Output: [5, 5, 5, 5, 5, 'John', 'Garri', 'Butter', 'Maize']
"""

Every object in a list in Python can be of different types. They do not have to be of the same types.

Iterate Through List

We can iterate through a list of numbers, a string, a list. Let's say we want a list of numbers, maybe 1 to 20. We cannot do [1,2,3,4,5,6,7,8 to 20]. We can use the list functions to do this.

value = list(range(20))
print(value)
"""
Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
"""

It is possible to iterate through the list functions. As a result, we pass an iterable to the function, which converts it to a list. To accomplish this, we use the range function range(). The range functions return an iterable range object. This gives us the power to loop over it. So we pass in 20 to generate a list of numbers ranging from 0 to 20.

String combination

Because strings are iterable, we can loop over them to achieve our goal. We'll do something like this below to demonstrate the above with string.

string_value = list("learning list")
print(string_value)
"""
Output: ['l', 'e', 'a', 'r', 'n', 'i', 'n', 'g', ' ', 'l', 'i', 's', 't']
"""

Getting the length of a list

By using the len() function, we can get the number of iterms in that list.

print(len(string_value))
"""
Output: 13
We have 13 items on this list.
"""

Accessing Items in a List

To access an item in a list, we will use a square bracket [] and pass in the index.

print(strings[0])
"""
Output: John
"""

This will return the first item in the list, John.
We can access an item at the end of a list by doing the following.

print(strings[-1])
"""
Output: Maize
it print Maize as the last item in the list.
"""

Modifying Items in a List

Let's modify our list so that the first and last item in the list return the new item.

strings[0] = "Grace" #assign Grace to the list at at index 0
strings[3] = "Jonathan" #assign Jonathan to the list at index 3
print(strings)
"""
Output: ['Grace', 'Garri', 'Butter', 'Maize', 'Jonathan']
"""

List Slicing

You can slice a list using two indexes to slice a string. Consider the following example.

print(strings[0:2])
"""
Output: ['John', 'Garri']
"""

As you can see, the slice only returns the first two items in the list. The list remains unchanged. If you do not specify either 0 or 2, the argument will be assumed to be 0.
See the list below.

print(print(strings[:2]) # return the first two elements in the list
print(strings[0:]) # return the exact copy of our list
print(strings[:]) # return the exact copy of our list
print(strings[::2]) # return every second elements in the list.

List Unpacking

In some cases, you may want to assign each item in a list to different variable. Let's take a look below.

numbers = [1, 2, 3, 4, 5] 
first, second, third, fourth, fifth = numbers
print(first)
"""
Output: 1
The first, second, third, fourth and fifth are defined and added to our list.
"""

first, second, third, fourth = numbers
print(numbers)
"""
Output: ValueError: too many values to unpack (expected 4)
"""

The above will result in an error because the number of items in the list must be equal to the number of variables assigned. If it does not match, an error is thrown.

To avoid this error, follow the steps outlined below:

first, second, third, *other = numbers
print(first) # print 1
print(other) # print 4 and 5 as the remaining numbers
print(numbers) # print the original list

Here we are trying to get the first, second and third item and pack the rest items inside variable named other
"""
Output: 
1
[4, 5]
[1, 2, 3, 4, 5]
"""

If you want to get the first and the last item, you could do something like this.

first, *other,  last, = numbers
print(first, last) # print the first and the last item in the list
print(other) # print the rest of the items.
"""
Output: 
1 5
[2, 3, 4]
"""

How to Loop Through a List

we are going to loop over a list to get an item.

strings = ["John", "Garri", "Butter", "Maize"]
for value in strings:
    print(value)
"""
Output: 
John
Garri
Butter
Maize
"""

Getting the index in a list items.

We will use the built-in function enumerate() to get the index of an item. The iterable object returned by the enumerate function. Each iteration will result in a tuple.

for value in enumerate(strings):
    print(value)
"""
Output:
(0, 'John')
(1, 'Garri')
(2, 'Butter')
(3, 'Maize')
"""

In this case, we get a tuple after each iteration. A tuple is similar to a list, but it can only be read. The index and value are obtained here. We see John and so on from index 0.

for index, value in enumerate(strings):
    print(index, value)
"""
Output: 
0 John
1 Garri
2 Butter
3 Maize
"""

We unpack the tuple here by looping and obtaining the index and value.

List item addition and removal

Add to list

You can add items to a list in two ways.
The first option is to use the append() method. The append method adds an item to the end of the list.

strings.append("psychology")
print(strings)
"""
Output: ['John', 'Garri', 'Butter', 'Maize', 'psychology']
"""

putting an item in a specific location

If you want to add an item to a specific position in a list, you must use the insert() method.

strings.insert(0, "Abdul kereem")
print(strings)
"""
Output: ['Abdul kereem', 'John', 'Garri', 'Butter', 'Maize']
"""

Remove an item from a list.

The pop() method should be used to remove an item at the end of a list.

strings.pop()
print(strings)
"""
Output: ['Abdul kereem', 'John', 'Garri', 'Butter']
"""

As you can see, the last item, maize, has been removed.
You can also remove an item by passing the index into the pop() method and specifying where you want it to be removed.

strings.pop(2)
print(strings)
"""
Output: ['Abdul kereem', 'John', 'Butter', 'Maize']
"""

If you want to remove an item but don't know the index, You can use the remove() method and pass in the item as you can see below.

strings.remove("Butter")
print(strings)
"""
Output: ['Abdul kereem', 'John', 'Garri', 'Maize']
"""

As you can see we removed Butter by specifying the value in the remove() method.

deleting an item in a list, you can use the del keyword.

del strings[0] # will delete Abdul kereem from the list.
del strings[0:3] # will delete the first three items in the list. 
strings.clear() # will clear everything in the list

find the index of a list item
Let's assume we don't know John's index.
We'll do something similar down below.

print(strings.index("John")
"""
Output: 1
"""

If you specify an item that does not exist in the list, you will receive a value error. You can use a keyword to see if an item exists in a list.

if "James" in strings:
    print(strings.index("James"))
"""
# this will return empty because it does not exist.
"""

You can do something like this to find out how many times an item appears in a list.

print(strings.count("James"))
"""
Output: 1
we will get 1 because it appear only once in the item.
"""

Wrap-up

I was able to explain lists, how different types of data types can be used in a list, where to use a list, and how to manipulate data in a list in this article. I believe you have discovered something new.

Your feedback is greatly appreciated.
Would you like to connect with me on Linkedin and Twitter?

Functions in Python

Isah Jacob — Mon, 19 Sep 2022 16:03:15 +0000

When creating a program, there will be thousands of lines of code that cannot be stored in a single file. It is always a good idea to break it down into smaller, more maintainable, and reusable pieces of code. This is where functions come in. In this article, I will look at the following Python functions, arguments, and key word arguments.

What is a Function?

A function is a piece of code that only executes when called. A function can accept data in a form of parameters. As a result, a function can return data.

Built-in Functions in Python

Python includes a built-in function that can help you solve problems quickly. The following are a few, but not lengthy, examples of built-in functions.

dir() Returns a list of the specified object's properties and methods
float() Returns a floating point number
input() Allowing user input
int() Returns an integer number
min() Returns the smallest item in an iterable

Creating a Function

A function is defined in Python by using the 'def' keyword, followed by parentheses and indentation.

def greet():
    print('Hi there')
    print('How are you doing today')

A function can be called by using the function name followed by parenthesis.

def greet():
    print('Hi there')
    print('How are you doing today?')
greet()
#returns:
Hi there
How are you doing today?

Arguments

We defined a greet function here and in between the parentheses we pass in our parameters first_name and last_name

def greet(first_name, last_name):
    print(f'Hi {first_name} {last_name}')
    print('How are you doing today?')
greet("John", "Emmanuel")

As you can see, we add first_name and last_name as parameters. We called the function with John and Emmanuel as the argument.

Hi John Emmanuel
How are you doing today?
You can reuse it and supply different arguments.

greet("Mike", "Joy")
Hi Mike Joy

How are you doing today?

A parameter is the input for your functions that you define, such as first name and last name. John Emmanuel is the actual value you assigned to your functions in this case.
By default, the parameters you define in a function are required. You cannot provide only first_name in the argument; you must provide both the first_name and last_name.

Types of Functions

We have two types of functions

A Function That Returns A Value

The greet function in the following code prints 'Hello John' on the terminal because it returns a value.

def greet(name):
    print(f'Hello {name}')
greet(“John” )

Functions That Perform A Task

The sum function below is a built-in function. It is an examples of a function that computes and returns a value.

scores = [30, 10, 56, 60, 70]
scores = sum(scores)
print(scores)

Function that returns a value.

def greet(name):
    return f'Hi {name}'
email_message = greet("John Ibrahim")
print(email_message)

We gave the parameter a name and used a return statement to return a string, as shown above (name). We invoke the greet() function and provide the name "John Ibrahim." We pass that value to a variable and print the variable email message because it returns a value.

When it comes to customizing your functions, the return value function is the best option because it allows you to do almost anything. You can print it, save it to a file, or send it as an email message.

Keyword Arguments

Functions can take information as arguments.
Arguments are enclosed in parentheses after the function name. You may enter as many arguments as you want, separated by a comma.

def multiplication(number, by):
    return number * by
result = multiplication(4, by=5)
print(result)

In this case, we define our function with multiplication and the parameters number and by, and it returns number * by. We store the value it returns in a variable called result and print it to the terminal because it returns a value. However, in order for other engineers to understand our code, we use a keyword argument with the value of 5. It's as simple as multiplying 4 by 5. In this case, the keyword is by=5.

Default Arguments

Remember what I said earlier about the parameters you define in a function being required by default? Assume we want to multiply a value by 5 using the multiplication function. We'll do something similar.

def multiplication(number, by=5):
    return number * by
result1 = multiplication(4)
result2 = multiplication(4, 2)

As you can see, we gave our parameter by a default values and set it to 5. The variables result1 and result2 were assigned to the multiplication function call.

The result1 will print 20 because the function will multiply the default value which is 5 by 4

the result2 variable will print 8 because you have provided a value 2. therefore 4 * 2

Please note that all optional parameters must come after the required parameters. This means that nothing else can be added after the default parameter by=5. Any additional parameters added after that will result in an error.

Arbitrary Arguments, shortened as *args

There are times when multiple arguments are required in your functions. If we want to multiply five numbers (1, 2, 3, 4, 5), we can do so as shown below.

def multiplication(*numbers):
    result = 1
    for number in numbers:
        result = result * number
    return result
answer = multiplication(1, 2, 3, 4, 5)
print(answer)

We provided a single argument number denoted by an asterisk *. The asterisk indicates that numbers can have multiple arguments. To compute the product of this number, we define a variable result and set it to 1. Then, in a loop, we multiply each numbers by the current number. The result is then returned, and the answer is printed.
The product is 120.

Arbitrary Arguments, shortened as **args

Assume you want a function that saves user information. A user's detail is more than just his or her name; a user can have many details. In this case, we use Arbitrary Arguments. We can do something similar down below.

def user_details(**user):
    print(user)
user_details(id=1, name="James", age="25", marital_status="single", location="lagos", job="software Engineer")

To save user information, we named our parameter user with a double asterisk **. The user argument is then printed. This is then called user_datails, and key value such as id, name, age, marital_status, location and jobare passed in. We can bring in as many as we want. We were then have

{'id': 1, 'name': 'James', 'ages': '25', 'marital_status': 'single', 'location': 'lagos', 'job': 'software Engineer'}

What you are seeing is called a dictionary. A dictionary is a data structure in Python. As you can see, we have multiple key value pairs. The key id is 1, the key name is James, and so on. When we use double asterisk, we can pass in different arguments and Python will package them into a dictionary. Click here to learn more about dictionary.

Function scope

"Scope" refers to the area of code where a variable is defined.

Local Variables

A local variable has a short life time. It cannot be accessed outside of the function scope.

def greetings():
     message = 'Good Morning'
print(message)

We have the message variable which is in the scope of the greet function. It only exists within this function. If we try to print the message, it will fail because the print function is not within the scope. The same thing happens if we pass in a parameter that is not within the scope. This is referred to as a local variable.

Global Variable

message = 'Good Morning'
def greetings():
    print(message)
greetings()

We moved the message variable outside of the functions, making it accessible anywhere in the function, outside of the functions, and in the file.

It is not always advisable to use global variables because if you have many functions that use the global variable and make changes in one of them, the rest of the functions are affected. If you're going to use global scope, avoid modification. There should always be a function with parameters and local variables.

Wrapping-up

In this article, I have been able to explain what a function is in python, how to create your own custom function, I explained arguments, keyword arguments and fuctions scope. I hope you have been able to learn something new.

Your feedback is highly appreciated.
you can follow me on twitter and linkedIn

How To Use List Comprehension in Python

Isah Jacob — Tue, 06 Sep 2022 14:02:04 +0000

You spend a lot of time coding, which can be exhausting. Python cares about your mental health, which is why it has tools like list comprehension to help you with your work.

List comprehension allows you to create a list with a single line of code. List are collections of data separated by commas and covered by square brackets. A list comprehension is surrounded by square brackets as well, but instead of data, expressions are entered, followed by for-loops and if clauses.

List: [1, 2, 3, 4, "a", "b", True, False, 10.90]

List Comprehensions: [expression for value in collection]

List comprehension allows us to manipulate items on a list. If you want to change a single list item, simply change the index and the value.

When you want to access a specific item in a list, list comprehension can also help you extract information. it can also be used to filter items in a list.

For-loops In A List comprehension

The expression below generates the elements in a list, followed by a for-loop over collections data this will evaluate the expression for every element in the collection.

[expression for value in comprehension]

If you only want to include the expression for certain pieces of data, you can add an if clause after the for-loop. The expression will be added to the list only if the if clause is True

[expression for value in collection if <test>]

You can have more than one if clause as you can see from below and the expression is in the list only if the if clauses are True.

[expression for value in collection if <test1> and <test2>]

You can also loop over more than one collection in a list

[expression for value1 in collection1 and value2 in collection2]

List A Square Of Numbers

Let’s create an empty list called find square number and loop over 10 positive integers. And append the square of i to the list.

squares = []
for i in range(1, 11):
    squares.append(i ** 2)
print(squares)
this will print 
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

You can use list comprehension to do the same in a single line of code and will arrive at the same result.

squares = [i ** 2 for i in range(1, 10)]
print(squares)
this will print 
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Manipulating List Item With A List Comprehension

List comprehension is always based on the following logic: Assume you already have a list with many products. We'll refer to it as

products_list = [1, 2, 3, 4, 5].

You can access this list and do something with it by adding, multiplying, or looking up specific product numbers. After that, save the changes as a new list.
Let's multiply the product list by two. You need access to each list item to multiply them by 2. To accomplish this, You will use a for-loop to loop through the product list. You'll do something similar down below.

create an empty list to store the new changes.
new_product_list = []
products_list = [1, 2, 3, 4, 5]
for an item in products_list:  # we will use the .append method to add each item multiplied by 2 in the new list.
    new_product_list.append(item * 2)
print(new_product_list)
the print out will be
[2, 4, 6, 8, 10]

When you want to create a new list from any iterable, it is a good practice to make use of list comprehension because it aids readability and that's the best practice. Let’s see how you replicate the above using list comprehension.

products_list = [1, 2, 3, 4, 5]
new_product_list = [item * 2 for item in products_list]
print(new_product_list)
the print out will be
[2, 4, 6, 8, 10]

List comprehension reads from the left-hand side by multiplying items by 2 then the for-loop loop through the product list.
We have printed the desired result without using the append methods and everything in a single line.

Repeating Items In A List Comprehension

Let’s say you want to repeat the product list by 2. You will do something like this below.

products_list = [1, 2, 3, 4, 5, ]
product_list = products_list * 2
print(product_list)
This will print [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

As you can see the asterisk (*) is not for multiplication in this case. It is for repetition.

NOTE:_In python (**) represents exponential and if you add two lists, it concatenates them.

How To Access A Specific Item In A List

You can also use list comprehension to access a specific item in a list.

To demonstrate this, let’s create a list containing the student registration number, student name, subject, and score.

students = [{'reg_number': 101, 'name': 'Kenny', 'subject': 'python programming Language', 'score': 78},
            {'reg_number': 212, 'name': 'Blessing', 'subject': 'java programming Language', 'score': 65},
            {'reg_number': 322, 'name': 'Ibrahim', 'subject': 'typeScript programming Language', 'score': 87},
            {'reg_number': 434, 'name': 'John', 'subject': 'javaScript programming Language', 'score': 90},
            {'reg_number': 545, 'name': 'Enema', 'subject': 'data analyst', 'score': 35}
            ]
print(students)
[{'reg_number': 101, 'name': 'Kenny', 'subject': 'python programming Language', 'score': 78}, {'reg_number': 212, 'name': 'Blessing', 'subject': 'java programming Language', 'score': 65}, {'reg_number': 322, 'name': 'Ibrahim', 'subject': 'typeScript programming Language', 'score': 87}, {'reg_number': 434, 'name': 'John', 'subject': 'javaScript programming Language', 'score': 90}, {'reg_number': 545, 'name': 'Enema', 'subject': 'data analyst', 'score': 35}]

You have been able to create a student dictionary list with the reg number, name, subject, and score as the keys followed by the corresponding value. You can read more on the dictionary list here.

You Can Access All Student Names From The List

student_name = [student['name'] for student in students]
print(student_name)
# ['Kenny', 'Blessing', 'Ibrahim', 'John', 'Enema']
this will print 
['Kenny', 'Blessing', 'Ibrahim', 'John', 'Enema']

What you did is loop through students to enable us to access the name key. You are not limited to the name alone, you can also use the same method to access the subject or score.

How To Filter List Items

You filter list items to find information about specific items or if they meet a specific condition. Maybe you are looking for the lowest student in a class or the highest student in a class.
What you need to do here is to add conditions that check for students who scored lower marks in a class.

student_name = [student['name'] for student in students if student['score'] <= 35]
print(student_name)
 this will print Enema

This will print Enema because that is the student with the lowest score.

Suppose you want to find a student whose name starts with the letter “B” among your students, you will do something like this below:

names_letters = [name for name in students if name['name'].startswith('B')]
print(names_letters)
[{'reg_number': 212, 'name': 'Blessing', 'subject': 'java programming Language', 'score': 65}]

this will print everything regarding the student whose name starts with the letter B.
[{'reg_number': 212, 'name': 'Blessing', 'subject': 'java programming Language', 'score': 65}]

You can also check for the names of students and their scores.
You can do something like this below.

name_and_score = [{'name': student['name'], 'score': student['score']} for student in students]
print(name_and_score)
we have this as our output 
[{'name': 'Kenny', 'score': 78}, {'name': 'Blessing', 'score': 65}, {'name': 'Ibrahim', 'score': 87}, {'name': 'John', 'score': 90}, {'name': 'Enema', 'score': 35}]

Checking For List Length

You can also check the length of a list using the len() method.

Students_lenght = len(students)
no_of_users = len(students)
print(no_of_users)
this will print 5 because we have 5 students on our list

Wrap up

In this article, I have been able to explain different ways list comprehension can be applied in python code. With list comprehension, you can build a complex list using a single line of code. Python loves you and wants to protect your sanity.

You can follow me on Twitter and on Linkedin

DEV Community: Isah Jacob

Outreachy Call for June 2025 Cohort mentoring.

Why Mentorship Matters in Open Source

Questions to ponder

Key Dates for the June 2025 Outreachy Cohort

How to Get Started as a Mentor

Questions to consider:

The Impact of Mentorship: Stories from the Community

How Open Source Drives Innovation Through Mentorship

Tips for Being an Effective Mentor

Join the Movement: Share Your Thoughts and Experiences

Stay Updated and Keep Learning

Final Thoughts

I want to hear from you

Best Open Source CRM

Open Source CRM

What is an Open-Source CRM?

Why Choose an Open-Source CRM?

Open-source CRMs address these issues by offering:

Top Open-Source CRM Solutions in 2025

Addressing Common Concerns

Is Open-Source CRM Secure?

What About Support and Maintenance?

How Do I Ensure the CRM Aligns with My Business Processes?

Real-World Example: A Small Business's Journey with Open-Source CRM

Keeping Your CRM Up-to-Date

Frontend and Backend Integration with RESTful APIs in Python and Django

What is Frontend-Backend Integration?

Introduction to RESTful APIs and How They Work

Setting Up a RESTful API in Django

Step 1: Set Up Your Django Project

Creating a virtual environment in django

activate virtual environment on windows

activate virtual environment on linux

Step 2: Install Django REST Framework (DRF)

Step 3: Create a Model

What are the migrations in Django?

Run the following commands to create and apply migrations:

Step 4: Create a Serializer File in Myapp folder

Step 5: Define Views

Step 6: Configure URLs

Integrating the Frontend with the Django Backend

Step 1: Fetching Data (GET Request)

Steps 2 and 3: Sending Data (POST Request) and Updating Data (PUT Request)

Common Challenges in Frontend-Backend Integration

Conclusion

How to Build an Online Banking System – Python Object-Oriented Programming Tutorial

Exploring the Basics of Objects and Methods in Java

What are objects in Java?

What is a constructor in Java?

What Are Methods in Java?

Void Method in Java

Parameters and return values in methods

Wrapping-up

A Beginner's Guide to Java Basics

Java Syntax and Structure

Print Statement in Java

Data Types and Variables

Operators

Assignment operators

Relational operators

Logical operators

Bitwise operators

Control statements (if, while, and loops)

If Statement

While-loop

for Loop

Do-while Loop

Wrapping-Up

Understanding APIs: A Beginner's Primer

What is API?

The importance of APIs in Modern Technology

How APIs Work in Modern Technology

Request-Response Cycle

API Endpoints

Data Formats

API Authentication and Authorization

Types of APIs

REST API

SOAP API

Step 4: Create a `Serializer` File in Myapp folder