DEV Community: Sami Ullah Saleem

🚀 𝗗𝗶𝘃𝗲 𝗶𝗻𝘁𝗼 𝗗𝗼𝗰𝗸𝗲𝗿 𝘄𝗶𝘁𝗵 𝗗𝗼𝗰𝗸𝗲𝗿 𝗖𝗼𝗺𝗺𝗮𝗻𝗱𝗲𝗿! 🐳

Sami Ullah Saleem — Sun, 16 Mar 2025 17:57:26 +0000

I'm thrilled to introduce you to 𝗗𝗼𝗰𝗸𝗲𝗿 𝗖𝗼𝗺𝗺𝗮𝗻𝗱𝗲𝗿, a comprehensive learning tool designed to help you master Docker commands and workflows. Whether you're a developer, DevOps engineer, or just someone curious about Docker, this project is for you! 🌟

𝗙𝗲𝗮𝘁𝘂𝗿𝗲𝘀 🌟

𝗜𝗻𝘁𝗲𝗿𝗮𝗰𝘁𝗶𝘃𝗲 𝗧𝗲𝗿𝗺𝗶𝗻𝗮𝗹 🖥️
Run Docker commands and see the output directly in your browser.

𝗗𝗼𝗰𝗸𝗲𝗿 𝗪𝗼𝗿𝗸𝗳𝗹𝗼𝘄 𝗩𝗶𝘀𝘂𝗮𝗹𝗶𝘇𝗮𝘁𝗶𝗼𝗻 📊
Provides a graphical representation of various Docker workflows.

𝗖𝗼𝗺𝗺𝗮𝗻𝗱 𝗚𝘂𝗶𝗱𝗲 📚
Detailed explanations and examples for various Docker commands, helping you understand their usage and syntax.

𝗦𝗶𝘁𝗲 𝗨𝗿𝗹: https://lnkd.in/d_ZgFQeJ
𝗥𝗲𝗽𝗼𝘀𝗶𝘁𝗼𝗿𝘆 𝗟𝗶𝗻𝗸: https://lnkd.in/dSm9seFM

𝗖𝗼𝗻𝘁𝗿𝗶𝗯𝘂𝘁𝗶𝗻𝗴 🤝
The project can have bugs 🐛, and I want you to try this project and create an issue in the GitHub repo if you encounter any. Your feedback is invaluable and helps us improve the project! 💪

Building Container Images Using Dockerfiles

Sami Ullah Saleem — Wed, 16 Aug 2023 11:43:21 +0000

1- Create Dockerfile

~ vi Dockerfile

FROM httpd:2.4
RUN apt update -y && apt autoremove

Dockerfile always start from FROM keyword and after it we tell the image name like we are telling here httpd of which we want to create our container.
RUN whatever we are going to write after RUN it will be run in our container.

~ docker build -t wigetfactory .

Here you can see that we are creating our image from our Dockerfile and giving it a name which is wigetfactory

2- Let's update our Dockerfile and put our website content in it.

FROM httpd:2.4
RUN apt update -y && apt autoremove
rm -f /usr/local/apache2/htdocs/
WORKDIR /usr/local/apache2/htdocs/
COPY ./web .

Here you can see that I am changing my container work directory using *WORKDIR * command and then copy my website content from my host directory to the container location which is htdocs.
Let's run our Dockerfile again.

~ docker build -t widgetfactory:0.3 .

Here will be the output of it

Now run container using the image.

docker  run --name weebproject -d -p 80:80 widgetfactory:0.3

Follow me for more content

Storing Container Data in AWS S3

Sami Ullah Saleem — Mon, 14 Aug 2023 17:35:40 +0000

Install awscli

~ pip install --upgrade --user awscli

AWSCLI Configure

~ aws configure

Install sefs

~ yum install s3fs-fuse -y

Mount S3 Bucket to local filesystem

So, what we have done here?
We mount our s3 bucket to our local system and then bind mount it with the container. Now, if we copy any new file to our local directory. It will automatically go to our s3 bucket and in our containers

Storing Container Data In Docker Volumes

Sami Ullah Saleem — Mon, 14 Aug 2023 17:06:54 +0000

Let's learn about volumes in Docker
What you will learn?

Anonymous Volumes
Create a Docker Volume
Use the Website Volume with Containers
Clean Up Unused Volumes

1. Anonymous Volumes
When we create a container then automatically docker creates an anonyous volume for that container.

