DEV Community: nadirbasalamah

API Performance Testing with k6 - A Quick Start Guide

nadirbasalamah — Tue, 04 Feb 2025 06:25:00 +0000

Introduction

The definition of a high-quality REST API application is an application that can operate well and perform well. The performance of the REST API can be measured by performance testing to ensure the application is operational, scalable, and reliable on many different workloads. From normal workloads to unexpected heavy workloads.

Why Performance Testing?

The performance testing provides some benefits during REST API development:

Ensuring the performance of the REST API meets the desired standards, especially in unexpected workloads.
Detecting performance bottlenecks earlier before it went to production.

What is k6?

Many tools can be used for performance testing. One of those is k6. k6 is a performance testing tool developed by Grafana Labs for conducting performance testing in various platforms like REST API and web applications. The k6 is a code-based tool which means the testing script is written in a Javascript code. The k6 can be utilized even more by using additional plugins and extensions.

k6 Setup

These are the required steps for using k6:

Install the k6. The k6 is available in Docker container and binary. Make sure to install it based on the operating system that is being used.
Configure the code editor. The code editor needs to be configured to enable the IntelliSense feature to enhance the developer experience when writing testing scripts.

Writing the First Test

The k6 testing scripts can be organized into one project because when working in a project, the scripts can be organized easily.

Create the npm project by running this command.

npm init --yes

If you want to specify the additional information of the project, use npm init.

After that, install the k6 types for enabling IntelliSense feature.

npm install --save-dev @types/k6

The test script can be generated automatically using k6 new command. This is the structure of the command.

k6 new <directory_name>/filename.js

make sure the directory is exists.

If the directory location is not specified. This command creates a test script in the current working directory. The test script can be created manually as well.

This is the example of creating a new test script in the src directory.

k6 new src/test.js

This is the content of the created test script. The comments inside the test script is already removed.

import http from "k6/http";
import { sleep } from "k6";

export const options = {
  // A number specifying the number of VUs to run concurrently.
  vus: 10,
  // A string specifying the total duration of the test run.
  duration: "30s",
};

export default function () {
  http.get("https://test.k6.io");
  sleep(1);
}

The test can be executed using k6 run command followed by the file name.

k6 run src/test.js

This is the output of the test.

After the test is executed, the k6 generates a summary output that describes information like the number of successful requests, duration of the requests, and others. This is a detailed explanation of the output summary.

Standard built-in metrics

Metric name	Description
checks	The rate of successful checks
data_received	The amount of received data
data_send	The amount of sent data
iteration_duration	The amount of time to complete a single iteration
iterations	The aggregate number of times the VUs execute the test script (the `default` function)
vus	The current number of active virtual users
vus_max	The maximum potential number of virtual users

HTTP-specific built-in metrics

Metric name	Description
http_req_blocked	Time to spent waiting for a free TCP connection slot before initiating the request
http_req_connecting	The duration of establishing a TCP connection to the remote host
http_req_duration	The total duration of the request
http_req_failed	The rate of failed requests according to `setResponseCallback`
http_req_receiving	The duration of receiving response data from the remote host
http_req_sending	The duration of sending data to the remote host
http_req_tls_handshaking	The duration of establishing TLS handshake session with remote host
http_req_waiting	The duration of waiting for the response from the remote host
http_reqs	The total amount of generated HTTP requests by k6

Learn more about the k6 metrics here.

Load Testing Types

There are many types of load testing for measuring the performance of the system. Each type serves different purposes and requirements.

Smoke Testing

The smoke testing ensures the system is operational with a minimal load and verifies the test scripts. The smoke testing must be executed with a small number of virtual users (from 2 up to 5 VUs) and short duration.

This is an example of smoke testing for getting all posts feature.

import http from "k6/http";
import { check } from "k6";

export const options = {
  vus: 3, // 3 virtual users
  duration: "40s", // duration is 40 seconds
};

export default function () {
  // sends GET request
  const response = http.get("https://jsonplaceholder.typicode.com/posts");

  // validate the response
  check(response, {
    "is status 200": (r) => r.status === 200,
    "is not null": (r) => r.json() !== null,
  });
}

Average Load Testing

The average load testing ensures the system is operational with typical loads. Typical loads mean the workload during the regular day in a production environment.

This is the example of average load testing for getting all posts feature.

import http from "k6/http";
import { check } from "k6";

export const options = {
  stages: [
    { duration: "5m", target: 100 }, // traffic ramp-up from 1 to 100 users over 5 minutes.
    { duration: "30m", target: 100 }, // stay at 100 users for 30 minutes
    { duration: "5m", target: 0 }, // ramp-down to 0 users
  ],
};

// function for generating random string
const generateRandomString = (start, end) => {
  const res = Math.random().toString(36).substring(start, end);
  return res;
};

// function for generating random ID
const generateRandomId = () => {
  const id = Math.floor(Math.random() * 1000);
  return id;
};

export default function () {
  // prepare request body
  const requestBody = {
    title: generateRandomString(1, 7),
    body: generateRandomString(1, 20),
    userId: generateRandomId(),
  };

  // sends POST request
  const response = http.post(
    "https://jsonplaceholder.typicode.com/posts",
    JSON.stringify(requestBody),
    {
      headers: {
        "Content-Type": "application/json",
        Accept: "application/json",
      },
    }
  );

  // validate the response
  check(response, {
    "is status 201": (r) => r.status === 201,
    "is not null": (r) => r.json() !== null,
    "is contains valid id": (r) => r.json().id > 0,
    "is contains valid title": (r) => r.json().title !== "",
    "is contains valid body": (r) => r.json().body !== "",
  });
}

Stress Testing

The stress testing ensures the system is operational with heavier loads than usual. The stress testing verifies the stability and reliability of the system under heavy workloads. The system may receive heavy workloads in many moments such as flash-sale, payday, school or university admission process, and other similar moments. When conducting the stress testing, the number of workloads must be heavier than typical workloads and must be executed after average load testing.

This is an example of stress testing for creating a new post feature.

import http from "k6/http";
import { check } from "k6";

export const options = {
  stages: [
    { duration: "10m", target: 200 }, // traffic ramp-up from 1 to a higher 200 users over 10 minutes.
    { duration: "30m", target: 200 }, // stay at higher 200 users for 30 minutes
    { duration: "5m", target: 0 }, // ramp-down to 0 users
  ],
};

// function for generating random string
const generateRandomString = (start, end) => {
  const res = Math.random().toString(36).substring(start, end);
  return res;
};

// function for generating random ID
const generateRandomId = () => {
  const id = Math.floor(Math.random() * 1000);
  return id;
};

export default function () {
  // prepare request body
  const requestBody = {
    title: generateRandomString(1, 7),
    body: generateRandomString(1, 20),
    userId: generateRandomId(),
  };

  // sends POST request
  const response = http.post(
    "https://jsonplaceholder.typicode.com/posts",
    JSON.stringify(requestBody),
    {
      headers: {
        "Content-Type": "application/json",
        Accept: "application/json",
      },
    }
  );

  // validate the response
  check(response, {
    "is status 201": (r) => r.status === 201,
    "is not null": (r) => r.json() !== null,
    "is contains valid id": (r) => r.json().id > 0,
    "is contains valid title": (r) => r.json().title !== "",
    "is contains valid body": (r) => r.json().body !== "",
  });
}

Spike Testing

The spike testing ensures the system is operational with suddenly heavy workloads. Examples of sudden heavy workloads are product launch events, limited-time discount,s and others. During spike testing, the heavy workloads increased suddenly without any ramp-down or "pause time".

This is an example of spike testing for updating a post feature.

import http from "k6/http";
import { check } from "k6";

export const options = {
  stages: [
    { duration: "2m", target: 500 }, // fast ramp-up without any break
    { duration: "1m", target: 0 }, // quick ramp-down
  ],
};

// function for generating random string
const generateRandomString = (start, end) => {
  const res = Math.random().toString(36).substring(start, end);
  return res;
};

// function for generating random ID
const generateRandomId = () => {
  const id = Math.floor(Math.random() * 100);
  return id;
};

export default function () {
  const sampleId = generateRandomId();

  // prepare request body
  const requestBody = {
    title: generateRandomString(1, 7),
    body: generateRandomString(1, 20),
    userId: sampleId,
  };

  // sends PUT request
  const response = http.put(
    `https://jsonplaceholder.typicode.com/posts/${sampleId}`,
    JSON.stringify(requestBody),
    {
      headers: {
        "Content-Type": "application/json",
        Accept: "application/json",
      },
    }
  );

  // validate the response
  check(response, {
    "is status 200": (r) => r.status === 200,
    "is not null": (r) => r.json() !== null,
    "is contains valid id": (r) => r.json().id > 0,
    "is contains valid title": (r) => r.json().title !== "",
    "is contains valid body": (r) => r.json().body !== "",
  });
}

Endurance Testing

The endurance testing (also known as soak testing) ensures the system is operational with average loads for a long duration. This test measures the performance degradation and the availability and stability during long periods.

The endurance testing can be executed after the smoke and average load tests are executed. The duration of this test must be longer than any other kind of test.

Actually, the typical duration is in hours like 3,4,12, and up to 72 hours. For this example, the duration is reduced.

This is an example of endurance testing for creating a post feature.

import http from "k6/http";
import { check } from "k6";

export const options = {
  stages: [
    { duration: "10m", target: 100 }, // traffic ramp-up from 1 to 100 users over 10 minutes.
    { duration: "30m", target: 100 }, // stay at 100 users for 30 minutes
    { duration: "10m", target: 0 }, // ramp-down to 0 users
  ],
};

// function for generating random string
const generateRandomString = (start, end) => {
  const res = Math.random().toString(36).substring(start, end);
  return res;
};

// function for generating random ID
const generateRandomId = () => {
  const id = Math.floor(Math.random() * 1000);
  return id;
};

export default function () {
  // prepare request body
  const requestBody = {
    title: generateRandomString(1, 7),
    body: generateRandomString(1, 20),
    userId: generateRandomId(),
  };

  // sends POST request
  const response = http.post(
    "https://jsonplaceholder.typicode.com/posts",
    JSON.stringify(requestBody),
    {
      headers: {
        "Content-Type": "application/json",
        Accept: "application/json",
      },
    }
  );

  // validate the response
  check(response, {
    "is status 201": (r) => r.status === 201,
    "is not null": (r) => r.json() !== null,
    "is contains valid id": (r) => r.json().id > 0,
    "is contains valid title": (r) => r.json().title !== "",
    "is contains valid body": (r) => r.json().body !== "",
  });
}

Using k6 Additional Libraries

The k6 provides additional Javascript libraries for enhancing testing processes like additional utilities, assertions, and others.

Assertion with k6chaijs

The assertion is a process to validate the response. The assertion is done by comparing the expected and the actual value. The assertion process can be done easily and comprehensively using k6chaijs. This library enables chai style assertion in the k6 test script.

In this example, the assertion is implemented using k6chaijs for testing the create post feature.

import http from "k6/http";
import {
  describe,
  expect,
} from "https://jslib.k6.io/k6chaijs/4.5.0.1/index.js";
import {
  randomIntBetween,
  randomString,
} from "https://jslib.k6.io/k6-utils/1.4.0/index.js";