Now, lets inspect the volume using the following command

2- Create a Docker Volume

~ docker volume create webiste
~ docker volume ls

3. Use the Website Volume with Containers

~ docker run -d --name web1 -p 80:80 -v webiste:/usr/local/apache2/htdocs:ro httpd:2.4

4- Clean Up Unused Volumes

~ docker volume prune

Hosting site on httpd and nginx docker container

Sami Ullah Saleem — Sun, 13 Aug 2023 20:18:37 +0000

Docker Project
In this project, I created containers using httpd and nginx images using command

~ docker pull httpd
~ docker run --name httpdproject httpd -d

Then I first stop and then remove this container

* docker stop httpdproject 
* docker rm httpdproject

Then I mount my website content on my container using these commands

~ docker run --name mywebproject -p 8080:80 -v $(pwd)/web:/usr/local/apache2/htdocs:ro -d httpd
~ docker ps

We can check our website will be running on 8080 port which it's redirecting to 80 port of container

Same Process, we will do with nginx

~ docker run --name nginxproject -p 8082:80 -v $(pwd)/web:/usr/share/nginx/html:ro -d nginx

Now, we can see our site will be working on 8082 port.

Dictionary
ps command to check running containers
images command to see available images
-p this flag with run use for port redirecting
-v is used to mount volume on the container
--name flag with run is used to name our container
-d flag means run container in detached mode. It means that it should be run in the background

Django Notes

Sami Ullah Saleem — Fri, 21 Jul 2023 11:56:27 +0000

HTTP vs HTTPS: *HTTP (Hypertext Transfer Protocol) * is the standard protocol used for communication between a web browser and a web server. It is not secure, meaning the data transmitted over HTTP is not encrypted, making it vulnerable to interception and tampering by attackers. On the other hand, HTTPS (Hypertext Transfer Protocol Secure) is a secure version of HTTP. It uses encryption protocols such as SSL (Secure Sockets Layer) or TLS (Transport Layer Security) to secure the communication between the web browser and the web server. HTTPS is identified by "https://" in the URL and ensures that data transmitted is encrypted and secure.

2. UDP vs TCP:
*UDP (User Datagram Protocol) and TCP (Transmission Control Protocol) * are both transport layer protocols used to transmit data over a network. The main differences between them are:

UDP: Provides connectionless communication and is often used for real-time applications such as video streaming, online gaming, and VoIP. It is faster but less reliable since it does not guarantee data delivery, and packets may arrive out of order or be lost.

TCP: Provides reliable, connection-oriented communication. It ensures that data packets are delivered in the correct order and without loss. TCP uses a three-way handshake to establish a connection between the sender and receiver before data transmission.

DNS (Domain Name System):
DNS is a system used to translate human-readable domain names (e.g., www.example.com) into IP addresses (e.g., 192.0.2.1) that computers can understand. When you enter a URL in your browser, the browser sends a DNS query to a DNS server, which returns the corresponding IP address. This IP address is then used to establish a connection with the appropriate web server.

Request Life Cycle:
The request life cycle refers to the process of how a web server handles a request from a client (usually a web browser). It typically involves the following steps:

a. DNS Resolution: The client resolves the domain name to an IP address using DNS.
b. Connection Establishment: The client establishes a TCP connection with the web server.
c. Request Handling: The client sends an HTTP request to the server, including the requested resource, method (GET, POST, etc.), and other headers.
d. Server Processing: The web server receives the request, processes it, and generates an appropriate response.
e. Response Sending: The server sends the response back to the client over the established TCP connection.
f. Browser Processing: The client (browser) receives the response and renders the web page or handles the data as required.

HTTP Request Types (GET, POST, PUT, etc.) and their Differences:
HTTP supports various request methods, each serving different purposes:

GET: Used to request data from the server. Parameters are sent in the URL, making it visible and limited in length. It is generally used for fetching data.

POST: Used to send data to the server in the request body. It is suitable for submitting forms or sending large amounts of data securely.

PUT: Used to update or replace existing data on the server with the data sent in the request body.

DELETE: Used to request the removal of a resource on the server.

PATCH: Used to apply partial modifications to a resource.

HEAD: Similar to GET but only retrieves the response headers, not the actual data.

OPTIONS: Used to request information about the communication options available for a resource.

Application Server vs. Web Server:

Web Server: A web server is responsible for handling HTTP requests from clients (browsers) and returning static content like HTML, CSS, and images. It manages the basic HTTP protocol, serves static files, and may support server-side includes. Examples include Apache HTTP Server and Nginx.

Application Server: An application server handles dynamic content and business logic. It interprets server-side code, interacts with databases, and generates dynamic HTML or other content to be sent to the client. Application servers are used to support web applications and APIs. Examples include Tomcat, Node.js, and Microsoft IIS.

How Encryption Works vs. How Hashing Works:

Encryption: Encryption is the process of converting plain text into a scrambled, unreadable form called ciphertext using an encryption algorithm and an encryption key. The recipient can decrypt the ciphertext back into the original plaintext using a decryption key. Encryption is used to secure data during transmission (e.g., HTTPS) and storage to prevent unauthorized access.

Hashing: Hashing is a one-way process of converting input data (any size) into a fixed-size string of characters using a hash function. The resulting output, called a hash value or hash code, is unique to the input data. Unlike encryption, hashing is not reversible, meaning you cannot convert the hash value back into the original data. Hashing is commonly used for data integrity checks, password storage, and digital signatures.
**
HTTP Headers:**
HTTP headers are additional pieces of information sent by the client or server in the request or response messages. They provide metadata about the request or response and allow clients and servers to pass various instructions, control caching behavior, enable CORS (Cross-Origin Resource Sharing), and set cookies, among other functionalities. Some common HTTP headers include "User-Agent," "Content-Type," "Accept," "Authorization," "Cache-Control," and "Location."

Comment Headers:
"Comment headers" is not a standard term in web development or HTTP. It is possible that this refers to custom headers added to HTTP requests or responses for documentation purposes or additional information specific to an application or system.

Above Average Topics:

SSL/HTTPS Encryption and Handshake:
SSL (Secure Sockets Layer) and its successor TLS (Transport Layer Security) are cryptographic protocols used to secure communications over a computer network. HTTPS, as mentioned earlier, is the implementation of HTTP over TLS/SSL.

The SSL/TLS handshake is the process of establishing a secure connection between a client (e.g., web browser) and a server. The handshake involves the following steps:

a. Client Hello: The client sends a "Client Hello" message to the server, containing supported cryptographic algorithms and other information.