export const options = {
  vus: 10,
  duration: "30s",
};

export default function () {
  describe("Create a new post", () => {
    // prepare request body
    const requestBody = {
      title: randomString(20),
      body: randomString(200),
      userId: randomIntBetween(1, 99),
    };

    // sends POST request
    const response = http.post(
      "https://jsonplaceholder.typicode.com/posts",
      JSON.stringify(requestBody),
      {
        headers: {
          "Content-Type": "application/json",
          Accept: "application/json",
        },
      }
    );

    // convert to JSON
    const jsonResponse = response.json();

    // perform assertions with k6chaijs
    expect(response.status, "response status").to.equal(201);
    expect(response).to.have.validJsonBody();
    expect(jsonResponse.id, "post ID").to.be.above(0);
    expect(jsonResponse.title, "title").to.not.equal(null);
    expect(jsonResponse.body, "body").to.not.equal(null);
    expect(jsonResponse.userId, "user ID").to.be.above(0);
  });
}

Data-driven Test with Papaparse

The data-driven test in k6 can be implemented using Papaparse. Papaparse is a library for reading and processing CSV files.

In this example, the data-driven test is implemented for testing the update post feature.

The sample CSV file is available in the Github repository.

First, create an additional helper for retrieving random posts inside the random.js file in the helpers directory. The helpers directory is created inside the src directory.

export function getRandomPost(csvData) {
  let randIndex = getRandomInt(0, csvData.length);
  return {
    postData: csvData[randIndex],
    id: randIndex,
  };
}

function getRandomInt(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min)) + min;
}

Then, create a test script for testing the update post feature. In this script, the Papaparse library is utilized for reading the CSV file enabling data-driven testing.

import http from "k6/http";
import { SharedArray } from "k6/data";
import papaparse from "https://jslib.k6.io/papaparse/5.1.1/index.js";
import {
  describe,
  expect,
} from "https://jslib.k6.io/k6chaijs/4.3.4.3/index.js";
import { getRandomPost } from "./helper/random.js";

export const options = {
  vus: 20,
  duration: "30s",
};

const csvData = new SharedArray("sample user dataset", () => {
  // load CSV file
  return papaparse.parse(open("../resources/posts.csv"), { header: true }).data;
});

export default function () {
  describe("Update a post", () => {
    // get random post data from CSV
    const { postData, id } = getRandomPost(csvData);

    // prepare request body
    const requestBody = {
      title: postData.title,
      body: postData.body,
      userId: postData.userId,
    };

    // sends PUT request
    const response = http.put(
      `https://jsonplaceholder.typicode.com/posts/${id}`,
      JSON.stringify(requestBody),
      {
        headers: {
          "Content-Type": "application/json",
          Accept: "application/json",
        },
      }
    );

    const jsonResponse = response.json();

    // perform assertions with k6chaijs
    expect(response.status, "response status").to.equal(200);
    expect(response).to.have.validJsonBody();
    expect(jsonResponse.id, "post ID").to.be.above(0);
    expect(jsonResponse.title, "title").to.not.equal(null);
    expect(jsonResponse.body, "body").to.not.equal(null);
    expect(jsonResponse.userId, "user ID").to.be.above(0);
  });
}

Resources

I hope this article helps you to learn about API performance testing using k6.

Do you have any experience working on performance testing using k6? Please let me know in the comments down below 👇

Thank you

What I've Done So Far in 2024

nadirbasalamah — Mon, 06 Jan 2025 07:23:41 +0000

This is a submission for the 2025 New Year Writing challenge: Retro’ing and Debugging 2024.

2024 has been a wild ride for me with a "full-packed" of activities including mentoring, developing side projects, and learning new things. In this post, I'll tell you what I've done so far in 2024.

🏆 Achievements

In 2024, I mentored more than 50 students in various boot camp programs including SIB Kampus Merdeka Batch 6, Talent Class Batch 12 by the Indonesian Ministry of Labour, and UNHCR Tech Bootcamp.

I have mentored in the software quality assurance field in two boot camp programs including SIB Kampus Merdeka Batch 6 and Talent Class Batch 12 by the Indonesian Ministry of Labour. These boot camps cover the software quality assurance process comprehensively from the essentials like understanding the urgency of software testing and creating test cases up to automation testing.

On the other hand, I have mentored in the back-end development field in the UNHCR tech boot camp. This boot camp covers the back-end development from the basics like basic programming with Go, REST API, database, software architecture, unit testing up to deployment process.

Besides mentoring, I have created side projects to enhance my skills. These are my side projects:

go-cms-gql: A GraphQL application for managing contents.
go-ads-management: A REST API service for managing ads.

Both these projects are developed using the Go programming language and utilize generative AI for recommendation features.

🧩 Challenges

In 2024, there are many challenges that I have to face. These challenges provide me a valuable insights:

🎯 Stay focused and organized: In 2024, I have to deal with many boot camp programs. Each program has different characteristics and challenges as well. To handle these challenges, I use Notion to organize the tasks by specifying the key objective of the task and its sub-tasks. By organizing tasks, I can complete all the tasks effectively.

Obviously, we can use another tool like Trello, Clickup, or others.

🙌 Provide additional assistance: One of the challenges in a boot camp is the student who struggles with the boot camp materials. To solve this issue, I have to provide additional assistance by performing 101 private sessions with the student and holding additional classes. This additional assistance helps the student to understand the material better resulting in the student can continue to complete the bootcamp.
📖 Learn new things: In 2024, I was assigned a task to develop course materials to ensure the materials are up-to-date and relevant to the industry's needs. In the development process, I have learned many new things like code profiling for measuring the efficiency of the source codes and other fields like generative AI implementations and cyber security.

💡 Lessons Learned

2024 taught me some valuable lessons to survive and stay relevant. These are the valuable lessons from my "2024 season":

🔎 Keep exploring: The technologies are evolving. To stay relevant, we have to explore many new technologies in many ways like learning and creating side projects that utilize those new technologies.
💻 Start sharing: One of the effective ways of learning is by sharing our knowledge with many people. We can share our knowledge by writing a post on social media like LinkedIn, dev.to, or other platforms. By sharing, we can provide insight that hopefully is valuable for the readers.

✨ What's Next?

I am excited for the 2025 season ahead. The main goal of this year is to contribute to a tech world that can have a positive impact on many people. Hopefully, I can contribute, learn, and develop myself even further this year. 🚀

Thank you for reading this post. I hope you find valuable insights from it.

Do you have any valuable moments in your 2024 season? Please let me know in the comments section below.

Python Tutorial - 4 Function

nadirbasalamah — Mon, 06 Jan 2025 02:30:20 +0000

Introduction

The function is a callable unit containing instructions, aimed at reducing code duplication and organizing complex tasks. There are two types: void functions (no return value) and those that return a value.

This is the basic structure of function in Python.

def function_name(args):
    function body

This is an example of a void function (no return value) in Python.

# create a function
def hello():
    print("hello!")

# call the function
hello()

Output

hello!

Based on the code above, the function called hello() is created. The function is called by specifying the function name followed by parentheses ().

This is an example of fa unction with the return value.

# create a function with return value
def add(a,b):
    return a + b

result = add(2,4)

print(result)

Output

Based on the code above, the function called add() is created to sum two numbers. The return value of the add() function is stored inside the result variable.

When working with the return value function, ensure the returned value is being used.

Arguments and Keyword Arguments

The function in Python can take multiple arguments dynamically. There are two approaches to implementing multiple arguments in a function:

Arguments: the multiple arguments are implemented in a function without specifying the keywords. the arguments can be implemented using *args.
Keyword arguments: the multiple arguments are implemented in a function with the specified keywords. the keyword arguments can be implemented using **kwargs.

Both arguments and keyword arguments must be located in the last position of the argument definition in a function.

This is an example of multiple arguments implementation using the arguments approach to calculate the sum of the numbers dynamically.

def sum(*args):
    result = 0
    for arg in args:
        result += arg
    return result

print(sum(1,2))
print(sum(1,2,3))
print(sum(1,2,3,4,5,4,3,2))

Output

3
6
24

Based on the code above, the sum() function can be called with a different number of parameters.

This is an example of multiple arguments implementation using the keyword arguments approach.

def display_info(name,**kwargs):
    print("========")
    print(f"name: {name}")
    print("other informations")
    for k, val in kwargs.items():
        print(f"{k}: {val}")
    print("========")

display_info("john",job="programmer",company="acme inc")
display_info("doe",job="programmer",company="acme inc",skills="go,java,php")

Output

========
name: john
other informations
job: programmer
company: acme inc
========
========
name: doe
other informations
job: programmer
company: acme inc
skills: go,java,php
========

Based on the code above, the display_info() function can be called with a different number of parameters. By using **kwargs, the parameters can be defined with the keywords.

Both arguments and keyword arguments can be used together. This is an example.

def display(*args,**kwargs):
    print("===========")
    print("items")
    for arg in args:
        print(arg)
    print("other information")
    for k, val in kwargs.items():
        print(f"{k}: {val}")
    print("===========")

display("apple","coffee","milk",payment="cash")
display("TV","Camera",payment="cash",delivery="express")

Output

===========
items
apple
coffee
milk
other information
payment: cash
===========
===========
items
TV
Camera
other information
payment: cash
delivery: express
===========

Recursive Function

The recursive function is a function that calls itself when accomplishing its task. The recursive function can solve many problems including factorial numbers, the Fibonacci sequence, and others.

There are two main components in a recursive function:

Base case: the base case defines when the function is stopped.
Recurrence relation: the recurrence relation defines the recursive process of the function.

In this example, the factorial calculation is implemented using a recursive function.

def factorial(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n-1)

# call the function
result = factorial(5)

print(result)

Output

Let's take a closer look to the factorial() function. There are two components involved in this function:

base case: the function execution terminates if the value of n equals to 0 or 1.
recurrence relation: the function executes if the value of n greater than 1.

def factorial(n):
    if n == 0 or n == 1: # base case
        return 1
    else:
        return n * factorial(n-1) # recurrence relation

The factorial() function is illustrated in this picture below.

Lambda

The lambda is an anonymous function. The lambda can contain many arguments just like function in general. The lambda function is suitable for creating a small function that returns the value directly.

This is an example of the sum() function.

def sum(a,b):
    return a + b

This is the example of a lambda function to sum two numbers. The lambda function is stored inside a variable called sum_func.

sum_func = lambda a,b: a + b

To use the lambda function, call the function by its variable name.

sum_func = lambda a,b: a + b

# call the function
print(sum_func(1,2))

Map and Filter

Map Function

The map() function executes a provided callback function for each item inside a list.

This is the example of the map() function to multiply each number by 3.

# create a function to multiply a number by 3
def triple(num):
    return num * 3


# list of numbers
numbers = [1, 2, 3, 4, 5]

# call triple() function for each item in a numbers
map_result = map(triple, numbers)

# convert the map result into the list
result = list(map_result)

# display the result
print(f"result: {result}")

Output

result: [3, 6, 9, 12, 15]

Based on the code above, the triple() function acts as a callback for the map() function which means the triple() function is called for each item in the numbers list. Then, the result of the map() function is converted into the list and then stored inside the variable called result.

The example above can be simplified using the lambda function.

# list of numbers
numbers = [1, 2, 3, 4, 5]

# using lambda function to multiply the number by 3
# then convert the result to the list
result = list(map(lambda num: num * 3, numbers))

# display the result
print(f"result: {result}")

Output

result: [3, 6, 9, 12, 15]

Filter Function

The filter() function selects the item inside a list based on the given callback function. The filter() function is suitable for filtering the items inside a list by using the provided callback function. The filter() function requires a callback function that returns a boolean value.

This is the example of the filter() function to select only even numbers in a list.

# create a function to check if the number is even
def is_even(num):
    return num % 2 == 0


# list of numbers
numbers = [11, 2, 4, 25, 65, 19, 20]

# select only even numbers
# then convert the result to the list
result = list(filter(is_even, numbers))

print(f"even numbers: {result}")

Output

even numbers: [2, 4, 20]

Based on the code above, the filter() function uses is_even() as a callback function to select the even numbers from the list.

This example can be simplified using the lambda function.

# list of numbers
numbers = [11, 2, 4, 25, 65, 19, 20]

# select only even numbers
# then convert the result to the list
result = list(filter(lambda num: num % 2 == 0, numbers))

print(f"even numbers: {result}")

Output

even numbers: [2, 4, 20]

Example - Remove Duplicate Codes

The function can be used to remove duplicate codes. For example, there are two functions called register() and login(). Both functions is using the validation process.

def register(email, password):
    # perform simple validation
    if email != "" and password != "":
        print("register succeed")
    else:
        print("invalid request")


def login(email, password):
    # perform simple validation
    if email != "" and password != "":
        print("login succeed")
    else:
        print("invalid request")

There is a duplicate code for the validation process. To remove these duplicates, the validation process can be wrapped in a separate function.

def validate(email, password):
    return email != "" and password != ""

The validate() function can be used inside the register() and login() functions.

def validate(email, password):
    return email != "" and password != ""


def register(email, password):
    # perform simple validation
    if validate(email, password):
        print("register succeed")
    else:
        print("invalid request")


def login(email, password):
    # perform simple validation
    if validate(email, password):
        print("login succeed")
    else:
        print("invalid request")

Based on the code above, the code is cleaner and easier to modify because if the additional validation rules are updated, the validation rules can be updated in one place (inside the validate() function).

Tips

These are the key tips when working with a function in Python.

The function must complete a single task. If multiple tasks are required, create a separate function for other tasks.
The maximum number of function arguments is 3. If the arguments seem more than 3, consider using a dedicated data object for the function argument.

The maximum number of function arguments seems debatable.

This is the example of the create_account() function using arguments.

def create_user(username, email, password, address):
    # create a new user...
    pass

The create_account() function can be modified to use data object for cleaner code.

def create_user(user: User):
    # create a new user with user data object
    pass