b. Server Hello: The server responds with a "Server Hello" message, selecting the best cipher suite and providing its digital certificate (which includes the server's public key).

c. Certificate Exchange: The client verifies the server's certificate against a trusted Certificate Authority (CA) to ensure the server's authenticity.

d. Key Exchange: The client generates a random pre-master secret, encrypts it using the server's public key, and sends it to the server. Both client and server then derive the master secret from this pre-master secret.

e. Session Key Generation: Both client and server independently generate session keys from the master secret, which will be used for encryption and decryption during the session.

f. Encrypted Communication: The client and server exchange messages encrypted using the session keys, establishing a secure channel for further communication.

Nameservers:
Nameservers are part of the Domain Name System (DNS) infrastructure and are responsible for translating domain names into IP addresses. When you enter a domain name into a browser, the browser queries a nameserver to obtain the IP address associated with that domain. There are two types of nameservers: authoritative nameservers and recursive/resolver nameservers.

Authoritative Nameservers: These nameservers hold the official records for specific domains. They store information about the IP addresses of the servers associated with a domain.

Recursive/Resolver Nameservers: These nameservers are used by clients (e.g., browsers) to resolve domain names. They recursively query authoritative nameservers to find the IP address associated with a given domain.

Understanding SSL/HTTPS encryption, HTTP handshake, and the role of nameservers is valuable knowledge for web developers and administrators, as it helps ensure secure communication and proper functioning of web applications.

Django
Django is an open source web development framework. It's built on Jazz philosophy. It means it's free and open source.
Django also provides an optional administrative create, read, update and delete interface that is generated dynamically through introspection and configured via admin models. It provides you serialization, Caching, middleware, web server for testing, MVT architecture which is based on basically MVC and an interface to built python built in unit test. The main goals of python is simplicity, flexibility, reliability, and scalability. DRY philosophy — Don’t Repeat Yourself — which means developers can reuse existing code and focus on the unique one.
**
What You Can Do with Django **
You can build ecommerce application, financial applications, face matching applications and many more.

Summary,
Django is a great addition to projects that need to handle large volumes of content (e.g., media files), user interactions or heavy traffic, or deal with complex functions or technology (e.g., machine learning). Yet it is simple enough for smaller-scale projects, or if you intend to scale your project to a much higher level. That’s why Django is used by so many companies that vary in size and goals.

Loose Coupling means that your code should be modular and less dependent on other modules or dependencies.

Django Philosophy
In Templates, avoid repetition, make it simple, using dynamic engine or interpolation for creating templates.
In Model, you should not assume things or characteristics. You should have good knowledge of the requirements.

In View, it should be simple. Handle GET POST requests and should have loose coupling.
In all cases, explicit is better than implicit, Simplicity, consistency, and best practices should be in mind.

Devops Notes

Sami Ullah Saleem — Thu, 20 Jul 2023 15:50:07 +0000

What is DevOPs?
There are lot of definition exist but in simple words it's all about development and operations. We automate things in it because manual work takes a lot of time to complete.

What is CD/CI?
CI means Continuous Integration. Let's suppose developers are coding for more than 3 weeks and after 3 weeks they take rest but when the code goes to build and testing. They find a lot of errors. This thing Just Sucks. So, We need to automate deployment so that we can see errors as soon we push our code or commit then automatically build and test and tells the errors if come
Now, So we can use different tools for it like Jenkins, Circle CI etc.

CD means Continuous Development. Now, we have automate things from the development end and a lot of code coming to operations team because of automation. Now, we have to automate operations and testing. So, Continuous Delivery means The code automatically deploy on server and after deployment further testing can be performed by QA but this can also be automated. We can write automated test cases for our code.

Python Notes

Sami Ullah Saleem — Sun, 09 Jul 2023 14:33:57 +0000

History

Python was founded by Guido and it's name taken from a BBC Comedy Series Monty Python's Flying Circus because of it's complete and mysterious nature which python also has.
It's a dynamically types language and strongly typed language.
It's an interpretation language.

Syntax Rule

It requires indentation. At least one space is required for a block.

if 2>3:
 print("Hello World")

You can use Unicode symbol in python.

Operators in Python

Arithmetic Operator
Assignment Operator
Logical Operator
Bit wise Operator
Comparison operator
Identity Operator
Membership Operator

pip and Virtual Environment

pip is a python package manager which we can use to install packages from python package index.
You can create virtual environment where you can have complete copy of python, pip etc. It will help you to avoid dependencies error etc.
Install virtualenv globally

pip install virtualenv

Create virtual environment using

virtualenv env

Activate environment on linux

source /env/bin/activate

Windows

env\Scripts\activate

pipenv makes it easy because it combines pip and virtual environment in one single tool. It generate pipfile which has all dependencies with their versions. It also generates pipfile.lock which lock the versions of the packages so that they work fine. Control Structures
While Loop: The while statement repeats a body of code as long as a condition is true.
For Loop: It's mostly use to iterate over number of items.
list comprehension: A list comprehension allows you to easily create a list based on some processing or selection criteria.

l1 = [x for x in range(0,5)]
print(l1)
[0,1,2,3,4]

Type Casting

Type Conversion is the conversion of an object from one data type to another data type.
Implicit Type Conversion is automatically performed by the Python interpreter.
Python avoids the loss of data in Implicit Type Conversion.
Explicit Type Conversion is also called Type Casting, the data types of objects are converted using predefined functions by the user.
In Type Casting, loss of data may occur as we enforce the object to a specific data type.

Exception Handling

try/except block If the code in try block failed then the code in except block will run
try/except/else block If the code in the try block failed then except block code will run and if the code in try block becomes successful then the code in the else block will run. If any exception occurs in the else block code then the above try/except block will not work.
try/except/else/finally block It has an extra finally block which always run either the code makes an error or not.

Functions

Benefits of function are reuseability and readability Partial Function Partial functions allow us to fix a certain number of arguments of a function and generate a new function. e.g

def f(a, b, c, x):
    return 1000*a + 100*b + 10*c + x

# A partial function that calls f with
# a as 3, b as 1 and c as 4.
g = partial(f, 3, 1, 4)

# Calling g()
print(g(5))

Lambda Function
In Python, a lambda function is a special type of function without the function name. For example,

greet = lambda name: print("Hello", name)
greet("sami")
add = lambda a,b:print(a+b)
print(add(1,2))

We can use filter or map to find filter out our list. E.g
Filter return new list with new values and map return True or False list.

list1 = [1,2,3,4,5]
list2 = list(filter(lambda x:x%2==0,list1))
print(list2)
# The Output will be -> [2,4]

Monkey Patching
In Python, the term monkey patch refers to dynamic (or run-time) modifications of a class or module. In Python, we can actually change the behavior of code at run-time.

Collection (Arrays)
There are four types of collection data types in python.

List
Set
Dictionary
Set

1.List
List is a collection which is ordered and changeable. Allows duplicate members.
Time Complexity: O(1)
Space Complexity: O(1)
List operations:
append,pop,remove,del sort, reverse, clear, and insert
We use the extend() method to add all the items of an iterable (list, tuple, string, dictionary, etc.) to the end of the list

numbers = [1, 3, 5]

even_numbers = [4, 6, 8]

# add elements of even_numbers to the numbers list
numbers.extend(even_numbers)

print("List after append:", numbers)

2.Tuple
Tuple is a collection which is ordered and unchangeable. Allows duplicate members. Tuples are immutable
Operations
append,comp,len,min,max,tuple
3.Sets
A Set in Python programming is an unordered collection data type that is iterable, mutable and has no duplicate elements. This is based on a data structure known as a hash table. Since sets are unordered, we cannot access items using indexes as we do in lists.
**Frozen sets **in Python are immutable objects that only support methods and operators that produce a result without affecting the frozen set or sets to which they are applied. It can be done with frozenset() method in Python.

While elements of a set can be modified at any time, elements of the frozen set remain the same after creation.
Operations:
add,discard, union, intersection, difference
4.Dictionary
Dictionary is a collection which is ordered (prior to Python 3.6, dictionaries were
unordered) and changeable. No duplicate members.
Operations
pop, popitem, del, insert new values

Strings

Escape Sequencing in Python You use single quotes, double quotes or triple quotes for printing a string but you can't use quotes inside the string.So, we use backslash for it. The element next to backslash deal in new meanings rather than literal meanings.

l1 = "\"Hello World\""

Formatting in Strings We use format() function for formatting Strings in Python can be formatted with the use of format() method which is a very versatile and powerful tool for formatting Strings. Format method in String contains curly braces {} as placeholders which can hold arguments according to position or keyword to specify the order.

name = "Sami Ullah"
age = 20

print("My name is {} and My age is: {}".format(name,age))

Methods
Capitalize, lower, upper, endswith, startswith

Object Oriented Programming

Abstraction -> In this you hide implementation of an object from the user.
Encapsulation -> In this, you combine data and methods with in a class to protect the data from external interference.
Inheritance -> It is a way to create new classes based on existing ones, allowing the new classes to inherit the attributes and methods of the parent class.
Polymorphism -> It allows objects of different classes to be treated as if they were of the same class, making it possible to write generic code that can work with a variety of objects.

There are two types of attributes 1) Instance Attribute -> This is described in constructor 2) Class Attribute -> This is described outside of the constructor.
Name mangling is a mechanism we use for accessing the class members from outside. The Python interpreter rewrites any identifier with “var” as “_ClassNamevar”. And using this you can access the class member from outside as well.
Namespaces and Scopes
When Python tries to interpret your code, one key task is to understand what variables and functions that you refer to. To get the job done, Python uses namespaces to track the variables and functions that it can search. Specifically, you can think of namespaces as dictionaries that store all the variables that are available to you — they are tools in your tool boxes.
Scopes are a concept closely related to namespaces. Scopes define boundaries where Python can resolve the variables (resolve means Python understands what variables it should use). As mentioned above, namespaces are tracking the tools in your boxes, while scopes are different tool boxes — some are larger and some are smaller (local scope for a function) and embedded in larger scopes (e.g., global scope for the module).
In Python, an abstract function is a function that is declared but does not have an implementation. It serves as a blueprint for subclasses to override and provide their own implementation. Abstract functions are typically used in the context of abstract classes or interfaces to enforce certain behaviors or contracts.


from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

    @abstractmethod
    def perimeter(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

    def perimeter(self):
        return 2 * 3.14 * self.radius

Constructors
There are two types of constructors.
1- Default Constructor
2- Parametrized Constructor
Class Methods

Let’s compare that to the second method, MyClass.classmethod. I marked this method with a @classmethod decorator to flag it as a

Static methods are like simple methods but belong to class

classmethod receives the class as the first parameter (cls) and can access class-level data, while staticmethod does not receive any special parameters and does not have access to instance or class-level data.

Inheritance Types
There are 5 inheritance types.

Single Inheritance
Multiple Inheritance
Multilevel Inheritance
Hierarchical Inheritance
Hybrid Inheritance

Static Variable and Static methods
Static variables are related to class not objects and static methods related to class not objects.
*Function Overloading vs Function Overriding *
Function overloading can be done without inheritance. In this we have two or more function with same name but with different parameters. Python doesn't support it. So, we can use parameterized functions to make it possible. It decide on compile time. It's make our code complex.
While Function overriding occurs in inheritance. It need two classed at least. The functions should have same name and it decide on run time. It's makes our code complex.

File Handling

f = open(filename,mode)

modes
r -> read
w -> write and overridden data
a -> append the file
r+ -> read and write data and overridden data
w+ -> write and read data and overridden data
a+ -> append and read data from the file. It won't be override existing data
You can remove file using os module

os.remove('test.txt')

Iterators
An iterator is an object that can be iterated upon, meaning that you can traverse through all the values.

Iterators are methods that iterate collections like lists, tuples, etc. Using an iterator method, we can loop through an object and return its elements.

Technically, a Python iterator object must implement two special methods, iter() and next(), collectively called the iterator protocol.

# define a list
my_list = [4, 7, 0]

# create an iterator from the list
iterator = iter(my_list)

# get the first element of the iterator
print(next(iterator))  # prints 4

# get the second element of the iterator
print(next(iterator))  # prints 7

# get the third element of the iterator
print(next(iterator))  # prints 0

Generators
A generator is a function that returns an object (iterator) which we can iterate over (one value at
a time).
Create Python Generator

In Python, similar to defining a normal function, we can define a generator function using the def keyword, but instead of the return statement we use the yield statement.

def generator_name(arg):
    # statements
    yield something

Here, the yield keyword is used to produce a value from the generator.

When the generator function is called, it does not execute the function body immediately. Instead, it returns a generator object that can be iterated over to produce the values.
The yield keyword is used to produce a value from the generator and pause the generator function's execution until the next value is requested.

The for loop iterates over the generator object produced by my_generator(), and the print statement prints each value produced by the generator.

Decorators
A decorator is a design pattern in Python that allows a user to add new functionality to an
existing object without modifying its structure. Decorators are usually called before the definition
of a function you want to decorate.

def maketea(func):
    func()
    print("Tea is making")


@maketea
def pre():
    print("Preperation has been done")

Here pre is sending as argument to maketea function

In Python, a first-class object refers to a programming language feature where functions can be treated as values. This means that functions can be assigned to variables, passed as arguments to other functions, and returned as values from other functions. In Python, functions are first-class objects, which means they can be manipulated and used just like any other data type.
Chaining decorators in Python can be done by applying multiple decorators to a function in a sequential manner


@decorator1
@decorator2
def example(): print("Hello World")

Shallow Copy vs Deep Copy
A shallow copy constructs a new compound object and then (to the extent possible) inserts
references into it to the objects found in the original. A deep copy constructs a new compound
object and then, recursively, inserts copies into it of the objects found in the original.
Syntax of Deep copy

Syntax: copy.deepcopy(x)

Syntax of Shallow copy

Syntax: copy.copy(x)

Random Numbers
The Python standard library provides a module called random that offers a suite of functions for generating random numbers.

Python uses a popular and robust pseudorandom number generator called the Mersenne Twister.

We use seed() function if we want reproduce able random numbers. Otherwise random function use epoch(1971).

PEP 8
Coding Style to follow

Consistent Indentation
The closing brace/bracket/parenthesis on multiline constructs may either line up under the first non-whitespace character of the last line of list or it may be lined up under the first character of the line that starts the multiline construct.
Spaces are the preferred indentation method.
Tabs should be used solely to remain consistent with code that is already indented with tabs.
Python disallows mixing tabs and spaces for indentation.
Import should be on seperate line
Comments use and docstring use Linter Linting highlights syntactical and stylistic problems in your Python source code, which often helps you identify and correct subtle programming errors or unconventional coding practices that can lead to errors. Formatter Formatter only format your code. It doesn't analyze your code and find errors in it

*Difference between Linter and Formatter *
Linting is distinct from Formatting because linting analyzes how the code runs and detects errors whereas formatting only restructures how code appears.

Steps to create RestAPI with Django Rest Framework

Sami Ullah Saleem — Sun, 18 Jun 2023 20:19:23 +0000

Steps
1- Create a Project
2- Create an App
3- Create urls.py and Serializers.py file in your app
4- Create a model
5- Go to Serialzers.py file and create a class like TestSerializer(serliazer.ModelSerializer) and add model and fields values
6- Go to views file and create a class TestView(APIView) and create functions like get, post, put, and delete in it
7- Go to urls.py file and add path like path("/",TestView.as_view())
8- Create another path to delete an object like path("/",TestView.as_view())
Here you go, These are steps required to create restful api

The Complete Guide to Solidity Programming: Learn to Build Smart Contracts Like a Pro

Sami Ullah Saleem — Sun, 07 May 2023 19:43:07 +0000

As the popularity of blockchain technology increases, the demand for smart contracts has also risen. Smart contracts are digital agreements that are self-executing and can be used to automate various processes such as payments, identity verification, and more. One of the most popular programming languages used to create smart contracts is Solidity. In this guide, I will take you through everything you need to know about Solidity programming, from its basics to building complex smart contracts.

Introduction to Solidity programming

Solidity is a high-level programming language used to write smart contracts on the Ethereum blockchain. It is similar to JavaScript and is designed to be simple, statically typed, and contract-oriented. Solidity was created by the Ethereum Foundation and is now being used by various organizations to develop decentralized applications.

Why learn Solidity programming?

Solidity programming is a highly in-demand skill in the blockchain industry. As more businesses embrace blockchain technology, the demand for developers who can create smart contracts using Solidity has increased. Learning Solidity programming will enable you to build decentralized applications and smart contracts, which are the backbone of the blockchain ecosystem.

Getting started with Solidity programming

To get started with Solidity programming, you will need to install the Solidity compiler. The compiler is used to convert Solidity code into bytecode, which can run on the Ethereum Virtual Machine (EVM). Once you have installed the compiler, you can start writing your first smart contract.

Solidity syntax and data types

Solidity syntax is similar to JavaScript syntax. Solidity supports various data types, including bool, int, uint, address, and more. The bool data type can have two values, true or false. The int data type is used to represent signed integers, while the uint data type represents unsigned integers. The address data type is used to represent Ethereum addresses.
**
Variables and functions in Solidity**

Variables in Solidity are used to store data. Solidity supports various variable types, including integers, strings, and arrays. Functions are used to perform specific tasks and can be called by other functions or contracts. Solidity supports both external and internal functions.

Here is the syntax to create variables and functions:

pragma solidity ^0.8.4;

contract MyContract {
    uint256 public myUint;

    function setMyUint(uint256 _myUint) public {
        myUint = _myUint;
    }
}

Control structures in Solidity

Control structures are used to control the flow of code execution in Solidity. Solidity supports various control structures, including if-else statements, for loops, while loops, and more. If-else statements are used to execute code based on a condition. For loops are used to execute a block of code a specific number of times.

Here is the syntax for a control structure:

pragma solidity ^0.8.4;

contract MyContract {
    uint256 public myUint;

    function setMyUint(uint256 _myUint) public {
        if (_myUint > 10) {
            myUint = _myUint;
        } else {
            myUint = 0;
        }
    }
}

Object-oriented programming in Solidity

Solidity supports object-oriented programming concepts such as inheritance, polymorphism, and encapsulation. Inheritance is used to create a new contract that inherits from an existing contract. Polymorphism is used to create functions that can operate on different types of data. Encapsulation is used to protect data and functions from external access.

Here is the syntax for object-oriented programming:

pragma solidity ^0.8.4;

contract Animal {
    string public name;

    constructor(string memory _name) {
        name = _name;
    }
}

contract Dog is Animal {
    function bark() public view returns (string memory) {
        return "Woof!";
    }
}

**
Building smart contracts with Solidity**

Now that you have learned the basics of Solidity programming, it's time to build your first smart contract. In this example, we will create a simple smart contract that stores and retrieves a string.

pragma solidity ^0.8.4;

contract MyContract {
    string public myString;

    function setMyString(string memory _myString) public {
        myString = _myString;
    }

    function getMyString() public view returns (string memory) {
        return myString;
    }
}

Popular Solidity frameworks and tools

Solidity programming can be made easier with the use of various frameworks and tools. Here are some examples:

Truffle: A development framework that allows for easy testing, deployment, and management of smart contracts.

Remix: An online Solidity IDE that allows for easy writing, testing, and deployment of Solidity code.

Ganache: A personal blockchain that can be used for testing and development purposes.

Conclusion

Solidity programming is an essential skill for anyone interested in the blockchain industry. With this guide, you should now have a good understanding of Solidity syntax, data types, variables, functions, control structures, object-oriented programming, and building smart contracts. Keep practicing and experimenting with Solidity to become a pro in no time.

How to create CD/CI pipeline using Jenkins

Sami Ullah Saleem — Sat, 15 Apr 2023 08:26:02 +0000

Today we are going to see the steps to create CD/CI pipeline

Create a VM on AWS or Azure and give security access according to your need
Install docker and jenkins on your VM
clone your github code on your VM
Create a freestyle project on your jenkins and use Github Project url and Github repository url
Your repository should contain Dockerfile
Go to Build Steps options at the bottom and click on execute shell and write the same commands which you use to create a docker container using dockerfile on command line.
We are automating it.

Now, what will happens?

Jenkins fetch the code from the github and create a container using the docker file and your app will start running

Errors:
Some errors may occur like giving permission denied you can google it and find the solution accordingly. Most of the times, it happens because of the docker user group creation.

Bonus
Don't forget to connect your Jenkins and Github using ssh key before starting the below topic
You can create Webhooks

Go to your repository settings and go to webhooks.
Add new Webhook and add jenkins url + /github-webhook
Go to configure options of your project and go to Build Triggers options and select GitHub hook trigger for GITScm polling

Now, whenever a trigger happens or your can say you change anything in your repository. Automatically, It will update the code with the new one

Jenkins Syntax and Logic

Sami Ullah Saleem — Wed, 12 Apr 2023 23:42:43 +0000

Environment Variables

Environment variables are key-value pairs that can be used to store and retrieve data during a Jenkins build. They are often used to store sensitive data, such as API keys or passwords, that should not be hardcoded into your scripts.

Here's an example of how to define an environment variable in Jenkins:

pipeline {
    agent any
    environment {
        MY_VARIABLE = "my value"
    }
    stages {
        stage('Example') {
            steps {
                echo "${env.MY_VARIABLE}"
            }
        }
    }
}

In this example, we define an environment variable called MY_VARIABLE and give it a value of "my value". We then use the echo command to print out the value of this variable.
Parameters

Parameters allow you to pass data into your Jenkins builds. They are often used to specify different configuration options or to allow users to select options at runtime.

Here's an example of how to define a parameter in Jenkins:

pipeline {
    agent any
    parameters {
        string(name: 'MY_PARAMETER', defaultValue: 'default value', description: 'A description of the parameter')
    }
    stages {
        stage('Example') {
            steps {
                echo "${params.MY_PARAMETER}"
            }
        }
    }
}

In this example, we define a string parameter called MY_PARAMETER with a default value of "default value" and a description. We then use the echo command to print out the value of this parameter.
Conditions and Logic

Jenkins provides a number of different ways to perform conditional logic and branching within your builds. Here are a few examples:
if statement

The if statement allows you to perform conditional logic within a stage of your pipeline.

pipeline {
    agent any
    stages {
        stage('Example') {
            steps {
                if (params.MY_PARAMETER == 'some value') {
                    echo "The parameter is set to 'some value'"
                } else {
                    echo "The parameter is set to something else"
                }
            }
        }
    }
}

In this example, we use an if statement to check if the value of MY_PARAMETER is equal to "some value". If it is, we print a message indicating that the parameter is set to "some value". If it is not, we print a different message.
when condition

The when condition allows you to control whether a stage should be executed based on some condition.

pipeline {
    agent any
    stages {
        stage('Example') {
            when {
                expression { params.MY_PARAMETER == 'some value' }
            }
            steps {
                echo "The parameter is set to 'some value'"
            }
        }
    }
}

In this example, we use a when condition to check if the value of MY_PARAMETER is equal to "some value". If it is, we execute the stage and print a message. If it is not, we skip the stage entirely.
Loops

Jenkins also provides a number of ways to perform loops within your pipeline. Here's an example of using a for loop to iterate over a list of items:

pipeline {
    agent any
    stages {
        stage('Example') {
            steps {
                def items = ["one", "two", "three"]
                for (item in items) {
                    echo "Item: ${item}"
                }
            }
        }
    }
}

In this example, we define a list of items and