Use documentation to explain the function description. The documentation can be added using """ syntax.

This is an example of using documentation inside a function.

def div(a, b):
    """
    divide two numbers
    """
    if b == 0:
        pass
    else:
        return a / b

Sources

I hope this article helps you learn Python. If you have any feedback, please let me know in the comment section.

Python Tutorial - 3 Data Structure

nadirbasalamah — Mon, 23 Dec 2024 01:14:44 +0000

Introduction

The data structure is a tool for organizing data. Not only for storage but also for solving some problems. There are some data structures in Python including list, dictionary, tuple, and set.

List

A list is a data structure that stores an item sequentially using indices. This is the illustration of the list data structure.

There are many ways to create a list in Python.

Initialize the value directly inside a list.

items = [1,2,3,4]

Initialize an empty list.

items = []

The item inside the list can be accessed directly via the index.

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

# access item at index 2
result = items[2]

print(result) # returns 3

All items inside the list can be retrieved using the for loop. This is an example.

# create a new list
items = [1,2,3,4,5]

# retrieve each item inside a list
for item in items:
    print(item)

Output

Based on the code above, the list called items is created with assigned items. Each item is retrieved using the for loop.

List Basic Operations

The append() function adds a new item to a list. This is an example of append() usage.

# create empty list
shopping_list = []

# add some items
shopping_list.append("apple")
shopping_list.append("milk")
shopping_list.append("cereal")

# retrieve all items
for item in shopping_list:
    print(item)

Output

apple
milk
cereal

The append() is illustrated in the picture below.

Besides the append() function, the insert() function adds a new item in a specific index. This is an example.

items = ["apple","banana","mango","coffee"]

# add new item at index 1
items.insert(1,"cereal")

# retrieve all items
for item in items:
    print(item)

Output

apple
cereal
banana
mango
coffee

The insert() is illustrated in the picture below.

Updating an item inside a list is straightforward. Just specify the index of the item then change it with the updated item.

# create a list
drinks = ["milkshake","black tea","banana milk","mango juice"]

# update value at index 2
drinks[2] = "chocolate milk"

print(f"value at index 2: {drinks[2]}")

Output

value at index 2: chocolate milk

The remove() function removes an item from the list. This is an example.

items = ["apple","banana","mango","coffee"]

# remove "mango"
items.remove("mango")

# remove item at index 1
items.remove(items[1])

print("after removed")
for item in items:
    print(item)

Output

after removed
apple
coffee

The items inside a list can be selected by specifying the start index and end index of the list. This is the basic structure for selecting items in a list.

list_name[start:end]

The items are selected from the start index up to but not including the end index. This is an example of selecting items in a list.

items = ["apple","mango","papaya","coconut","banana"]

# select items from index 1 up to but not including index 3
selected = items[1:3]

# show all items
print(f"all items: {items}")

# show the selected items
print(f"selected: {selected}")

Output

all items: ['apple', 'mango', 'papaya', 'coconut', 'banana']
selected: ['mango', 'papaya']

List Comprehension

List comprehension is a "functional" way to create a list. To understand list comprehension, let's take a look at an example of creating a list that contains even values using an iterative approach.

evens = []

for i in range(1,11):
    evens.append(i*2)

print(evens)

Output

[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Based on the code above, the even numbers are generated using the iterative approach with a for loop. The example above can be achieved also using list comprehension. This is an example of generating even numbers using list comprehension.

evens = [x*2 for x in range(1,11)] # using list comprehension
print(evens)

Output

[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Based on the code above, the list comprehension approach provides more concise code and the same result as the previous iterative approach.

The list comprehension can be used together with if branching. In this example, list comprehension is used to filter certain values based on the specific condition.

samples = [12,32,55,10,2,57,66]

result = [s for s in samples if s % 4 == 0] # using list comprehension

print(result)

Output

[12, 32]

This is the iterative version of the previous example.

samples = [12,32,55,10,2,57,66]

result = []

for s in samples:
    if s % 4 == 0:
        result.append(s)

print(result)

Multi-Dimensional List

The list can be stored in a multi-dimensional approach like a matrix. This is an example of declaring a multi-dimensional list for storing a number matrix.

matrix = [
 [1,2,3],
 [4,5,6],
 [7,8,9],
]

The item can be accessed with double square brackets ([x][y]) by specifying the x that represents the index of the main list whilst y represents the index of the item inside the nested list. This is the illustration of the number matrix.

The items inside the multi-dimensional list can be retrieved by utilizing a nested for loop.

matrix = [
 [1,2,3],
 [4,5,6],
 [7,8,9],
]

# retrieve all items
for m in matrix:
    for num in m:
        print(num)

Output

Dictionary

The dictionary is a data structure that stores records as key-value pairs. Each key must be unique, while duplicate values are permitted. This illustrates the dictionary data structure:

There are many ways to create a dictionary:

Create a dictionary with initialized records.

courses = {
    "C001":"Algorithm",
    "C002":"Data Structure",
    "C003":"Programming in Python",
}

Create an empty dictionary.

courses = {}

All records inside the dictionary can be retrieved using the for loop. This is an example.

# create a dictionary
courses = {
    "C001":"Algorithm",
    "C002":"Data Structure",
    "C003":"Programming in Python",
}

# retrieve all items
# "k" represents item's key
# "v" represents item's value
for k, v in courses.items():
    print(k,v)

Output

C001 Algorithm
C002 Data Structure
C003 Programming in Python

Dictionary Basic Operations

To insert a new item inside a dictionary, specify the key-value pair of the item. Make sure the key is unique.

map_name['key'] = value

This is an example of inserting a new item inside the dictionary.

# create an empty dictionary
courses = {}

# insert courses
courses['C001'] = 'Algorithm'
courses['C002'] = 'Data Engineer'
courses['C003'] = 'Data Science'

# retrieve all courses
for k, v in courses.items():
    print(k,v)

Output

C001 Algorithm
C002 Data Engineer
C003 Data Science

To update an item inside the dictionary, specify the key of the item then insert the updated value.

courses = {
    "C001":"Algorithm",
    "C002":"Data Engineer",
    "C003":"Data Science",
}

print(f"before update: {courses['C002']}")

# update course with key equals to C002
courses['C002'] = "Data Analyst"

print(f"after update: {courses['C002']}")

Output

before update: Data Engineer
after update: Data Analyst

The keys and values in the dictionary can be accessed independently using different methods.

courses = {
    "C001":"Algorithm",
    "C002":"Data Engineer",
    "C003":"Data Science",
}

# retrieve keys
course_keys = courses.keys()
print(f"keys: {course_keys}")

# retrieve values
course_values = courses.values()
print(f"values: {course_values}")

Output

keys: dict_keys(['C001', 'C002', 'C003'])
values: dict_values(['Algorithm', 'Data Engineer', 'Data Science'])

The pop() method removes the item from the dictionary based on the given key.

courses = {
    "C001":"Algorithm",
    "C002":"Data Engineer",
    "C003":"Data Science",
}

# remove course with key equals to C003
courses.pop('C003')

for k, v in courses.items():
    print(k,v)

Output

C001 Algorithm
C002 Data Engineer

The clear() method removes all items inside the dictionary.

courses = {
    "C001":"Algorithm",
    "C002":"Data Engineer",
    "C003":"Data Science",
}

# remove all items
courses.clear()

# check if the dictionary is empty
is_empty = len(courses.values()) == 0

print(is_empty)

Output

True

Tuple

The tuple is an immutable data structure for storing many values. The tuple may contain mutable values. There are two ways to create a new tuple.

Create a tuple with assigned values.

# create a tuple with assigned values
fruits = ("apple","banana","mango")

# retrieve all values
for f in fruits:
    print(f)

Output

apple
banana
mango

Create an empty tuple.

# create an empty tuple
fruits = ()

Tuple Basic Operations

A tuple is immutable, which means that its values cannot be changed or updated once it has been created.

# create a tuple with assigned values
fruits = ("apple","banana","mango")

# error, tuple is immutable
fruits[0] = "starfruit"

The values from the tuple can be retrieved using "tuple unpacking" (this concept is similar to object destructuring in JavaScript).

When unpacking, the size of the unpacked values must equal the size of the tuple.

# create a tuple with assigned values
fruits = ("apple","banana","mango")

# tuple unpacking
(one, two, three) = fruits

print(one,two,three)

Output

apple banana mango

Set

A set is an unordered data structure that only contains unique items. There are many ways to create a set.

# create a set with assigned values
data = {1,2,3,4}

# create a set with set() function
records = set(['milk','coffee','juice'])

The empty set can be created using the set() function.

empty_set = set()

The set data structure removes duplicate values automatically.

# create a set with assigned values
data = {1,1,1,2,2,2,3,3,4,5,4}

for d in data:
    print(d)

Output

The values inside the set can be accessed using the for loop.

# create a set with assigned values
data = {1,2,3,4}

for d in data:
    print(d)

Output

Set Basic Operations

The set data structure provides many operations like union, intersection, difference, and symmetric difference.

The union operation returns all items in both sets.

data1 = {'burger','kebab','noodle','pasta','pizza'}
data2 = {'burger','french fries','pasta','cereal','biscuit'}

result = data1 | data2

print(result)

Output

{'burger', 'cereal', 'french fries', 'noodle', 'kebab', 'pizza', 'pasta', 'biscuit'}

The intersection operation returns all items that exist in the intersection of the sets.

data1 = {'burger','kebab','noodle','pasta','pizza'}
data2 = {'burger','french fries','pasta','cereal','biscuit'}

result = data1 & data2

print(result)

Output

{'burger', 'pasta'}

The difference operation returns all items that only exist in a certain set.

data1 = {'burger','kebab','noodle','pasta','pizza'}
data2 = {'burger','french fries','pasta','cereal','biscuit'}

result = data1 - data2 # items in data1 but no in data2

print(result)

Output

{'pizza', 'kebab', 'noodle'}

The symmetric difference operation returns all items that exist in either of the sets, but not in the intersection.

data1 = {'burger','kebab','noodle','pasta','pizza'}
data2 = {'burger','french fries','pasta','cereal','biscuit'}

result = data1 ^ data2 # items in data1 or data2 but not both

print(result)

Output

{'biscuit', 'kebab', 'cereal', 'pizza', 'noodle', 'french fries'}

Introduction to Function

This is the basic structure of function in Python.

def function_name(args):
    function body

This is the example of void function (no return value) in Python.

# create a function
def hello():
    print("hello!")

# call the function
hello()

Output

hello!

Based on the code above, the function called hello() is created. The function is called by specifying the function name followed with parentheses ().

This is the example of function with return value.

# create a function with return value
def add(a,b):
    return a + b

result = add(2,4)

print(result)

Output

Based on the code above, the function called add() is created to sum two numbers. The return value of add() function is stored inside result variable.

When working with the return value function, ensure the returned value is being used.

The topic of functions in Python will be explained in detail in a separate chapter.

Example - Simple Todo List Application

Let's create a simple todo list application. This application uses list as a storage for todos and utilizes function for a cleaner code.

The first step is to import uuid package and create a list called todos for storing todo records. The uuid package is used as an identifier (ID) for todo record.

import uuid

# create a local storage for storing todos
todos = []

After that, create a view_todos() function to retrieve all todo records. All todo records are retrieved using for loop.

def view_todos():
    """
    view all todos
    """
    print("all todos")
    for todo in todos:
        print("====")
        print(f"id: {todo["id"]}")
        print(f"title: {todo["title"]}")
        print("====")

Create a view_todo() function to retrieve todo record by specified ID. Each todo record is checked inside the for loop to check if the current todo ID is equal to the specified ID. If matches, then the todo record is displayed.

def view_todo(todo_id):
    """
    view todo by ID
    """
    for todo in todos:
        if todo["id"] == todo_id:
            print("====")
            print(f"id: {todo["id"]}")
            print(f"title: {todo["title"]}")
            print("====")

Create a create_todo() function to create a new todo. The todo record is represented as a dictionary with id and title field.

def create_todo(todo_input):
    """
    create a new todo
    """
    new_todo = {
        "id":uuid.uuid4().hex,
        "title":todo_input
    }

    todos.append(new_todo)

    print("todo added!")

Create a update_todo() function to update a todo. In this function, the todo record is updated by specified ID.

def update_todo(todo_id,todo_input):
    """
    update existing todo
    """
    for todo in todos:
        if todo["id"] == todo_id:
            todo["title"] = todo_input

    print("todo updated!")

Create a delete_todo() function to delete a todo. In this function, the todo record is deleted by specified ID.

def delete_todo(todo_id):
    """
    delete todo
    """
    for todo in todos:
        if todo["id"] == todo_id:
            todos.remove(todo)

    print("todo deleted!")

Finally, create a function called display_menu() to display the main menu of the application.

def display_menu():
    """
    displays the main menu of the application
    """
    # create a variable for storing user's choice
    choice = 0

    while choice != 6:
        print("Simple Todo App")
        print("1. view all todos")
        print("2. view todo by ID")
        print("3. create a new todo")
        print("4. update todo")
        print("5. delete todo")
        print("6. exit")
        print("---------------")
        choice = int(input("insert choice: "))

        match choice:
            case 1:
               view_todos()
            case 2:
                todo_id = input("insert todo ID: ")
                view_todo(todo_id)
            case 3:
                todo_input = input("insert new todo: ")
                create_todo(todo_input)
            case 4:
                todo_id = input("insert todo ID: ")
                todo_input = input("insert updated todo: ")
                update_todo(todo_id,todo_input)
            case 5:
                todo_id = input("insert todo ID: ")
                delete_todo(todo_id)
            case 6:
                print("good bye")
            case _:
                print("invalid choice, please input 1-6")

# call the function
display_menu()

This is the complete code.

import uuid

# create a local storage for storing todos
todos = []

def view_todos():
    """
    view all todos
    """
    print("all todos")
    for todo in todos:
        print("====")
        print(f"id: {todo["id"]}")
        print(f"title: {todo["title"]}")
        print("====")

def view_todo(todo_id):
    """
    view todo by ID
    """
    for todo in todos:
        if todo["id"] == todo_id:
            print("====")
            print(f"id: {todo["id"]}")
            print(f"title: {todo["title"]}")
            print("====")

def create_todo(todo_input):
    """
    create a new todo
    """
    new_todo = {
        "id":uuid.uuid4().hex,
        "title":todo_input
    }

    todos.append(new_todo)

    print("todo added!")

def update_todo(todo_id,todo_input):
    """
    update existing todo
    """
    for todo in todos:
        if todo["id"] == todo_id:
            todo["title"] = todo_input

    print("todo updated!")

def delete_todo(todo_id):
    """
    delete todo
    """
    for todo in todos:
        if todo["id"] == todo_id:
            todos.remove(todo)

    print("todo deleted!")


def display_menu():
    """
    displays the main menu of the application
    """
    # create a variable for storing user's choice
    choice = 0

    while choice != 6:
        print("Simple Todo App")
        print("1. view all todos")
        print("2. view todo by ID")
        print("3. create a new todo")
        print("4. update todo")
        print("5. delete todo")
        print("6. exit")
        print("---------------")
        choice = int(input("insert choice: "))

        match choice:
            case 1:
               view_todos()
            case 2:
                todo_id = input("insert todo ID: ")
                view_todo(todo_id)
            case 3:
                todo_input = input("insert new todo: ")
                create_todo(todo_input)
            case 4:
                todo_id = input("insert todo ID: ")
                todo_input = input("insert updated todo: ")
                update_todo(todo_id,todo_input)
            case 5:
                todo_id = input("insert todo ID: ")
                delete_todo(todo_id)
            case 6:
                print("good bye")
            case _:
                print("invalid choice, please input 1-6")

# call the function
display_menu()

This is the output of the application.

Sources

Data Structure in Python.

I hope this article helps you learn Python. If you have any feedback, please let me know in the comment section.

Python Tutorial - 2 Control Flow

nadirbasalamah — Thu, 19 Sep 2024 03:18:48 +0000

Control flow is an essential part of programming. There are two types of control flow including branching and looping.

Comparison and Logical Operator

Comparation and logical operators are commonly used in the control flow mechanism. This is the list of comparison operators that can be used in Python. The comparison operator returns a boolean value.

Operator	Description
`==`	Equals to
`!=`	Not equals to
`>`	Greater than
`>=`	Greater than or equals
`<`	Less than
`<=`	Less than or equals

This is an example of comparison operator usage in Python.

first = 5
second = 6

print(first > second)
print(first < second)
print(first != second)

Output

False
True
True

The and operator is an operator that returns true if the two conditions return true.

Condition	Condition	Result
False	False	False
False	True	False
True	False	False
True	True	True

The or operator is an operator that returns true if one or two conditions return true.

Condition	Condition	Result
False	False	False
False	True	True
True	False	True
True	True	True

This is an example of logical operator usage.

first = 6
second = 7

result_1 = first != 0 and first > second
result_2 = second > 5 or second == first

print(result_1)
print(result_2)

Output

False
True

Based on the code above, the and operator returns False because there is a condition that returns False which is first > second.
The or operator returns True because there is a condition that returns True which is second > 5.

and returns true if all conditions are true.

or returns true if one of the other conditions is true.

Branching in Python

Branching is a mechanism to execute a code based on a specific condition. There are many approaches to performing branching in Python.

Branching with `if`

This is the basic structure of branching with if.

if condition:
    code

The code inside the if block is executed if the condition inside the if block is true.

This is an example of branching using if.

num = 24

if num % 2 == 0:
    print('even number')

Output

even number

Based on the code above, the code inside the if block is executed because the condition inside the if block is true.

Branching with `if-else`

This is the basic structure of branching with if-else.

if condition:
    code
else:
    other code

The code inside the if block is executed if the condition inside the if block is true. Otherwise, the other code is executed inside the else block.

This is the example of branching with if-else.

num = 35

if num % 2 == 0:
    print('even number')
else:
    print('odd number')

Output

odd number

Based on the code above, the condition inside the if block is false then the code inside the else block is executed.

Branching with `if-elif-else`

This is the basic structure of branching with if-elif-else.

if condition:
    code
elif condition:
    code
else:
    code

The if-elif-else is useful to perform branching with many conditions. This is an example of if-elif-else usage.

role = "Back-end"

if role == "Front-end":
    print("learn HTML, CSS and JS")
elif role == "Back-end":
    print("learn Java, Go and PHP")
else:
    print("learn any related topics")

Output

learn Java, Go and PHP

Based on the code above, the code is executed based on the role value.

Branching with `match-case`

The match-case branching works like the switch-case in other programming languages. This is the basic structure.

match value:
    case condition:
        code
    case condition:
        code
    case condition:
        code
    case _:
        default code

This is the example of branching with match-case.

role = "Back-end"

match role:
    case "Front-end":
        print("learn HTML, CSS and JS")
    case "Back-end":
        print("learn Java, Go and PHP")
    case _: # default condition
        print("learn any related topics")

Output

learn Java, Go and PHP

Looping in Python

Looping is a mechanism to execute a code repeatedly. Looping is an essential tool for completing repetitive tasks like reading a record in a file, basic calculations, and so on. There are many approaches to performing looping in Python.

Looping with `for`

The for loop is suitable for executing repetitive tasks within an exact amount of time. For example, a certain task has to be completed 10 times. This is the basic structure of the for loop.

for value in iterables:
    code

This is the sample code without using the for loop.

print(1)
print(2)
print(3)
print(4)
print(5)

This is the modified code using the for loop.

for i in range(1,6):
    print(i)

Output

Based on the code above, the for loop code is executed with the range() function. The range() function returns a sequence of numbers based on the given start and end of the range. This is the basic structure of the range() function.

range(start,end,step)

start defines the start of the sequence.
end defines the end of the sequence. The end value is not included in the sequence.
step defines the step value for generating the next sequences. By default, the step value is 1 which means each sequence value is incremented by 1.

The range(1,6) means generating a sequence of numbers from 1 up to but not including 6.

This is another example of a for loop with a custom range (range(2,11,2)) to display even numbers.

for i in range(2,11,2):
    print(i)

Output

Based on the code above, the even numbers from 2 up to but not including 11 are displayed. The range(2,11,2) generates sequence from 2 up to but not including 11 with the step value equals 2 which means each sequence value is incremented by 2.

`break` and `continue` keyword

The break keyword stops the code execution. This keyword is usually used inside the loop. This is an example of break usage.

num = 10

while num != 0:
    if num % 4 == 0:
        print("done!")
        break # stops the execution
    print("stil running...")
    num -= 1 # decrement the value by 1

Output

stil running...
stil running...
done!

Based on the code above, the break keyword stops the execution if the condition is met.

The continue keyword continues the code execution into the next phase or skips to the next iteration. This is an example of continue keyword usage.

for i in range (1,7):
    if i == 5:
        print("skipped!")
        continue
    print(f"value: {i}")

Output

value: 1
value: 2
value: 3
value: 4
skipped!
value: 6

Based on the code above, the continue keyword skips to the next iteration if the condition is met.

Looping with `while`

The while loop is suitable for executing repetitive tasks within an uncertain amount of time. For example, a certain task has to be completed until a specific condition is met. This is the basic structure of the while loop.

while expression:
    code

This is an example of while loop usage.

num = 1

while num <= 5:
    print(num)
    num += 1

Output

Based on the code above, the code inside the while loop is executed while the condition (in this case num <= 5) is true. If the condition is not met, then the loop is stopped. The += operator increments the num value by 1.

The num += 1 is equals to num = num + 1. The ++ and -- operator is not supported in Python.

When working with a loop, ensure the implementation and applied condition are correct to avoid an infinite loop.

Example 1 - Grade Checking

Let's create a Python program to check the grade based on the given score. For example, this table is used to check the grade based on the given score.

Score	Grade
81-100	A
65-80	B
50-64	C
30-49	D
0-29	E

The solution is using branching. This is the complete example:

score = int(input("enter a score: "))

if score >= 81 and score <= 100:
    print("A")
elif score >= 65 and score <= 80:
    print("B")
elif score >= 50 and score <= 64:
    print("C")
elif score >= 30 and score <= 49:
    print("D")
elif score >= 0 and score <= 29:
    print("E")
else:
    print("invalid score")

Output

Example 2 - Palindrome Checking

Let's create a program to check if the given word is a palindrome. Palindrome is a word that can be read equally forward and backward.

The naive solution is to compare the original word and the reversed word. If both of them are equal, then the given word is a palindrome. The naive solution walkthrough is illustrated in the picture below.

This is the naive solution implementation using a while loop.

# get the word input from the user
word = input("insert a word: ")

# sanitize the input
word = word.lower()

# create a variable to store reversed word
reversed = ""
# create a variable to store the index
idx = len(word) - 1

# generate reversed word
while idx >= 0:
    reversed += word[idx]
    idx = idx - 1

# compare the original and reversed word
if word == reversed:
    print("palindrome")
else:
    print("not palindrome")

Output

Another approach is to create two indices for iterating through each character from forward and backward. If two characters from forward and backward are not equal, then the given word is not palindrome. The walkthrough of this approach is illustrated in the picture below.

This is the implementation of using two indices.

# get the word input from the user
word = input("insert a word: ")

# sanitize the input
word = word.lower()

# create two indices
front = 0 # forward tracking
back = len(word) - 1 # backward tracking

# store result
result = "palindrome"

# track each characters forward and backward
while front < len(word):
    if word[front] != word[back]:
        result = "not palindrome"
        break
    front += 1
    back -= 1

# display the check result
print(result)

Output

Sources

I hope this article helps you learn Python. If you have any feedback, please let me know in the comment section.

Python Tutorial - 1 Introduction

nadirbasalamah — Sat, 24 Aug 2024 02:20:49 +0000

Python is one of the most popular programming languages right now, especially with the rise of AI technology. Python is a multi-purpose programming language for developing many things like web applications, back-end services, and data science and machine learning.

Setup

These are the preparations for coding with Python:

Download the Python then install it.
You can use any text editor for writing Python code like Visual Studio Code or a dedicated IDE like PyCharm.

Writing the First Code

Create a new file with a .py extension called main.py. Then write this code.

print("Hello World!")

Run this command to execute Python code.

python main.py

This is the output.

Hello World!

Based on the code above, the print() function displays the Hello World! text.

Variable and Data Types

A variable is a place for storing values like integers, floating numbers, and strings (a bunch of alphanumeric characters). This is an example of variable usage in Python.

number = 42
username = "John Doe"
price = 2.95

To display the value from a variable, use print() function.

number = 42
username = "John Doe"
price = 2.95

# display a value from variable
print("this is a number", number)
print("price: ", price)
# using formatting
print(f"hello, my username is {username}")

This is the output.

this is a number 42
price:  2.95
hello, my username is John Doe

This is the list of commonly used data types in Python.

Data Type	Value
Integer	non-decimal number
Float	decimal number
String	Alphanumeric characters
Boolean	`True` or `False`

Operator

There are many basic arithmetic operators in Python. These operators can be used to perform calculations for number data types like integer and float.

Operator	Description
`+`	add operation
`-`	substract operation
`*`	multiply operation
`/`	division operation
`//`	floor division operation
`%`	modulo operation (get the remainder from division operation)
`**`	Perform the operation of raising a number to the power of a number

This is an example of operator usage in Python.

first = 4
second = 2

addition = first + second
subtraction = first - second
multiplication = first * second
division = first / second
mod = first % second
square_of_first = first ** 2

print(f'{first} + {second} = {addition}')
print(f'{first} - {second} = {subtraction}')
print(f'{first} * {second} = {multiplication}')
print(f'{first} / {second} = {division}')
print(f'{first} % {second} = {mod}')
print(f'{first} ** {2} = {square_of_first}')

Output

4 + 2 = 6
4 - 2 = 2
4 * 2 = 8
4 / 2 = 2.0
4 % 2 = 0
4 ** 2 = 16

The // operator performs division and then returns the floor of a division result.

result = 29 // 5 # returns 5 (actual value before floor operation: 5.8)

Adding User Input

The input() function reads the input from the user. This function is useful for creating interactive programs in Python. By default, the input() returns String data type.

This is the basic example of using the input() function.

# get username from input
username = input("enter username: ")
# get age from input
# the int() function converts string into integer data type
age = int(input("enter age: "))

print(f"username: {username}")
print(f"age: {age}")

Output

Example 1 - Rectangle Area Calculation

Let's create a rectangle area calculation program in Python. The program allows the user to enter the length and width of the rectangle. Then, the program calculates the area of the rectangle and then displays it to the user.

# get length from user input
length = int(input("enter length: "))

# get width from user input
width = int(input("enter width: "))

# calculate the area of rectangle
area = length * width

# display the result
print(f"area of rectangle: {area}")

Output

Example 2 - Get Discounted Price

Let's create a program to calculate the price of an item after the discount is applied. The program allows the user to enter the actual price and discount. Then, the program returns the discounted price.

# get price from user input
price = int(input("enter price: "))

# get discount from user input
discount = int(input("enter discount: "))

# calculate the discounted price
discounted_price = price - (price * (discount / 100))

# display the result
print(f"original price: {price}")
print(f"discounted price: {discounted_price}")

Output

Sources

I hope this article helps you learn Python. If you have any feedback, please let me know in the comment section.

Generics in Go Tutorial

nadirbasalamah — Mon, 01 Aug 2022 09:07:19 +0000

Introduction

In the Go programming language with the version of 1.18 or later there is a new feature called Generics. Generics are a feature that has been featured in many programming languages like Java. Generics are a feature to define a type or data type as a parameter in a function or a struct.

Using Generics in Function

The generics mechanism can be applied in a function. To use a generics feature, the any keyword can be used to define all data types that can be used as a parameter in a function or a struct. The other keyword that can be used is comparable which means the data type that implements comparable like int and float64.

This is an example of generics usage in a function. Before the generics are used, two functions are created called compareInt and compareFloat to compare two numbers for different data types including int and float64.

// compare two numbers for int data type
func compareInt(x, y int) bool {
    return x == y
}

// compare two numbers for float64 data type
func compareFloat(x, y float64) bool {
    return x == y
}

This is the example of generics usage in function to compare two numbers.

func compare[T comparable](x, y T) bool {
    return x == y
}

Based on the code above, the generics are implemented in [T comparable] syntax. The T is a variable name for the generic parameter. The variable name for the generic parameter can contain many characters like numType but the parameter name in general only contains a single character. The comparable syntax means a function can be used by a data type that implements comparable like int and float64.

This is an example of a function call that implements the generics.

package main

import "fmt"

func main() {
    fmt.Println("compare result for int: ", compare(2, 3))
    fmt.Println("compare result for float64: ", compare(2.9, 2.9))
}

Output.

compare result for int:  false
compare result for float64:  true

The generics can be used to define the required data types for the function with the | operator. This is the example of generics usage in the average() function.

// calculate the average
// T is an int or float64 data type
func average[T int | float64](nums []T) T {
    var sum T = 0

    for _, num := range nums {
        sum += num
    }

    var result T = sum / T(len(nums))

    return result
}

Based on the code above, the usage of the generic can be seen in [T int | float64] syntax which means the function only can be used by the int or float64 data type.

This is the example of the average() function call.

package main

import "fmt"

func main() {
    var intData []int = []int{1, 2, 3, 4}
    var floatData []float64 = []float64{2.5, 3.4, 6.7, 2.9}

    fmt.Println("average result for int data type: ", average(intData))
    fmt.Println("average result for float64 data type:", average(floatData))
}

Output.

average result for int data type:  2
average result for float64 data type: 3.8750000000000004

Using Generics in Struct

The generics can be applied in a struct. The generics usage is similar in a function by using certain keywords like any, and comparable and defining the required data types with the | operator.

This is the example of a struct without generics implementation.

type IntBox struct {
    Content int
}

type StringBox struct {
    Content string
}

This is the example of generics usage in a struct called Box.

type Box[T any] struct {
    Content T
}

Based on the code above, the usage of the generic can be seen in [T any] syntax which means the struct can be used with any data type.

This is an example of struct usage that implements generics.

package main

import "fmt"

type Box[T any] struct {
    Content T
}

func main() {
    var numberBox Box[int] = Box[int]{
        Content: 200,
    }

    var stringBox Box[string] = Box[string]{
        Content: "my content",
    }

    fmt.Println(numberBox.Content)
    fmt.Println(stringBox.Content)
}

Output.

200
my content

This is another example of generics usage in a struct with two generic parameters.

type Pair[K, V any] struct {
    Key   K
    Value V
}

The number of the generic parameter is not restricted. In general, the number of the generic parameter is one or two parameters.

This is an example of struct usage that used two generic parameters.

package main

import "fmt"

type Pair[K, V any] struct {
    Key   K
    Value V
}

func main() {
    var pairOne Pair[string, int] = Pair[string, int]{
        Key:   "score",
        Value: 2000,
    }

    var pairTwo Pair[int, string] = Pair[int, string]{
        Key:   10,
        Value: "a value",
    }

    fmt.Println(pairOne.Key, pairOne.Value)
    fmt.Println(pairTwo.Key, pairTwo.Value)
}

Output

score 2000
10 a value

Using Generics in Interface

The generics can be used with the interface. This is an example of generics usage in an interface.

// Number is an int or float64 data type
type Number interface {
    int | float64
}

Based on the code above, the interface called Number indicates a certain data type that has an int or float64 data type.

The interface that uses the generics can be applied in a function or a struct. This is an example of generic interface usage in a function.

// calculate average
// using Number interface as a type
func average[T Number](nums []T) T {
    var sum T = 0

    for _, num := range nums {
        sum += num
    }

    var result T = sum / T(len(nums))

    return result
}

Based on the code above, the Number interface is used inside the average() function which means the average function can be called or used by a data type that implements the Number interface including int or float64 data type. With the interface, the code is more readable and well structured.

Notes

The generics can be used to reduce code duplication if the code has a similar logic structure. For example, a single generic function to calculate an average can be created instead of creating many average functions for many data types.

// without generics, each average function is created for each data type
func averageInt(nums []int) int {
    var sum int = 0

    for _, num := range nums {
        sum += num
    }

    var result int = sum / len(nums)

    return result
}

func averageFloat(nums []float64) float64 {
    var sum float64 = 0

    for _, num := range nums {
        sum += num
    }

    var result float64 = sum / float64(len(nums))

    return result
}

// with generics, the average function can be used for int and float64 data type
func average[T int | float64](nums []T) T {
    var sum T = 0

    for _, num := range nums {
        sum += num
    }

    var result T = sum / T(len(nums))

    return result
}

Sources

Generics usage in Go programming language.

I hope this article is helpful to learn generics in Go. If you have any thoughts, you can write it in the discussion section below.

Introduction to Protocol Buffers

nadirbasalamah — Tue, 26 Oct 2021 05:56:02 +0000

There are many data structures that can be used to perform communication between applications like XML and JSON. These two data structures are commonly used in application development but there are many disadvantages in performance and data size. To solve this disadvantages can be done by using another alternative called protocol buffers.

Protocol Buffers

Protocol Buffers is a mechanism that developed by Google to perform data serialization. There are many advantages when using Protocol Buffers:

The data structure is tidy and more manageable.
Can be used for RPC communication.
Validation feature in data structure.
Better performance compared to XML and JSON.

There are many disadvantages of Protocol Buffers:

Only support some programming languages like Java, JavaScript, Go, C++. Probably in future, other programming languages support for protocol buffers will be added.

Setup

In order to use protocol buffers in programming language, the protocol buffers compiler is needed. The compiler can be downloaded here then choose the compiler based on the operating system that is used. For example, for windows operating system the compiler that is needed is protoc-3.17.3-win64.zip file.

For windows user, follow these steps.

Download the protocol buffers compiler in this link. Then choose for windows operating system (example: protoc-3.17.3-win64.zip).

Extract that file in a folder called proto3, this folder can be put in any location.

Open start then search for "environment variables" and then choose Edit the system environment variables.

Choose Environment Variables..

Choose Path in system variables.

Click new then add the folder location for proto3 folder for bin folder (example: D:\proto3\bin).

Click OK. After the path variable is added. Check the compiler installation with protoc --version command. If the version is visible then the compiler is installed correctly.

Create a Protocol Buffers

In this tutorial, the protocol buffers version that is used is Protocol Buffers version 3 (proto3)

The data structure of protocol buffers looks like this:

message message_name {
    data_type field_name = tag;
    ..
}

In this example, the protocol buffers is used to define a data structure for car entity.

// define the syntax type of protocol buffers
// the syntax type is proto3
syntax = "proto3";

// create a message
message Car {
  int32 id = 1;
  string manufacturer = 2;
  string name = 3;
  float mileage = 4;
  bool is_new = 5;
}

Then naming convention for message name, enum and service is using capital letter for each first sentence like SearchRequest then for field name is using underscore _ like zip_code.

These are the basic data types that can be used in protocol buffers.

Data Type	Description
int32	32 non decimal integer
string	A group of alphanumeric characters
bool	Contains true and false
float	decimal integer
uint32	32 non decimal integer and must be positive integer

All supported data types in protocol buffers can be checked here.

In protocol buffers, the enum can be created if needed. This is the basic syntax to create an enum.

enum enum_name {
  enum_value = tag;
}

In this protocol buffers, the enum called CarType is created.

// define the syntax type of protocol buffers
// the syntax type is proto3
syntax = "proto3";

// create a message
message Car {
  int32 id = 1;
  string manufacturer = 2;
  string name = 3;
  float mileage = 4;
  bool is_new = 5;
  uint32 vin = 6;

  // create an enum
  enum CarType {
    UNKNOWN = 0;
    RACE_CAR = 1;
    ROAD_CAR = 2;
  }
  // using enum
  CarType car_type = 7;
}

Another data type that is supported is map. Map is a data type that can store many key value pairs. This is the example of map usage.

syntax = "proto3";

message Student {
  string name = 1;
  uint32 student_id = 2;
  // using map
  // key: string
  // value: string
  map<string, string> courses = 3;
}

The message that already created is also a data type that can be used. This is the example of using another message as a data type.

syntax = "proto3";

message Student {
  string name = 1;
  uint32 student_id = 2;

  // using Course message as a data type
  repeated Course courses = 3;
}

message Course {
  string code = 1;
  string name = 2;
}

To import another protocol buffers file, use the full path from the root folder that is used to store protocol bufers files. This is the example of import mechanism in protocol buffers. The protocol buffers file that is imported is person.proto.

person.proto file in models folder.

syntax = "proto3";

message Person {
  string name = 1;
  string address = 2;
  int32 age = 3;
}

The car.proto file is using person that is imported.

// using proto3 syntax
syntax = "proto3";

// import person.proto
import "models/person.proto";

// create a message
message Car {
  int32 id = 1;
  string manufacturer = 2;
  string name = 3;
  float mileage = 4;
  bool is_new = 5;
  uint32 vin = 6;

  // create an enum
  enum CarType {
    UNKNOWN = 0;
    RACE_CAR = 1;
    ROAD_CAR = 2;
  }
  CarType car_type = 7;

  // using person that is imported
  Person owner = 8;
}

Rules in Protocol Buffers

There are many rules that can be used in protocol buffers.

Rule	Description
`repeated`	A field could contains many values
`oneof`	A field's value must be chosen from the specified value choices

By default in proto3, the field without specified rule could contain empty value.

The repeated rule is used to create a field that can store many values like list or array. For example, if there is a field repeated int32 numbers = 1;. This field means that a numbers can store many values that has a int32 data type.

This is the example of rule usage in protocol buffers.

syntax = "proto3";

message Student {
  string name = 1;
  string student_id = 2;
  repeated Course courses = 3;
  uint32 member_id = 4;
  oneof card_number {
    string student_card_number = 5;
    string id_card_number = 6;
  }
}

message Course {
  string code = 1;
  string name = 2;
}

Based on the code above, the courses field could contains many values that has a Course data type. The oneof rule is applied into card_number field which means one of the card_number value must be chosen from student_card_number or id_card_number.

Changes in Protocol Buffers

If the changes is occurred in protocol buffers that is used in application. There are many rules when the change is occurred in protocol buffers.

Tag number change is not allowed.
The field name can be changed
If there is a new field addition, the new field is filled automatically with the default value based on the specified data type. The default values for each data type can be checked here.

In this example, the new field is added in protocol buffers file called Blog.

Before new field addition.

syntax = "proto3";

message Blog {
  string title = 1;
  string author = 2;
  string content = 3;
}

After new field is added.

syntax = "proto3";

message Blog {
  string title = 1;
  string author = 2;
  string content = 3;
  // add new field
  string category = 4;
}

If the field is unused. The unused field must be specified with OBSOLETE_ keyword or using reserve keyword for the unused field's tag number. Using reserve keyword is recommended to avoid bug.

This is the example of reserved keyword usage in student_id field.

syntax = "proto3";

message Course {
  string code = 1;
  string name = 2;
  //   string student_id = 3;
  //   string lecturer_name = 4;

  // student_id field with tag number 3 is not used
  reserved 3;
  // field called lecturer_name is not used
  reserved "lecturer_name";
}

In enum, the addition, changes and removal can be performed.

In this example, the enum is changed.

Before changed.

syntax = "proto3";

message User {
  string name = 1;

  // using enum
  enum Role {
    UNKNOWN = 0;
    USER = 1;
  }
}

After changed.

syntax = "proto3";

message User {
  string name = 1;

  // using enum
  enum Role {
    // default value for enum
    UNKNOWN = 0;
    // USER = 1;
    STAFF = 2;
    // add new value inside enum
    ADMIN = 3;

    // remove "USER" value from enum
    reserved "USER";
    reserved 1;
  }
  Role role = 2;
}

Using Protocol Buffers

Protocol buffers can be used together with programming languages such as Java, JavaScript, Go, C++ and Dart. In this example, the protocol buffers is used with Go programming language.

The Go application project is created with this command. Make sure the domain name is specified based on your repository.

go mod init github.com/nadirbasalamah/protodemo

Add some dependencies to use protocol buffers.

go get github.com/golang/protobuf
go get google.golang.org/protobuf

Create a new protocol buffers file in src/model directory called student.proto. The option inside protocol buffers file is added so the generated code can be used from student package.

syntax = "proto3";
package tutorial;

// only for Golang
option go_package = "model;student";

message Student {
  string name = 1;
  string student_id = 2;
  repeated Course courses = 3;
  uint32 member_id = 4;
  oneof card_number {
    string student_card_number = 5;
    string id_card_number = 6;
  }
}

message Course {
  string code = 1;
  string name = 2;
}

Generate code from protocol buffers so the code can be used together with Go. In this command, the file is generated from root directory src/ then the generated code is stored in src/. The protocol buffers file that will be generated is src/model/student.proto.

protoc -I=src/ --go_out=src/ src/model/student.proto

If the file called student.pb.go is exists, then the generate operation is success.

The generated code is used in main.go file.

package main

import (
    "fmt"

    student "github.com/nadirbasalamah/protodemo/src/model"
)

func main() {
    // create a student entity
    var newStudent student.Student = student.Student{
        Name:      "Nathan Mckane",
        StudentId: "RVN2021",
        CardNumber: &student.Student_IdCardNumber{
            IdCardNumber: "12345321",
        },
    }

    // print some value from fields
    fmt.Println("Student Data")
    fmt.Println("Name: ", newStudent.GetName())
    fmt.Println("Student ID: ", newStudent.GetStudentId())
    fmt.Println("Card Number: ", newStudent.GetCardNumber())
}

Output

Student Data
Name:  Nathan Mckane
Student ID:  RVN2021
Card Number:  &{12345321}

Based on the code above, the generate result from protocol buffers is used in student package. The object from Student struct is created then the values from newStudent object is retrieved from provided getter methods.

Another example of protocol buffers usage is to convert protocol buffers into another data structure like JSON or vice versa.

package main

import (
    "fmt"
    "log"

    "github.com/golang/protobuf/jsonpb"
    "github.com/golang/protobuf/proto"
    student "github.com/nadirbasalamah/protodemo/src/model"
)

func main() {
    // create a student entity
    var newStudent student.Student = student.Student{
        Name:      "Nathan Mckane",
        StudentId: "RVN2021",
        CardNumber: &student.Student_IdCardNumber{
            IdCardNumber: "12345321",
        },
    }

    // add some courses
    newStudent.Courses = []*student.Course{
        {
            Code: "C001",
            Name: "Algorithm",
        },
        {
            Code: "C002",
            Name: "Data Structure",
        },
    }

    // print courses
    fmt.Println("Courses")
    for _, v := range newStudent.Courses {
        fmt.Println(v)
    }

    // convert to JSON
    var result string = convertToJSON(&newStudent)
    fmt.Println("to JSON: ", result)

    // convert to protocol buffers from JSON data
    var jsonData string = `{"name":"Ryan Cooper","studentId":"RPC2007","idCardNumber":"98753443"}`
    var protoResult student.Student = student.Student{}

    // call the function
    convertToProto(jsonData, &protoResult)
    fmt.Println("to proto: ", &protoResult)

}

func convertToJSON(pb proto.Message) string {
    var marshaler jsonpb.Marshaler = jsonpb.Marshaler{}
    result, err := marshaler.MarshalToString(pb)

    if err != nil {
        log.Fatalln("Cant convert to JSON", err)
        return ""
    }
    return result
}

func convertToProto(data string, pb proto.Message) {
    err := jsonpb.UnmarshalString(data, pb)
    if err != nil {
        log.Fatalln("Cant convert to proto, ", err)
    }
}

Output

Courses
code:"C001"  name:"Algorithm"
code:"C002"  name:"Data Structure"
to JSON:  {"name":"Nathan Mckane","studentId":"RVN2021","courses":[{"code":"C001","name":"Algorithm"},{"code":"C002","name":"Data Structure"}],"idCardNumber":"12345321"}
to proto:  name:"Ryan Cooper"  student_id:"RPC2007"  id_card_number:"98753443"

Notes

The protocol buffers can be used by these steps:

Create a protocol buffers file.
Generate a code from protocol buffers file based on the programming language that is used.
Use the code from generated code.

The code example of using protocol buffers in Go can be checked here.

Sources

I hope this article is helpful to learn protocol buffers. If you have any thoughts, you can write it in the discussion section below.

Introduction to Class Diagram

nadirbasalamah — Tue, 19 Oct 2021 09:19:52 +0000

There are many steps when developing a software. One of those steps is software design. In software design step, there are many diagrams that used and one of those is class diagram.

Class Diagram

Class diagram is a diagram that represents relation between many entities that involved in a software. The class diagram consist of attribute and behavior. The attribute represented as a field and behavior represented as a method. This is the structure of class diagram.

This is the scope notations that can be used in fields or methods inside class diagram.

Symbol	Scope	Description	Example
`+`	public	Field or method is available publicly	`+setName()`
`-`	private	Field or method only available for its own class	`-id: String`
`#`	protected	Field or method is available for its own class and its sub classes	`#walk()`
`~`	package	Field or method is available in a same package	`~getData(): Data`

This is the example of class diagram that represents book entity.

Based on the class diagram above, there are three attributes or fields in a book including id, title and author. These three fields has a private scope. In Book class there is a one method called getData() that has a return type is a book data (Book).

Relation in Class Diagram

There are many relationship types in class diagram including generalization, association, aggregation and composition.

Generalization

This relationship is used to define an inheritance mechanism in class diagram. In this example, the generalization relationship is defined between Vehicle class and Car class.

Association

This relationship is used to define a single relationship between classes that involved each other. In this example, the association relationship is used by User class and Blog class.

Aggregation

This relationship is used to define a relationship for a class that is a part of the another class. In this example, the aggregation relationship is used by Car class and Machine class.

Composition

This relationship is used to define a relationship between classes that involved each other and cannot be separated. In this example, the composition relationship is used by Course class and Teacher class.

Create a Class Diagram

There are many tools that can be used to create a class diagram like StarUML, Draw.io and other software tools.

These are the steps to create a class diagram:

Define some entities that involved in a software or application. The entity could become concrete entitiy like book, user or abstract entity like course that taken by student.
Define the attributes and behaviors of an entity. Attributes described as a fields in class whilst behaviors described as a methods in class.
Define the scope for the fields and methods. In general, the scope for the fields is private and scoe for the methods is public or protected.
Define the relationships between classes.
Review the class diagram that already created to make sure the diagram is created correctly. The diagram must be correct in terms of syntax and semantics.

Correct in terms of syntax means that a diagram is defined with the correct notation or symbol.

Correct in terms of semantic means that a diagram is understandable.

Notes

Class diagram can be used to define the relationship between entities that involved in a software.
There are many relationships that can be used in class diagram.
Generalization can be used to define inheritance relationship between classes.
Association can be used to define single relationship between classes.
Aggregation can be used to define relationship for a class that is a part of the another class.
Composition can be used to define relationship between classes that involved each other and cannot be separated.

Sources

Check out this blog post about relationships in class diagram.

I hope this article is helpful to understand the concept of class diagram. If you have any thoughts or comments you can write in the discussion section below.

Kotlin Tutorial - 9 Polymorphism

nadirbasalamah — Thu, 14 Oct 2021 06:14:23 +0000

In object oriented programming, there is a principle called polymorphism. Polymorphism is a mechanism when a behavior can be implemented differently by many classes. For example, the human and cat entity has a walk behavior but implemented differently. The human walks with two legs whether the cat walks with four legs.

Create a Sealed Class

Sealed class is a class that contains many sub classes that inherit sealed class. Basically, sealed class is identical with enum but sealed class could contains many classes. Sealed class is an abstract class so the object cannot be created or instantiated from sealed class.

This is the basic syntax to create sealed class.

sealed class class_name(attributes,...) {
    // create many sub classes..
}

The sealed class can be created with this other syntax.

sealed class class_name
// create many sub classes..

In this example, the sealed class is created inside Vehicle.kt file.

// create a sealed class called Vehicle
sealed class Vehicle
// create two data classes that inherit Vehicle class
data class Motorcycle(val manufacturer: String, val type: String): Vehicle()
data class Car(val manufacturer: String, val type: String): Vehicle()

// create a run()  method that can be called
// from a class that inherits Vehicle class
fun Vehicle.run() {
    // define the run() implementation
    // based on specific class
    when(this) {
        is Motorcycle -> println("Running with two wheels")
        is Car -> println("Running with four wheels")
    }
}

Create an object from Motorcycle class that inherits sealed class called Vehicle.

fun main() {
    // create an object from Motorcycle class
    val motorcycle = Motorcycle("Honda","CBR")
    // call run() method
    motorcycle.run()
}

Output

Running with two wheels

Based on the code above, the sealed class is created called Vehicle that contains many sub classes including Motorcycle and Car.

The implementation from run() method inside Vehicle class is defined based on specific class with when condition selection.

// create a run()  method that can be called
// from a class that inherits Vehicle class
fun Vehicle.run() {
    // define the run() implementation
    // based on specific class
    when(this) {
        is Motorcycle -> println("Running with two wheels")
        is Car -> println("Running with four wheels")
    }
}

Create an Interface

Interface is a class that only contains many abstract methods. Interface can be used to define contract that has to be fulfilled for a class. This is the basic syntax to create an interface.

interface interface_name {
    // create many abstract methods...
}

In this example, the interface called ShapeInterface is created in ShapeInterface.kt file.

interface ShapeInterface {
    fun getArea(): Double
}

The interface that already created is implemented by Circle class.

// create a Circle class that implements ShapeInterface
class Circle(val radius: Double): ShapeInterface {

    // the getArea() method is implemented
    override fun getArea(): Double {
        return Math.PI * radius * radius
    }
}

The object from Circle class is created in main() method.

fun main() {
    // create an object from Circle class
    val circle = Circle(7.0)
    // call getArea() method
    val area = circle.getArea()
    // print out the result from getArea() method
    println("Area of circle: $area")
}

Output

Area of circle: 153.93804002589985

Based on the code above, the interface called ShapeInterface is created that contains abstract method called getArea(). The Circle class is implementing ShapeInterface so all of the methods inside this interface must be implemented. In main() method, the object from Circle class is created then the getArea() method is called.

The class can implements many interfaces. In this example, the Circle class implements two interfaces.

The new interface is created called EntityInterface in EntityInterface.kt file.

interface EntityInterface {
    fun getInfo()
}

The two interfaces is implemented in Circle class.

// create a Circle class that implements two interfaces
class Circle(val radius: Double): ShapeInterface, EntityInterface {

    // getArea() method is implemented
    override fun getArea(): Double {
        return Math.PI * radius * radius
    }

    // getInfo() method is implemented
    override fun getInfo() {
        println("Radius: $radius")
        println("Area of circle: ${getArea()}")
    }
}

The object from Circle class is created in main() method.

fun main() {
    // create an object from Circle class
    val circle = Circle(7.0)
    // getInfo() method is called
    circle.getInfo()
}

Output

Radius: 7.0
Area of circle: 153.93804002589985

Notes

Sealed class can be used to make many classes that inherit sealed class.
Interface can be used to define certain contract that has to be fulfilled by certain class.

This is the final part of Kotlin basic tutorial series in this blog. I hope this Kotlin basic tutorial series is helpful for learning the Kotlin programming language 😀.

Sources

Learn more about sealed class in this link.
Learn more about interface in this link.
Learn more about the example of sealed class usage in this link.

I hope this article is helpful for learning the Kotlin programming language. If you have any thoughts or comments you can write in the discussion section below.

Kotlin Tutorial - 8 Inheritance

nadirbasalamah — Wed, 13 Oct 2021 01:01:46 +0000

Inheritance is a mechanism to create a sub class that inherits attributes and methods from parent class. Basically, each class that created in Kotlin is inherits attributes and methods from Any class.

In general, parent class is a general representation from an entity whilst sub class is a more specific representation from an entity. The inheritance mechanism is illustrated in this picture.

Create an Inheritance

In Kotlin, the inheritance mechanism can be created with : notation followed with the parent class name. In this example, there are two classes called Car and RaceCar. The Car class is a parent class when the RaceCar class is a sub class from Car class. The relation between Car class and RaceCar class is illustrated in this picture.

The Car class is created inside Car.kt file.

open class Car (val manufacturer: String, val type: String) {
    open fun run() {
        println("Running...")
    }
}

The RaceCar class is created inside RaceCar.kt file.

// create a RaceCar class that inherits Car class
class RaceCar(val team: String, manufacturer: String, type: String) : Car(manufacturer, type) {
    // create a specific implementation for run() method
    // in RaceCar class
    override fun run() {
        println("Running with racing spec from $team")
    }
}

The object from RaceCar class is created in main() method.

fun main() {
    // create an object from RaceCar class
    val raceCar = RaceCar("Manthey Racing","Porsche","911 GT3")
    // call run() method
    raceCar.run()
}

Output

Running with racing spec from Manthey Racing

Based on the code above, the Car class is acts as parent class with open keyword is added before class declaration. The open keyword means a class can be inherited by another class. In Car class, the run() method is added with open keyword that means this method can be override or implemented specifically in a sub class.

The sub class from Car class is RaceCar class. The RaceCar class implements the run() method specifically with override keyword. The object from RaceCar class is created in main() method then the run() method is called from the created object.

Notes

The multiple inheritance mechanism is not available in Kotlin. Multiple inheritance is a mechanism that allows a class could inherits from many parent classes. This is the illustration of multiple inheritance.

The multilevel inheritance is available in Kotlin. This is the illustration of multilevel inheritance.

Sources

Learn more about inheritance in Kotlin in this link.

I hope this article is helpful for learning the Kotlin programming language. If you have any thoughts or comments you can write in the discussion section below.

Kotlin Tutorial - 7 Class and Object

nadirbasalamah — Thu, 07 Oct 2021 01:22:34 +0000

Object oriented programming is a programming paradigm that mainly focused on real life entities like human, car and abstract entity like course that taken by student. Object oriented programming usually involves an entity that represented as a class with attributes like name, age and behavior in entity like walk.

Create Class and Object

In object oriented programming, class is a blueprint that used to create an object. In Kotlin, a class can be created using this syntax.

class class_name(
    attributes,...
) {
    // behaviors...
}

This is the example of class creation. The class called Student is created to represents a student entity. This class is created in separated file Student.kt.

// create Student class with name and course as attribute
class Student(
    val name: String,
    val course: String
) {
    // create learn method
    fun learn() {
        println("learning $course")
    }
}

The Student class is used inside main() method.

fun main() {
    // create an object from Student class
    val student = Student("john doe","Algorithm")

    // call learn() method from the object
    student.learn()
}

Output

learning Algorithm

Based on the code above, a class called Student is created inside Student.kt file then the object from Student class is created by using constructor from Student class with the specified values for attributes. The learn() method can be called from the created object.

The best practice for class usage is to create a class in a separated file so the refactoring or maintenance for certain class can be done easily.

If the object is created from the class then the attribute value can be changed after the object is created. Use var keyword for certain attribute in a class.

// create Student class with name and course as attribute
class Student(
    var name: String,
    var course: String
) {
    // create learn method
    fun learn() {
        println("learning $course")
    }
}

The attribute value for course is changed.

fun main() {
    // create an object from Student class
    val student = Student("john doe","Algorithm")

    // the course value is changed
    student.course = "Algorithm with C++"

    // call learn() method from the object
    student.learn()
}

Output

learning Algorithm with C++

Create Data Class

In Kotlin, there is a specific class to create a particular object class or also known as POJO (Plain Old Java Object) by using data class. The POJO class is a class that contains particular methods including setter and getter.

This is the basic syntax to create data class.

data class class_name(
    attributes,...
)

This is the example of data class usage for course entity. This class is created in Course.kt file.

// create a data class called Course
data class Course(
    val code: String,
    val name: String
)

The object from Course class is created in main() method.

fun main() {
    // create an object from Course class
    val course = Course("C001","Data Structure")

    // print out the course data
    println("Course data")
    println("Course code: ${course.code}")
    println("Course name: ${course.name}")
}

Output

Course data
Course code: C001
Course name: Data Structure

Based on the code above, the object from Course class is created by using constructor from Course class that filled with specified values for the attributes.

If the object is created using data class, the attribute value from certain object can be retrieved with destructuring mechanism.

This is the example of destructuring mechanism.

fun main() {
    // create an object from Course class
    val course = Course("C001", "Kotlin Basics")

    // perform destructuring
    // retrieve value from attributes (code and name)
    val (code, name) = course

    // print out the value from code and name attribute
    println("Course data")
    println("Code: $code")
    println("Name: $name")
}

Output

Course data
Code: C001
Name: Kotlin Basics

`toString()` Method

The toString() method can be used to give the information of created object from certain class. This is the example of toString() method usage in Course class.

// create a data class called Course
data class Course(
    val code: String,
    val name: String
) {
    // using toString() method
    override fun toString(): String {
        return "Course(code='$code', name='$name')"
    }
}

The object from Course class is created in main() method.

fun main() {
    // create an object from Course class
    val course = Course("C001", "Kotlin Basics")

    // print out the object information
    println("Course data: $course")
}

Output

Course data: Course(code='C001', name='Kotlin Basics')

Based on the code above, the toString() method is called automatically if the course object is printed out.

Special Class in Kotlin (`object`)

In Kotlin there is a specific class for one time use called object. An object can be created directly in a variable or in a separated file.

This is the example of creating object directly in a variable.

fun main() {
    // create an "object" class in person variable
    val person = object {
        val name = "joe"
        val address = "palm city"

        fun greet() {
            println("Hi, my name is $name")
            println("I lived in $address")
        }
    }

    // object can be used directly
    // without creation or instantiation
    person.greet()
}

Output

Hi, my name is joe
I lived in palm city

Based on the code above, an object is created directly inside person variable. The object can be used directly without creation or instantiation of an object class.

In this example, the object class is created in separated file called Person.kt.

object Person {
    val name = "nathan mckane"
    val address = "rockford"

    fun greet() {
        println("Hi, my name is $name")
        println("I lived in $address")
    }

    fun say(message: String) {
        println("$name says $message")
    }
}

The object that already created is used in main() method.

fun main() {
    // using Person "object" in variable
    val person = Person
    person.greet()

    // the Person "object" can be used directly
    Person.say("hello!")
}

Output

Hi, my name is nathan mckane
I lived in rockford
nathan mckane says hello!

Based on the code above, an object called Person can be used inside variable or use the object directly.

The companion object can be used in a class if the method or attribute can be accessed directly without creating an object from certain class. In this example, the companion object is used in Calculator class.

class Calculator {
    // create companion object
    companion object {
        // these methods can be accessed directly
        // without creating an object from Calculator class
        fun sum(x: Int, y: Int): Int {
            return x + y
        }

        fun multiply(x: Int, y: Int): Int {
            return x * y
        }
    }
}

The Calculator class is used in main() method.

fun main() {
    // the sum and multiply method called directly
    // from Calculator class
    val sumResult: Int = Calculator.sum(4,5)
    val multiplyResult: Int = Calculator.multiply(5,6)

    println("Result from sum operation: $sumResult")
    println("Result from multiply operation: $multiplyResult")
}

Output

Result from sum operation: 9
Result from multiply operation: 30

Based on the code above, the sum() and multiply() method can be accessed directly from Calculator class because these methods are created inside companion object.

Generic

The generic concept is also available in Kotlin. Generic is a mechanism when a data type acts as parameter in a class. Generic can be used to define which data type is used in certain class rather than make some classes for many data types.

This is the example of generic usage in Kotlin.

class Box<T>(val content: T)

Create an object from Box class that use generic.

fun main() {
    val stringBox: Box<String> = Box("cool!")
    val intBox: Box<Int> = Box(24)

    println("Content from stringBox: ${stringBox.content}")
    println("Content from intBox: ${intBox.content}")
}

Output

Content from stringBox: cool!
Content from intBox: 24

Based on the code above, the generic is used inside angle brackets <> with T notation for generic type.

Enum

Enum is a class that contains many constants. This is the basic syntax to create an enum.

enum class enum_name {
    VALUE1, VALUE2, ...
}

In this example, an enum is created called Role.

enum class Role {
    STUDENT, LECTURER, ADMIN
}

The value from Role enum is used inside Student class.

// create Student class
class Student(
    val name: String,
    val course: String,
    // using value from Role enum
    val role: Role = Role.STUDENT,
) {
    fun learn() {
        println("Learning $course")
    }

}

Based on the code above, the value from Role enum is used inside an attribute with Role data type.

Notes

Class is a blueprint for an object.
Data class is suitable to create a particular object that contains setter and getter method.
The object class can be used only once.
Enum is suitable to store many constants

Sources

Learn more about class in this link.
Learn more about data class in this link.
Learn more about object in this link.
Learn more about generic in Kotlin in this link.
Learn more about enum in this link.

I hope this article is helpful for learning the Kotlin programming language. If you have any thoughts or comments you can write in the discussion section below.

DEV Community: nadirbasalamah

API Performance Testing with k6 - A Quick Start Guide

Introduction

Why Performance Testing?

What is k6?

k6 Setup

Writing the First Test

Load Testing Types

Smoke Testing

Average Load Testing

Stress Testing

Spike Testing

Endurance Testing

Using k6 Additional Libraries

Assertion with k6chaijs

Data-driven Test with Papaparse

Resources

What I've Done So Far in 2024

🏆 Achievements

🧩 Challenges

💡 Lessons Learned

✨ What's Next?

Python Tutorial - 4 Function

Introduction

Arguments and Keyword Arguments

Recursive Function

Lambda

Map and Filter

Map Function

Filter Function

Example - Remove Duplicate Codes

Tips

Sources

Python Tutorial - 3 Data Structure

Introduction

List

List Basic Operations

List Comprehension

Multi-Dimensional List

Dictionary

Dictionary Basic Operations

Tuple

Tuple Basic Operations

Set

Set Basic Operations

Introduction to Function

Example - Simple Todo List Application

Sources

Python Tutorial - 2 Control Flow

Comparison and Logical Operator

Branching in Python

Branching with if

Branching with if-else

Branching with if-elif-else

Branching with match-case

Looping in Python

Looping with for

break and continue keyword

Looping with while

Example 1 - Grade Checking

Example 2 - Palindrome Checking

Sources

Python Tutorial - 1 Introduction

Setup

Writing the First Code

Variable and Data Types

Operator

Adding User Input

Example 1 - Rectangle Area Calculation

Example 2 - Get Discounted Price

Sources

Generics in Go Tutorial

Introduction

Using Generics in Function

Using Generics in Struct

Using Generics in Interface

Notes

Sources

Introduction to Protocol Buffers

Protocol Buffers

Branching with `if`

Branching with `if-else`

Branching with `if-elif-else`

Branching with `match-case`

Looping with `for`

`break` and `continue` keyword

Looping with `while`

`toString()` Method

Special Class in Kotlin (`object`)