The book "Artificial Intelligence: AI Engineer's Cheatsheet: Silicon edition" is the only book you need to master AI and ML concepts to become a ML Engineer or ML Researcher.

Get your copy at: AI ENGINEER SILICON CHEATSHEET

The book will give you the real research and engineering knowledge you lack. No AI will replace you if you have this skill. For theoretical knowledge, search algorithms were enough.

This book covers all major topics that you must understand to build a practical deep understanding of state-of-the-art (SOTA) AI. Some of the topics include:

• Design of AI systems (MLSys) and LLM serving. Foundation of systems like vLL, SGLang. Optimizations that help OpenAI serve over 900M users weekly like Prefill Chunk.
• Core LLM architecture and operations like Attention with variants like FlexAttention, FlashAttention and more.
• Core Deep Learning optimizations like Quantization.
• Architecture and optimization techniques of AI processors like GPU, TPU, Gaudi and CPU (x86 + ARM).
• Core Intuitive Understanding that helps you understand the global AI race and direction and helps you to jump into AI discussions.

On completing this book, you will be ready:

• To clear interview opportunities at High-Tech companies like Meta, Google, xAI and Foundational AI startups like Mixtral and Perplexity.
• Be able to conduct your own independent AI research.
• Be able to do quick calculations of various AI/LLM requirements.
• Deep insights into everything AI.
• Join AI discussions on World Politics or Future of AI.

This book is for:

• Students and developers preparing for Coding Interviews specifically for Machine Learning/Deep Learning/GenAI positions.
• Experienced developers who wanted to revise their Deep Learning skills.
• Students who need a coding sheet to revise DL/AI/ML topics quickly.

Get started with this book and change the equation of your career.

Book: Artificial Intelligence: AI Engineer's Cheatsheet: Silicon edition
Author (1): Seymour Boris Papermaster
Published: September 2025 (Edition 1)

When players spin the reels of an online pokie or place a bet at a digital blackjack table, they expect one thing above all else: fairness. That sense of trust is made possible by Random Number Generators (RNGs), the unseen engines running behind every legitimate online casino game. These algorithms are responsible for ensuring that each spin, card draw, or dice roll is unpredictable and independent from the last. Without RNGs, the credibility of the entire online gambling industry would collapse. I've spent years studying how casinos operate, and in my experience, the platforms that are most transparent about their RNG systems - such as https://uptown-pokies.online/en-au/ create an environment where players can spin with confidence, knowing that fairness isn't just promised, but built into every outcome. By embracing certified RNGs, these casinos prove that chance, not manipulation, determines whether you win or lose.

How RNGs Actually Work

At its core, an RNG is a piece of software that generates long sequences of numbers at lightning speed. Each number corresponds to a potential outcome in the game - such as which reel symbols appear, which card is dealt, or where the roulette ball lands. The system ensures that every result is independent from the last. That's why even if you've had ten spins without a win, the next spin is not "due" for a payout; it's just as unpredictable as the first.

Most online casinos use two types of RNGs:

• Pseudo-RNGs: Software-driven, relying on complex algorithms and seed values. These are the most common in pokies and digital table games.
• True RNGs: Hardware-based, often using natural phenomena (like electronic noise) to generate randomness. These are less common but considered the gold standard. As an expert tip, I always advise players to look for platforms that submit their RNGs to independent auditors, such as eCOGRA or iTech Labs. These certifications prove that the system has been tested for genuine randomness and fairness.

Why RNGs Matter for Players

For players, the RNG is both friend and foe. It guarantees that outcomes are fair, but it also removes any illusion of control. No strategy can influence when a jackpot drops or when a winning hand arrives. This may sound frustrating, but it's what protects the integrity of the game.

In practical terms, this means:

1. Every spin is unique - Past results don't affect future outcomes.
2. Payout rates are statistical - Over thousands of plays, the advertised RTP (Return to Player) becomes
   accurate.
3. Fairness is constant - Whether you bet small or go all in, the RNG doesn't discriminate.

Understanding this helps you approach online gambling with the right mindset. Rather than chasing patterns, focus on bankroll management, choosing games with strong RTPs, and playing for entertainment first.

RNGs and Responsible Gambling

One of the underappreciated roles of RNGs is how they support responsible gambling. Because outcomes cannot be predicted or manipulated, RNGs discourage unhealthy "chasing losses." For example, if you lose several rounds in a row, it doesn't mean a win is around the corner. Accepting this truth helps players set realistic expectations.

From my perspective, the best players aren't those who try to beat the RNG - they're the ones who understand it. By recognizing that every spin is independent, you learn to enjoy the unpredictability without falling into the trap of superstition.

The Future of RNGs in Online Casinos

With the rise of blockchain technology and AI, RNGs are evolving. Some casinos are experimenting with transparent "provably fair" systems, where players can verify the randomness of each outcome in real time. This extra layer of transparency could redefine how trust is built in online gambling.

Meanwhile, AI is being used to monitor RNG performance, ensuring that systems remain secure and resistant to hacking attempts. For players, this means the fairness of online pokies and casino games will only grow stronger in the future.

Final Thoughts

Random Number Generators are the backbone of online casino fairness. They ensure that when you spin, bet, or withdraw your winnings, the outcome is governed by chance, not manipulation. For players who want both entertainment and trust, choosing platforms that emphasize certified RNG systems - such as Uptown Pokies - is essential. By understanding how these systems work, you gain peace of mind and can focus on enjoying the excitement that makes online gambling such a global phenomenon.

In the ever-evolving world of decentralized technologies, understanding the core infrastructure behind blockchain systems is essential. Among the most critical components of any blockchain network are nodes. While frequently mentioned, nodes are often misunderstood. This article provides a technical overview of blockchain nodes, demystifying their role, types, and operational significance within a distributed ledger environment.

What Are Blockchain Nodes?

At its simplest, a node is any device—typically a computer—that participates in the blockchain network. Nodes communicate with each other to propagate transactions and blocks, verify information, and maintain a copy (partial or full) of the blockchain ledger.

These nodes work together to maintain the integrity, security, and decentralization of the network.

Types of Blockchain Nodes

Blockchain nodes vary depending on their roles and responsibilities. Here are the most common types:

1. Full Nodes

Full nodes are at the heart of a blockchain network. They download and store the whole history of the blockchain and independently verify every transaction and block. Bitcoin and Ethereum rely heavily on full nodes to maintain network consensus. These nodes enforce the rules of the protocol and reject invalid data.

2. Lightweight (or SPV) Nodes

Simplified Payment Verification (SPV) or light nodes don’t store the full blockchain. Instead, they download only block headers and rely on full nodes to retrieve transaction data. SPV nodes are commonly used in mobile wallets and applications where full verification is unnecessary or resource-intensive.

3. Miner Nodes

These are specialized nodes that contribute computational power to validate transactions and create new blocks. While all miner nodes are full nodes, not all full nodes are miners. Mining nodes solve complex mathematical problems as part of the consensus mechanism (e.g., Proof of Work) to add new blocks to the blockchain.

4. Masternodes

Some blockchains, like Dash, use masternodes—full nodes with enhanced responsibilities such as enabling instant transactions or private transfers. Masternodes often require staking a significant number of coins to operate and receive rewards in return.

5. Archive Nodes

Particularly in networks like Ethereum, archive nodes store everything that full nodes do, plus all intermediate states. While not essential for most users, archive nodes are crucial for network analytics, debugging, and forensic applications.

Why Nodes Matter

Nodes are vital to decentralization. Without nodes distributed across multiple jurisdictions and operated by diverse participants, a blockchain risks becoming centralized and vulnerable to control or censorship. Nodes also play a crucial role in ensuring the network is fault-tolerant and resilient to attacks or outages.

Furthermore, nodes are essential for maintaining consensus. By independently validating and broadcasting transactions and blocks, nodes ensure that all participants have a consistent view of the blockchain’s state.

Setting Up a Node

Running a node involves downloading the appropriate blockchain client software, syncing with the network, and allocating sufficient resources (CPU, memory, and storage). While this may sound daunting, improvements in hardware and software have made it more accessible than ever to run your own node—even on a virtual private server or cloud infrastructure.

For a more detailed guide on what blockchain nodes are and how they function, check out this comprehensive article on blockchain nodes.

Summing Up

Blockchain nodes are foundational to the operation and security of decentralized networks. Understanding their technical roles helps demystify the architecture of blockchains and empowers individuals to participate more actively—whether as users, developers, or operators. As blockchain technology continues to mature, nodes will remain a cornerstone of decentralized digital infrastructure.

Llama is an open-source pre-trained LLM released by Meta which can be used to run ChatGPT like prompts locally on CPU or GPU. Llama comes in different sizes like 1B parameters, 8B, 70B and 405B. The capability of the LLM increases with the number of parameters. This is preferred to OpenAI API because using Llama locally gives more native support.

The 8B variant of LLM performs reasonably well and can ask moderate level questions and write simple code as well. This is something 1B variant cannot perform.

LLMs are usually too large to run on CPU due to limited memory and compute power and GPU are expensive.

If you wish to test Llama on a CPU server due to budget limitations, you can test Llama 3.1 8B model on DigitalOcean CPU droplet with a nominal cost of $86 per month. On the other hand, using a NVIDIA GPU on DigitalOcean to run it or larger versions of Llama 3.1 or 3.3 may cost over $90 per day (30X more).

In this guide at OpenGenus.org, we present the steps to setup the minimum required DigitalOcean CPU droplet, download Llama3.1-8B-Instruct model, prepare the script to run it on a sample input and generate the output. The computation time can vary from 2 to 10 minutes (or beyond) depending on the input prompt length.

Table of contents:

• Minimum requirements to run Llama3.1-8B
• Minimum DigitalOcean CPU droplet needed
• Steps to prepare your droplet to run Llama on CPU
• Script to run LLM with an input prompt
• Run the LLM script on CPU

Minimum requirements to run Llama3.1-8B

Minimum requirements to run Llama3.1-8B or any LLM:

• 16GB RAM required for 4096+ tokens to be run.
• Llama3.1-8B requires a minimum of 10GB RAM to load into memory. This involves KV cache. With the lower cache, the model fails to perform inference.
• SSD memory of 20GB (Llama3.1-8B Model files are of 16.4GB)

Minimum DigitalOcean CPU droplet needed

Specification of the most economical DigitialOcean CPU droplet required to run Llama 3.1 8B model:

• Machine type: Basic
• CPU type: Premium AMD
• vCPUs: 4
• RAM: 16GB
• SSD: 80GB
• Transfer: 8TB
• Price: $84 per month (As of May 2025)

Once the plan is acquired, an IP Address is assigned and you have to set the password.

Steps to use your droplet to run Llama on CPU

Install MobaXTerm

• Install the free version of MobaXterm to connect to the DigitalOcean droplet using terminal.

• Click on new Session

• Select the SSH Client type
  
  

  Figure: MobaXterm: SSH client

• Enter the IP Address in the Remote Host field and the username as got from DigitalOcean.
  
  

  Figure: MobaXterm: IP address and userame

• Now the Session is created

• Enter the password in the terminal to run the model.

Get access of Llama3.1-8B from Meta

Llama is a series of LLM from Meta (formerly known as Facebook).

• Request Access to Llama3.1 from Meta
• Once the Request is approved, the unique URL will be shared through email.
• Install Llama CLI:

pip install llama-stack

• To check the available models run

llama model list

Output:

• The model that we have to download is Llama3.1-8B-Instruct.
• Use the following command to install the model

llama download --source meta --model-id Llama3.1-8B-Instruct

• Now you have to provide the unique URL sent by Meta through email

Get access from HuggingFace

Since Llama3.1-8B is a gated repository, you have to get access from HuggingFace.

Fill in the above details:

• To check for approval updates, click on your HuggingFace profile then go to settings -> gated repository
  
  

  Figure: HuggingFace: request status accepted

• Once accepted, go to access tokens
  
  

  Figure: HuggingFace: access token

• Create a new token
  
  

  Figure: HuggingFace: create new token

• Fill in the details and select all the user permissions
  
  

  Figure: HuggingFace: user permissions

• Save the access token for later use (Note: this is a sample which we have deleted. You need to create your own token).
  
  

  Figure: HuggingFace: save token

Install necessary libraries

Install pip:

sudo apt install python3-pip -y

Install Huggingface, Transformers, Torch, Accelerate:

pip install huggingface_hub
pip install transformers
pip install torch
pip install accelerate

Script to run LLM with an input prompt

• Create a file named "prompt.py":
  
  
  Figure: LLM script

Following is the code to start inference of your LLM (we will go through the explanation of the code following it):

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "meta-llama/Llama-3.1-8B-Instruct"

# Load tokenizer and model
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

prompt = """<|begin_of_text|><|start_header_id|>system<|end_header_id|>

Environment: ipython<|eot_id|><|start_header_id|>user<|end_header_id|>

Write code to check if number is armstrong, use that to see if the number 153 is armstrong<|eot_id|><|start_header_id|>assistant<|end_header_id|>
"""

# Tokenize and move to model device
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

# Generate the model's response
outputs = model.generate(
    inputs.input_ids,
    max_new_tokens=128,
    do_sample=True,
    temperature=0.7,
    top_p=0.9
)

# Decode and print only the model's answer
response = tokenizer.decode(
    outputs[0][inputs.input_ids.shape[-1]:],
    skip_special_tokens=True
)
print(response)

Explanation of the script

In short, the code prompts Llama 3.1 8B to generate a program to check if the number 153 is an Armstrong number. The process involves tokenizing the input, feeding it to the model and decoding the generated response to print it.

This code is using the HuggingFace transformers library to interact with the LLM to generate a response for a programming task. Following is the step by step explanation:

• Imports
  AutoTokenizer and AutoModelForCausalLM are classes from the HuggingFace transformers library. The AutoTokenizer is used to handle tokenization (converting text into input suitable for the model), and AutoModelForCausalLM is used to load the language model (in this case, for causal language modeling, which generates text based on a prompt).

torch is the PyTorch library, used for managing tensors and running models on devices like CPU or GPU.

• Model ID
  model_id = "meta-llama/Llama-3.1-8B-Instruct" specifies which model to load. It refers to a specific pre-trained model called Llama 3.1 with 8 billion parameters.

• Load Tokenizer and Model
  The tokenizer is loaded from the specified model, which prepares the text for the model. The model is loaded with torch_dtype=torch.bfloat16 (which reduces memory usage and improves speed on supported hardware), and device_map="auto" automatically places the model on the available device (CPU or GPU).

• Prompt
  A prompt is defined which contains a system instruction (environment: ipython) and a user request to write a program to check if the number 153 is an Armstrong number. The format uses special tokens like <|begin_of_text|> to mark different sections.

• Tokenize Input
  The prompt is tokenized (converted into numerical representations) and sent to the model's device.

• Generate Model Response
  The generate method is used to generate the model's response based on the provided input. In this case, it generates up to 128 new tokens with sampling controls (temperature=0.7 and top_p=0.9) to control the randomness and creativity of the response.

• Decode and Output the Response
  The output tokens from the model are decoded back into text, skipping any special tokens used for processing.

Run the LLM script on CPU

Login into HuggingFace
Run the following command:

huggingface-cli login

Now enter the access token

• For access to git credentials, select "no".
• Once login is successful, we will run the Python script.
  

Run the command:

python3 prompt.py

Output:

Testing is possible in CPU, but once script is ready and you have tested on CPU with patience, you can switch to GPU to compute faster on larger number of prompts.

The book "C++: Coding Cheatsheet: GOAT edition" is the only book you need to master C++ programming concepts. The focus is on practical programming skills, design concepts and performance engineering ideas.

GOAT = "Greatest Optimizations, Abstractions and Techniques"

Read C++ Coding Cheatsheet: GOAT edition here for free

This book include:

• Chapters covering all core concepts in C++ programming, code design and optimization including:
  • OOP concepts, Inheritance, Composition, Singleton pattern
  • Efficient use of C++ STL for DSA
  • and much more.
• Each chapter is a CHEATSHEET. It includes to-the-point explanation and relevant code snippets.
• Each concept can be covered quickly in at most 4 minutes.

With this, you will be able to crack any Coding Interview easily.

After reading this book, you will:

• Master C++ programming concepts. Have a strong mental model equivalent to programming at least 10K lines of C++ code.
• Strong implementation skills to optimize for performance.
• Clear interviews for full-time positions at high-tech companies.

This book is for:

• Students and developers preparing for Coding Interviews with C++ as their primary programming language.
• Experienced developers who wanted to revise their C++ concepts.
• Students who need a coding sheet to revise C++ topics quickly.

Get started with this book and change the equation of your career.

Book: C++: Coding Cheatsheet: GOAT edition
Authors (1): Wesley Kincaid
Published: March 2025 (Edition 1)

The book "Deep Learning: DL1943 Cheatsheet: DL/AI/ML Research, Engineering, Optimization & System Design" is the only book you need to master Deep Learning (DL) concepts.

Read the book for free: HERE

Get your printed book copy of DL1943 Cheatsheet

This book include:

• Chapters covering all core concepts in DL research, engineering and optimization including:
  • Basic concepts like Perceptron, Gradient Descent
  • All basic terms like epoch, topK and basic ops like MaxPool
  • Core techniques like INT8 Quantization
  • Deep Learning System Design (with examples)
  • Numerical Analysis concepts like INT32 IEEE754, emulating FP64 using FP32.
  • Optimization techniques across:
  • Assembly instructions like AVX512 VNNI
  • Algorithmic optimizations for DL operations like MatMul
  • Graph level operations
  • and much more.
• Each chapter is a CHEATSHEET. It includes to-the-point explanation and relevant code snippets.
• Each concept can be covered quickly in at most 4 minutes.
• Over 350 DL/AI concepts have been covered.

With this, you will be able to crack any Deep Learning Coding Interview easily.

After reading this book, you will:

• Master Deep Learning/ Artificial Intelligence.
• Clear interviews for full-time positions at high-tech companies. Good enough for:
  • Software Engineer 2/3, Machine Learning or Senior Software Engineer, AI/ML GenAI or ML Analyst at Google (L3/L4/L5)
  • Software Engineer, Machine Learning (E4/E5/E6) at Meta
  • Senior Deep Learning Systems Software Engineer - AI or AI Developer Technology Engineer at NVIDIA
  • Kernel Software Engineer - AI/ML GPU or Senior Machine Learning Software Engineer at AMD
  • Lead Engineer, Senior-C/C++, machine learning at Qualcomm
  • Machine Learning Engineer at Microsoft (Level 60 to 66)
  • And much more.

This book is for:

• Students and developers preparing for Coding Interviews specifically for Machine Learning/Deep Learning/GenAI positions.
• Experienced developers who wanted to revise their Deep Learning skills.
• Students who need a coding sheet to revise DL/AI/ML topics quickly.

Get started with this book and change the equation of your career.

Book: Deep Learning: DL1943 Cheatsheet: DL/AI/ML Research, Engineering, Optimization & System Design
Authors (2): Calder Reed, Chen Hui Fang
Published: February 2025 (Edition 1)

Introduction

In a previous article, we introduced the concept of cyber-physical systems (CPS). Moving further in our journey into CPS, agent is a term we will be encountering quite a lot. So let's get that off our plate first. Simply put, an agent is an autonomous entity that navigates through a given environment.

In the context of CPS, we can think of an agent as an entity that interacts with the environment in a manner defined by its hybrid automaton. Consider the bouncing ball example we discussed previously. Here, the ball can be though of as the agent, and the nature of its interactions with the environment, such as free fall and rebounding off the ground, is defined by the hybrid automata of the system.

Clearly, so far we've been only talking about single-agent systems - where the hybrid automaton describing the agent's behaviour is as good as describing the entire system itself. However, as we attempt to model complex systems in the real world, we shall soon find that in most cases a single agent will not suffice.

As such, we must talk about multi-agent CPS, where the behaviour of each agent (their interactions with the environment, which comprises mainly of the other agents) is described by their own individual hybrid automaton. Then, if we wish to study the system as a whole, we must look at the collective behaviour that emerges out of these individual hybrid automata. In order to do this, we must take the help of compositional hybrid automata (CHA).

And what is a compositional hybrid automaton?

Now that we are familiar with the language of hybrid automata, let us define a multi-agent CPS by describing a couple of hybrid automata - each representing a single agent in the system:

What does this system do? In order to understand the behaviour of the system as a whole, it is beneficial to talk first about the individual agents: the water tank, the burner, and the thermometer.

The tank initially has a constant temperature x of 20 degrees Celsius (location t4). Only if the burner is turned on (transition ON), the temperature will start to increase as the water starts heating (location t1). There seems to be some mechanism that caps the upper temperature limit to 100 degrees, and when this limit is reached (transition B to location t2) the heating stops. However, the burner must then be turned off (transition OFF) for the water to cool down naturally (location t3). Of course at any point during heating or cooling, we can turn the burner off or on to transition between locations t1 and t3. The dynamics for the tank is described by the hybrid automaton H1.

The burner is initially switched off (location b1). When it is switched on (transition TURN-ON to location b2) it takes about 0.1 seconds time y to actually start the heating process (transition ON to location b3). Similarly, when it is switched off (transition TURN-OFF to location b4) it takes about 0.1 seconds time y to actually stop the heating process entirely (transition OFF to location b1). The dynamics for the burner is described by the hybrid automaton H2.

Note. The ON and OFF transitions in the tank automaton have the same label as the ON and OFF transitions in the burner automaton. This is completely intentional, and this is how the agents communicate with each other. For example, when the burner sends an ON signal to the tank, only then the water in the tank actually starts heating. This is known as label synchronization. A multi-agent CPS may or may not exhibit label synchronization.

The thermometer is much simpler: it continuously measures the water temperature x and sends periodic signals at an interval of 0.1 seconds about whether the temperature is lower than 93 degrees (transition DW93), above 95 degrees (transition UP95) or somewhere in between (transition ε), based on which the managers of the water heating plant can manually switch off the burner if needed. The dynamics for the thermometer is described by the hybrid automaton H3.

Note. The variable x of the thermometer automaton is the same as the variable x of the tank automaton, so that the thermometer can be used to directly monitor the water temperature of the tank. This is another way for the agents to communicate with each other and is known as shared variables. A multi-agent CPS may or may not exhibit shared variables.

When considered together, these three components completely describe the entire system. Naturally, a question arises as to why not use a single automaton to H to describe the system. Of course we can do this, but this comes with a cost. Take a look at how the automaton H looks like based on our descriptions of H1, H2 and H3:

This is a complete mess and does not seem human-readable at all. Indeed we must use this hybrid automaton H in the backend when we are, say, mathematically verifying the safety specifications of the system. However, when we are describing the system itself, we are much better off describing the individual components each as a hybrid automaton. This is exactly where CHA comes in.

In this framework, we describe each agent (component) in our system as a hybrid automaton and the entire system can then be studied using the single automaton of the system which we showed above. This automaton is known as the CHA of the system, and is obtained by a mathematical operation known as composition (which we denote by the symbol '.'), from where CHA gets its name.

So how do I compose hybrid automata?

Of course, talking about the composition of the three hybrid automata into a single CHA seems daunting, but don't worry! The '.' operation is commutative as well as associative, which means that we can start with any two components of our choice and go on composing recursively, always ending up with the same final CHA! How does this help? Well, let us consider the tank and the thermometer first. Once we understand how to compose H1 and H3 to get (H1.H3), we can simply compose H2 and (H1.H3) to get H = H1.H2.H3 = H2.(H1.H3) without any ambiguity.

This is where the fun begins. At the heart of automata composition is a graph operation known as the product of two graphs. Generally speaking, graph products are binary operations on graphs which input two graphs to create a new graph. The vertex set of the new graph is the Cartesian product of the vertex sets of the input graphs, while the edge set is constructed via some rule. We are particularly interested in strong products. We'll talk about them in a bit. Before that, let us revisit the concept of Cartesian product of two sets. Given two sets, their Cartesian product is defined as all possible ordered pairs that can be formed by selecting one element from the first set and another element from the second.

A classic example of Cartesian products is the standard deck of 52 cards. The ranks {A, K, Q, J, 10, 9, 8, 7, 6, 5, 4, 3, 2} form a 13-element set. The card suits {♠, ♥, ♦, ♣} form a four-element set. Ranks × Suits returns a set of the form {(A, ♠), (A, ♥), (A, ♦), (A, ♣), (K, ♠), ..., (3, ♣), (2, ♠), (2, ♥), (2, ♦), (2, ♣)}. Suits × Ranks returns a set of the form {(♠, A), (♠, K), (♠, Q), (♠, J), (♠, 10), ..., (♣, 6), (♣, 5), (♣, 4), (♣, 3), (♣, 2)}. Since the order of elements in the pair are irrelevant in our case, these two products are bijective (that is, can be treated as one and the same), and can be expressed as {{A, ♠}, {A, ♥}, {A, ♦}, {A, ♣}, {K, ♠}, ..., {3, ♣}, {2, ♠}, {2, ♥}, {2, ♦}, {2, ♣}}.

Similarly, let us consider two directed graphs as follows:

The vertex sets of the two graphs are given as {1, 2, 3, 4} and {5}. The Cartesian product of the two sets is given as {{1, 5}, {2, 5}, {3, 5}, {4, 5}}. This is the vertex set of the graph product. For strong products, an edge exists between vertices {u, u'} and {v, v'} if and only if either of the following conditions are met:

• u = v and u' is adjacent to v', or
• u' = v' and u is adjacent to v, or
• u is adjacent to v and u' is adjacent to v'.

Following these rules, the strong product for the given two graphs will look like this:

Note. There are several other kinds of graph products based on what rule is being used to construct the edge set. One such product is the lexicographic product, which confusingly enough is also called graph composition. Don't get confused though; strong products are but a special case of graph composition - all strong products are graph compositions but all graph compositions are not strong products.

Let us now return to the subject of hybrid automata composition. In our discussion of strong products, we talked about taking the Cartesian product of the two graphs as the vertex set of the new graph. But in case of hybrid automata, it's not just about the graph structure anymore. Each location in an automaton also has its own flow and invariant. Aptly then, the flow/invariant of the product location is given as one where the flow/invariant of both the constituent locations hold.

Similarly, each transition has a guard and an assignment. In cases where one location in the pair is fixed and the other is undergoing the transition, the guard/assignment of the transition in the CHA is same as the guard/assignment of the corresponding transition in the input automaton. In cases where both the locations are undergoing a transition, the guard/assignment of the product transition is given as one where the guard/assignment of both the constituent transitions hold.

In case of the inits, the init of the CHA is similarly given as one where the inits of both the components hold. The initial location {u1, u2, ..., uk} for the CHA H1.H2...Hk is chosen such that u1 is the initial location of H1, u2 is the initial location of H2 and so on.

As an example, let us finally take a look at the composition H1.H3, which we are now well-equipped to understand:

Similarly, the chaotic mess that is H = H1.H2.H3 should hopefully make a bit more sense to you now.

Why do you think it seems reasonable to use strong products for the composition of hybrid automata?
(Hint: Think about the simulation of a two-agent CPS. Each agent is moving autonomously in the system following their hybrid automaton. At any point in time, the state of the CHA can be given by looking at the states of the components simultaneously.)

Um... where's the code?

CHA is not a easy affair. Different authors define it in a slightly different manner. The fringe cases are particularly heavily debated. For example, HyST (Hybrid Source Transformer/Translation) is a tool developed by Bak et al. that provides a framework for working with hybrid automata, including a flatten transformation pass for automata composition. While HyST allows composition in cases where inits, invariants or guards are unsatisfiable, it does not in cases where flows or assignments are unsatisfiable.

In the previous article, we already talked about the Verse library and how it makes the modelling of CPS accessible. Verse is extremely capable when it comes to multi-agent systems, but it also ships with certain limitations - such as all agents requiring the same state, and lack of support for shared variables. As such, implementing the tank-burner-thermometer system in Verse is complicated to the point of near-impossibility. However, the model editor tool of SpaceEx provides a GUI interface for this and is suited for modelling this system.

In the upcoming article, we discuss about robot swarms as multi-agent CPS. Verse proves its mettle such scenarios, and therein we discuss in detail how to implement a swarm of robots in Verse.

Note. It is important to distinguish between homogeneous multi-agent CPS and heterogeneous multi-agent CPS in this context. Homogeneous multi-agent CPS consists of agents of the same type, characterized by a single component hybrid automaton (with the same underlying structure) - for example, a swarm of robots. Heterogeneous multi-agent CPS, on the other hand, consists of agents of different types, characterized by several different component hybrid automata in the system - as was the case in our tank-burner-thermometer CPS.

Conclusion

To sum up, in this article at OpenGenus, you learnt:

• what a multi-agent CPS is,
• how we model multi-agent CPS using compositional hybrid automata (CHA),
• how we compose several components into a single CHA, and
• challenges of modelling heterogeneous multi-agent CPS in Verse and how SpaceEx excels in this.

In the future, we will explore homogeneous multi-agent CPS in greater detail.

PyTorch is one of the most popular Deep Learning (DL) libraries today, thanks to its flexibility and ease of use. However, the extensive range of its features can sometimes lead to confusion, especially when two functions appear to have overlapping purposes. This is the case with torch.Tensor.max and torch.max, two methods that allow users to find maximum values in tensors. So, why does PyTorch provide two different ways for a similar operation? This article aims to clarify their differences, explore their use cases, and help you make an informed choice.

Why Two Functions for Maximum?

PyTorch offers two ways to find maximum values in a tensor because they address different needs:

• torch.Tensor.max is an instance method that applies directly to a torch.Tensor object and is mainly used to find maximum values within a single tensor.
• torch.max is a module-level function used to compare two tensors element-wise.

These two functions, therefore, offer specific possibilities that cater to different scenarios. Let’s examine each in detail.

1. Understanding torch.Tensor.max

Description and Syntax

torch.Tensor.max is an instance method that applies directly to a torch.Tensor object. Its syntax is as follows:

tensor.max(dim=None, keepdim=False)

• dim (int, optional): The dimension along which to find the maximum value. If no dimension is specified, the method returns the maximum value across the entire tensor.
• keepdim (bool, optional): If True, retains the original dimension in the output tensor. This is useful for keeping the tensor structure intact.

Use Cases of torch.Tensor.max

This method is ideal when you want to:

1. Find the overall maximum value in a tensor.
2. Obtain both the maximum value and its index along a specific dimension.

Example

Consider a 2D tensor:

import torch

# Create a 2D tensor
tensor = torch.tensor([[1, 5, 3],
                       [2, 4, 6]])

# Find the maximum across the entire tensor
max_value = tensor.max()
print(f"Maximum value in the entire tensor: {max_value}")

# Find the maximum value along each row
max_values, indices = tensor.max(dim=1)
print(f"Maximum values by row: {max_values}")
print(f"Indices of maximum values: {indices}")

Output:

Maximum value in the entire tensor: 6
Maximum values by row: tensor([5, 6])
Indices of maximum values: tensor([1, 2])

In this example, we find the global maximum (6) and also the maximum values by row by specifying dim=1.

2. Exploring torch.max

Description and Syntax

torch.max is a module-level function that compares two tensors element-wise, returning a new tensor containing the maximum values at each position. The syntax is:

torch.max(input, other)

• input: The first tensor.
• other: The second tensor (must have the same shape as the first).

Output:

Tensor with maximum values at each position:
tensor([[2, 5, 4],
        [2, 5, 6]])

3. Comparing the Two Methods

When to Use torch.Tensor.max?

If you need to extract the maximum value within a single tensor, whether across the entire tensor or along a specific dimension.
When you need to retrieve the index of the maximum value along a specified dimension.

When to Use torch.max?

If you want to perform an element-wise comparison between two tensors and retain the maximum value for each position.
Ideal for cases like merging tensors from two sources while keeping the highest values at each position.

Performance and Code Readability

Choosing the appropriate method is important not only for optimization but also for code readability. Using torch.Tensor.max for a two-tensor comparison would require additional steps and make the code more complex.

Conclusion

In summary of this OpenGenus article, PyTorch offers both torch.Tensor.max and torch.max to meet specific needs. torch.Tensor.max is your choice for operations within a single tensor, while torch.max is ideal for element-wise comparisons between two tensors. These distinctions, though subtle, are essential for writing efficient and clear code.

Introduction

Put in simple terms, a cyber-physical system (CPS), as the name suggests, is a dynamical system that exhibits both discrete (cyber) and continuous (physical) dynamic behavior. Due to their distinct mixed discrete-continuous dynamics, they are also known as hybrid systems.

We model such systems using mathematical structures aptly named hybrid automata. Let us now look into these structures to get a deeper understanding of what a CPS is.

What exactly is a hybrid automaton?

Consider as an example of CPS a bouncing ball. Any object under the influence of gravity will certainly act according to the laws of Newtonian mechanics, which are given by ordinary differential equations (ODE). If the ball in question has a height x and a velocity v, and we assume the acceleration due to gravity to be g, we can then come up with a set of ODEs for the ball's physics:

• x' = v
• v' = -g

One more thing to keep in mind is that the value of x can never be negative, because a negative height does not make sense. This condition is always true, and is known as the invariant of the continuous state defined by the aforementioned flow.

Nothing too fancy, right? Let us name this state as B1. This set of ODEs is then known as the flow of the state, which is sufficient to describe the continuous dynamics of the state. The set of all such states (locations) together with their flow defines the continuous dynamics of the system. In our case, there is only one location.

Note. The nature of flow in a hybrid automaton is often used to classify hybrid automata into different classes. The example we are dealing with has a set of linear ODEs as its flow, hence is known as a linear hybrid automaton (LHA). If the flows are given by a set of affine ODEs, we call it an affine hybrid automaton (AHA), or more generally, a nonlinear hybrid automaton (NHA).

Now, consider the case when the ball hits the ground. Obviously, the ball will bounce back with a reduced velocity based on some dampening coefficient, which we denote by c. This c depends upon several factors such as the hardness of the surface, the air resistance, and so on, but let us not get into that mess.

In other words, when x reaches 0 value and velocity is in the downward direction, then the ball bounces back with a reduced velocity cv in the opposite direction. Mathematically, we express this as

• When x <= 0 && v < 0, then set v to -cv (where 0 < c < 1).

Let us call this discrete event as rebound. This is an example of a jump, which checks for a guard condition (x <= 0 && v < 0) which, when met, triggers an assignment, namely setting v to -cv. The set of all such jumps together defines the discrete dynamics of the system. In our case, there is only one jump.

Note. We define the guard condition as x <= 0 instead of x == 0. This is because computers can't really handle continuous dynamics, and any ODE computation must be done in very tiny discrete steps, creating an approximation of continuity. As such errors may often creep up, resulting in x jumping from a very negligible positive value to a very negligible negative value instead of actually hitting zero.

All of this looks too verbose. So we must find some way to represent all of this more compactly. This is exactly where the hybrid automata comes in. One can think of hybrid automata as a finite state automata with each state having its own set of ODEs to describe different continuous dynamics that the system can attain, while the state transitions describe the discrete dynamics in the system.

Consider the following diagram:

This diagram represents every information we just covered, while noting that the ball was dropped from a height h without applying any additional force (free fall under gravity). This is known as the init or initial condition. We also observe that the execution of the automaton begins at B1, which is our initial location.

Of course, this is a very simplistic example with a single location B1 and only two variables. In real world, we often deal with complex CPS which may contain tens of locations and hundreds of variables.

Note. At x = 0, both the invariant of B1 and the guard of the transition Rebound is satisfied. As such, the automaton has a choice to either dwell in the location B1 until the invariant is no longer satisfied, or take the transition. This introduces nondeterminism in the system, but we won't be getting into that today.

Okay, I get it. Now give me some code!

I'm glad you asked. Let us code this simple bouncing ball example in Python. We will use networkx for implementing the discrete structure and store the continuous dynamics as a set of strings.

import networkx as nx

''' Must use digraphs to model the discrete structure
because having a transition A -> B does not mean
we also have the transition B -> A '''

G = nx.DiGraph()
G.add_node('B1')
G.add_edge('B1','B1',label="Rebound")

''' Now let us add the dynamics as meta-data.
Let c be 0.7 and g be the usual 9.8. '''

loc_dict = {} # Stores flow and invariant for each location
flow = ["x'=v", "v'=-9.8"]
inv = "x>=0"
loc_dict['B1'] = (flow, inv)

trans_dict = {} # Stores guard and assignment for each transition
guard = "x<=0 && v<0"
asgn = "v=-0.7*v"
trans_dict["Rebound"] = (guard, asgn)

''' Let us add the initial conditions, assume h = 10'''
init = ["x=10", "v=0", 'B1']

In order to execute (simulate) the hybrid automaton in question, we must have some mechanism to parse these expressions and pass them to some ODE solver, which will solve these and give solutions. All that and we haven't even implemented the invariant anywhere in our code yet. This added complexity makes the entire affair extremely cumbersome.

Ah, great. What do we do then?

Of course one could go about implementing their own hybrid automata library, but several great ones already exist. The industry standard is SpaceEx (not to be confused with Elon Musk's SpaceX) which was developed by the VERIMAG lab of the University of Grenoble.

SpaceEx provides a standardized format to describe hybrid automata as .xml files and implements a tool to parse and execute these files. One can write their own CPS in the easy-to-understand .xml format and run them using SpaceEx. Alternatively, one can also use the SpaceEx model creator, a GUI CPS modelling tool for the more visually inclined.

A more flexible library indeed exists in Python itself called Verse, which was developed by the Reliable Autonomy Group at the University of Illinois Urbana-Champaign and funded by NASA. Verse not only makes the modelling of CPS intuitive but also allows users to design custom algorithms for verifying safety properties in such systems. For a taster, here's how one would model the bouncing ball example in Verse.

The continuous dynamics:

from verse.plotter.plotter2D import *
from verse import Scenario, ScenarioConfig
from enum import Enum, auto

class BallAgent(BaseAgent):

    def __init__(self, id, code=None, file_name=None):
        super().__init__(id, code, file_name)

    # Define the flow
    def dynamics(self, t, state):
        x, v = state # Get the continuous variable values at that step
        dxdt = v
        dvdt = -9.8
        return [dxdt, dvdt]

The discrete dynamics:

# Define the continuous and discrete variables
class BallMode(Enum):
    B1 = auto()

class State:
    x = 0.0
    v = 0.0
    mode: BallMode

    def __init__(self, x, v, ball_mode: BallMode):
        pass

# Define the transitions
def decisionLogic(ego: State):
    c = 0.7
    output = copy.deepcopy(ego)
    if ego.x <= 0: # Guard condition
        output.vx = -ego.vx*c # Assignment
        output.x = 0 # Assignment
    assert all(ego.x >= 0), "No negative height" # Invariant
    return output

And we would simply execute the hybrid automaton as follows:

if __name__ == "__main__":
        # Initialize a scenario and set the decision logic (discrete dynamics)
        bouncingBall = Scenario(ScenarioConfig(parallel=False))
        myball = BallAgent("ball", file_name="./bouncing_ball.py")
        bouncingBall.add_agent(myball)
        
        # Set the initial conditions
        bouncingBall.set_init([[[10, 0]], # Lower bound for init x, v
            [[10, 0]], # Upper bound for init x, v
            [(BallMode.B1)]) # Initial location 

        # Simulate for 40 seconds, where ODE computation is done every 0.01 seconds
        traces = bouncingBall.simulate_simple(40, 0.01)
        
        # Print the trajectory (x vs. t graph)
        fig = go.Figure()
        fig = simulation_tree(traces, None, fig, 0, 1, [0, 1], "fill", "trace")
        fig.show()

And that's it! Upon simulation, we would get a trajectory similar to this:

Take a moment to ponder on that. Why do you think the trajectory looks like this?

Note. Verse's framework is designed for multi-agent CPS (more on that in the future) and offers an alternative way to model CPS than hybrid automata. However, the framework is designed in such a way that every agent in Verse (such as our ball agent) will have an equivalent hybrid automaton, and vice versa. As such, Verse can be effectively used to model, simulate and verify any given hybrid automaton.

But what is it good for?

Excellent question! CPS are found everywhere - in highly autonomous vehicles (think Tesla's self-driving cars and NASA's unmanned satellites), robotics and telecommunication networks, distributed realtime systems, distributed artificial intelligence, surveillance systems, industrial control systems, power systems and smartgrids, coordinated defence systems, and healthcare.

In fact, most of these use cases are often safety-critical, where ensuring the operational correctness is absolutely necessary. Consider, for example, autonomous vehicles, insulin infusion pumps, and so on. Therefore, the formal verification of these system becomes a critical area of study in theoretical computer science and control theory.

Conclusion

To sum up, in this article at OpenGenus, you learnt:

• what a cyber-physical system (CPS) is,
• how we model CPS using hybrid automata,
• how to code your own hybrid automata in Python, and
• application domains of CPS.

In the future, we will dive deeper by exploring more complex types of CPS.

Let me give you a rough idea of containerization metaphoricaly. Imagine living in a house with no rooms, utter chaos and no privacy, where everything blends together. Horrible right! Now, picture introducing rooms: suddenly, life feels organized and beautiful!(yes privacy too!) Similarly, containerization brings order to software development, creating isolated environments for applications. This way, chaos transforms into efficiency and clarity, making it easier to manage, deploy, and scale applications.

In a general computing environment, processes share the same set of resources, creating potential conflicts and challenges in resource management. In this scenario, processes share a common namespace, leading to a lack of isolation and independence. Resource conflicts, such as two processes trying to access the same memory address or conflicting file access, can result in unstable and unpredictable behavior.

Containerization is essential in modern software development and deployment due to its benefits: isolation, portability, resource efficiency, scalability, faster deployment, enhanced security, and more. In this article, we will explore the core technologies behind popular containerization software like Docker, Kubernetes, and Podman, as well as notable cloud providers.

How does containerization work?

Containerization uses specific features of the Linux kernel to create isolated environments for running applications. For eg this is what Docker states on their website:-

Docker uses a technology called namespaces to provide the isolated workspace called the container. When you run a container, Docker creates a set of namespaces for that container.

Docker employs Linux namespaces, cgroups, and seccomp Linux features, and this is also true for other well-known container technologies. The core concepts and components involved are namespaces, control groups (cgroups), chroot, and union file systems. In this article, we will focus on Linux namespaces.

Linux Namespaces: What are they?

Linux namespace is a fundamental linux kernel feature that enables the isolation of resources within a system. Currently, Linux implements six different types of namespaces. The purpose of each namespace is to wrap a particular global system resource in an abstraction that makes it appear to the processes within the namespace that they have their own isolated instance of the global resource. Here’s what the man pages say about namespaces:

A namespace wraps a global system resource in an abstraction that
makes it appear to the processes within the namespace that they
have their own isolated instance of the global resource. Changes
to the global resource are visible to other processes that are
members of the namespace, but are invisible to other processes.
One use of namespaces is to implement containers.

Linux supports six distinct namespace types. By wrapping a specific global system resource in an abstraction, each namespace aims to provide the impression that the processes running inside it have their own isolated instance of the global resource. Process IDs, file system mount points, network interfaces, IP addresses, routing tables, firewall rules, hostnames, NIS domain names, and so forth are examples of global resources.

Given below is the table from man pages of namespaces showing the types:-

Understanding PID Namespaces

I will delve further into pid namespaces and provide a basic code output in this post to help readers grasp isolation and gain a clear idea of how namespaces function.
According to the manpages:-

PID namespaces isolate the process ID number space, meaning that
processes in different PID namespaces can have the same PID. PID
namespaces allow containers to provide functionality such as
suspending/resuming the set of processes in the container and
migrating the container to a new host while the processes inside
the container maintain the same PIDs.
PIDs in a new PID namespace start at 1, somewhat like a
standalone system, and calls to fork(2), vfork(2), or clone(2)
will produce processes with PIDs that are unique within the
namespace.

To explain this better I have attached a picture:

A Process ID (PID) is a unique numerical identifier assigned by the operating system to each running process. It allows the system to distinguish between different processes, hence manage and track processes effectively. Linux establishes a single init pid_namespace by default, and all processes live inside of it. It is possible for processes to generate a new pid_namespace and assign their child processes to it. The new pid_namespace inherits the parent pid_namespace as a child. In a new pid_namespace, the PID number begins with 1.

• Processes are assigned unique numbers in the parent (init) namespace.
• In a child namespace, processes have PID as 1, 2, 3, while the parent sees them as PID 4, 5, 6.
• If a grandchild namespace is created from a process(in fig process ID 1) in the child namespace, processes there will also see their PIDs starting from 1, while the parent namespaces see them as higher-numbered PIDs.

Experiment

To demonstrate the above concept here is the code in C below. This C program illustrates how to create a new PID namespace and run a child process within that namespace. :-

#define _GNU_SOURCE
#include <sched.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <signal.h>
#include <stdio.h>

/* A simple error-handling function: print an error message based
   on the value in 'errno' and terminate the calling process */

#define errExit(msg)    do { perror(msg); exit(EXIT_FAILURE); \
                        } while (0)

static int              /* Start function for cloned child */
childFunc(void *arg)
{
    printf("childFunc(): PID  = %ld\n", (long) getpid());
    printf("childFunc(): PPID = %ld\n", (long) getppid());

    char *mount_point = arg;

   printf("Programme done");
    execlp("sleep", "sleep", "600", (char *) NULL);
    errExit("execlp");  /* Only reached if execlp() fails */
}

#define STACK_SIZE (1024 * 1024)

static char child_stack[STACK_SIZE];    /* Space for child's stack */

int
main(int argc, char *argv[])
{
    pid_t child_pid;

    printf("Parent Process: PID  = %ld\n", (long) getpid());
    printf("Parent Process: PPID = %ld\n", (long) getppid());

    child_pid = clone(childFunc,
                    child_stack + STACK_SIZE,   /* Points to start of
                                                   downwardly growing stack */
                    CLONE_NEWPID | SIGCHLD, argv[1]);

    if (child_pid == -1)
        errExit("clone");

    printf("PID returned by clone(): %ld\n", (long) child_pid);

    if (waitpid(child_pid, NULL, 0) == -1)      /* Wait for child */
        errExit("waitpid");

    exit(EXIT_SUCCESS);
}

Code explanation

In the above code, the childFunc() is the function executed by the child process created in the new PID namespace. It does following work:-

• It prints the child’s PID and parent PID (PPID).
• It calls execlp to run the sleep command for 600 seconds. This replaces the current process image with the sleep program.
• If execlp fails, it calls errExit.

The parent process prints its own PID and PPID (main function). The clone function is called to create a new child process in a new PID namespace. The clone() system call creates a new process in a new PID namespace, taking following parameters:-

• childFunc: The function to run in the child process.
• child_stack + STACK_SIZE: Specifies the top of the stack pointer for the child (since the stack grows downwards). Stack and its size provided above main() function
• CLONE_NEWPID: flag to ensure the child gets its own PID namespace.
  SIGCHLD: Sends a signal to the parent when the child terminates.

If clone() succeeds, it returns the child's PID, which is then printed. The parent process waits for the child to complete using waitpid, ensuring proper cleanup before exiting.

Output

Compiling and running the program in bash gives:-

(yappye?? Yeah that's me 😁)

When the program runs, the parent process PID(process ID) ie 41 and PPID(parent process ID) ie 40 is printed initially in main() function. Next, after the child process is created using the clone function, the child process prints its own PID and PPID. From parent's namespace perspective child process ID appears as 42.
However, within the child namespace, the child process sees its PID as 1 and its PPID as 0.

This output demonstrates how PID namespaces provide isolation by allowing the same process to have distinct PIDs based on the namespace from which it is viewed. In the child namespace, the process ID begins at 1, similar to the behavior of a standalone system, yet the parent process sees it as 42 in its own namespace.

Additional Commands Run

1. The ps -ef command is a common way to display information about currently running processes in a Linux system.

ps -ef

Output

When we run ps -ef after executing the "pidns_init_sleep.c" program, you will see a list of all running processes, including the parent and child processes created by the program (shown by arrows).
We can observe in the output that the child process with PID 42 and PPID as 41, showing that it was spawned by the main program(./a.out). It runs the "sleep 600" command for 600 seconds.

2. The pstree -n command provides a visual representation of the process tree on a Linux system, showing the hierarchical relationship between processes.

pstree -n

Output

The output for above command before running the program.

The output for above command after running the program. We can observe the ./a.out program creating process "sleep"(child process).

Conclusion

To summarize, Linux namespaces, particularly PID namespaces, play an important role in containerization by isolating and independent processes. This allows numerous processes to coexist without interference, with the same PID in various namespaces. In this article we have covered only PID namespaces. In iupcomming article we will discover other namespaces too. Stay tuned!✌

Table of Contents

1. Introduction
2. Confidentiality
   • Definition
   • Protocols to Ensure Confidentiality
   • Attacks on Confidentiality
3. Integrity
   • Definition
   • Protocols to Ensure Integrity
   • Attacks on Integrity
4. Authentication
   • Definition
   • Protocols to Ensure Authentication
   • Attacks on Authentication
5. Availability
   • Definition
   • Protocols to Ensure Availability
   • Attacks on Availability

1. Introduction

Network security is a critical aspect of modern computer networks, ensuring the protection of data, systems, and resources from unauthorized access, damage, or disruption. As the amount of sensitive information transmitted over networks continues to grow, so does the need to safeguard it against various types of threats. The primary goals of network security include confidentiality, integrity, authentication, and availability. These goals work together to ensure that only authorized individuals can access data, that data remains unaltered during transmission, that the identities of users and devices can be trusted, and that network services are accessible when needed. To achieve these objectives, a range of protocols and techniques are employed, while simultaneously defending against a variety of attacks aimed at compromising security. Understanding and addressing these goals are essential for creating secure and resilient network infrastructures.

2. Confidentiality

Definition: Confidentiality ensures that information is accessible only to those who are authorized to view it. In other words, it prevents unauthorized individuals from accessing sensitive data during transmission or storage.

Protocols to ensure confidentiality:

• Encryption is the primary mechanism to maintain confidentiality. Some widely used encryption algorithms include:
  • Feistel-based encryption: Block cipher methods like DES (Data Encryption Standard) and 3DES use the Feistel structure to transform plaintext into ciphertext.
  • AES (Advanced Encryption Standard): A modern block cipher widely used for securing sensitive data.
  • RSA and ECC (Elliptic Curve Cryptography): Public-key encryption algorithms used for secure communication.
  • TLS/SSL (Transport Layer Security): Ensures encrypted communication over the Internet for applications like web browsing (HTTPS).

Attacks on confidentiality:

• Brute force attacks: Attempting to decrypt data by trying all possible keys.
• Known plaintext attack (KPA): Where the attacker knows both plaintext and ciphertext pairs and uses them to break the encryption.
• Chosen ciphertext attack (CCA): The attacker can select a ciphertext and obtain its decryption to derive more information.
• Meet-in-the-middle attack: This attack is often used against block ciphers like 3DES, where the attacker tries to find intermediate values to reduce the complexity of decrypting data.

3. Integrity

Definition: Integrity ensures that the data being transmitted or stored is not altered or tampered with, either maliciously or accidentally. The goal is to ensure that the data remains consistent and accurate from the sender to the receiver.

Protocols to ensure integrity:

• Hash functions: Algorithms like SHA-256 and MD5 generate a fixed-size output from input data. Any change to the input will result in a different hash, signaling tampering.
• Checksums: Used to detect accidental data corruption by comparing the checksum value before and after transmission.
• Message Authentication Codes (MAC): Ensure both integrity and authenticity by appending a code created from a secret key.
• Digital signatures: Often used in combination with public-key cryptography, these signatures provide a method to verify that a message or document has not been altered.

Attacks on integrity:

• Man-in-the-middle attack (MITM): The attacker intercepts and possibly alters the communication between two parties, leading to compromised integrity.
• Replay attacks: An attacker captures valid data transmissions and replays them later to achieve unauthorized results.
• Data modification attack: An attacker intercepts and modifies data in transit, possibly corrupting files, emails, or even transactions.

4. Authentication

Definition: Authentication ensures that the entity involved in communication is who they claim to be. This goal applies to both users and devices, confirming their identity before allowing access to sensitive data or network resources.

Protocols to ensure authentication:

• Password-based authentication: Simple usernames and passwords are the most common form of authentication.
• Multi-factor authentication (MFA): Combines two or more independent credentials, such as a password, a one-time code, or biometric verification (fingerprint or face recognition).
• Kerberos: A network authentication protocol using secret-key cryptography and tickets to verify users' identities.
• Digital certificates: Issued by certificate authorities (CAs), these are used to verify the identity of devices or websites in protocols like SSL/TLS.

Attacks on authentication:

• Password cracking: Using tools like brute force or dictionary attacks to guess or compute a user’s password.
• Phishing: An attacker impersonates a trusted entity to trick users into revealing their login credentials.
• Session hijacking: The attacker takes control of a user's session by stealing their session token or cookies.
• Credential stuffing: Using stolen credentials from one service to gain access to other accounts due to password reuse.

5. Availability

Definition: Availability ensures that network services, systems, and data are accessible to authorized users when needed. It ensures that there is no disruption in service, allowing continuous access to network resources and services.

Protocols to ensure availability:

• Redundancy: Network devices, systems, and servers often have backups to ensure that even if one system fails, others can take over.
• Load balancing: Distributes traffic across multiple servers to ensure no single server is overwhelmed, maintaining service availability.
• Firewalls: Provide defense against unauthorized access and attacks, helping maintain availability by blocking malicious traffic.
• DDoS protection: Mechanisms like rate limiting and cloud-based DDoS mitigation are used to protect against Distributed Denial of Service (DDoS) attacks, which aim to overwhelm a network with traffic.

Attacks on availability:

• Denial of Service (DoS): An attacker floods the network or service with excessive traffic, making it unavailable to legitimate users.
• Distributed Denial of Service (DDoS): Similar to DoS, but the attack is launched from multiple compromised systems.
• Botnets: Networks of compromised devices that are used to perform massive-scale DDoS attacks.
• Ransomware: Malware that locks down systems or data, demanding ransom to restore access, affecting the availability of critical services.

These four goals—confidentiality, integrity, authentication, and availability—form the core of network security. Ensuring each of these is protected is vital for safeguarding sensitive data and maintaining the smooth operation of any network. However, each of these security aspects is constantly under threat from evolving and sophisticated attacks. To protect against these, organizations must employ a combination of security protocols, best practices, and proactive defenses, while remaining vigilant in identifying and addressing new vulnerabilities.

Table of Contents

1. Prerequisites
2. Introduction
3. The Contact class
4. The ContactBook class
5. Putting it all together - The ContactBookClient class
6. Summary
7. Key Concepts
8. Conclusion

Prerequistes

This OpenGenus article is intended for those who have knowledge of basic Java syntax such taking input/output from the user using Scanner, data types and variables, loops and conditions, classes and objects, exception handling and ArrayList and are ready to build their first project using object-oriented programming.

Tools

Installation of JDK 17 or higher and an IDE of your choice.

Introduction

In this OpenGenus article, you will learn how to apply the basic concepts of object-oriented programming (OOP) to develop a simple, console-based contact book application. This application will allow users to store, view, edit, and manage a list of contacts efficiently using core OOP principles such as classes, objects, encapsulation, and methods.Your application will be have the following features:

Add a contact: Users can add a new contact by providing the name, phone number, and email.
View contacts: Users can view the list of contacts stored in the Contact Book.
Edit a contact: Users can edit the details of an existing contact, including the name, phone number, and email.
Delete a contact: Users can delete a contact from the Contact Book.

In this article we will follow the principle of incremental development where I will give you some boilerplate code so that you can implement the code according to the directions. Please try writing the code yourself before looking at my implementation.

The Contact Class

Object-oriented programming (OOP) is a paradigm that uses objects to represent real-world entities and their interactions, helping us design more organized and maintainable applications. For example, consider the contacts list on your iPhone: each contact has attributes like name, email, and phone number. You can also perform actions such as adding, editing, and deleting contacts. We'll use OOP principles to model this relationship in our code. Let's start implementing our Contact class, which represents a single contact or the most basic unit of our contact book.

Defining Instance Variables

public class Contact {
    //define instance variables here
}

public class Contact {
        private String name;
        private String phoneNumber;
        private String email;
    }
 

In Java, it is best practice to keep instance variables private so that they cannot be modified from other classes.

Initializing our Contact object with a constructor

	public Contact(String name, String phoneNumber, String email) {
		//initialize instance variables here
	}

    public Contact(String name, String phoneNumber, String email) {
		this.name = name;
		this.phoneNumber = phoneNumber;
		this.email = email;
	}
 

A constructor in Java is a special method that is called when you create a new object of a class. It initializes the object and sets up its initial state. The keyword this is a reference to the current object (the object whose constructor is being called). It's used to distinguish between instance variables and parameters or other variables with the same name.

Key points:

• It has the same name as the class.
• It doesn't have a return type, not even void.
• It's used to assign values to the object's variables when the object is created

Getters and Setters

Getters and setters in Java help with encapsulation by keeping a class's variables private and controlling how they are accessed or changed. Getters let you read the value, while setters allow you to update it safely, ensuring the data stays valid and secure. This keeps the internal details of the class hidden from outside code. Let's add our getters and setters for the Contact class.

        public String getPhoneNumber() {
		//your implementation here
	}

	public String getName() {
		//your implementation here
	}

	public String getEmail() {
		//your implementation here
	}

	public void setPhoneNumber(String phoneNumber) {
		//your implementation here
	}

	public void setName(String name) {
		//your implementation here
	}

	public void setEmail(String email) {
		//your implementation here
	}

    public String getPhoneNumber() {
        return this.phoneNumber;
	}
public String getName() {
	return this.name;
}

public String getEmail() {
	return this.email;
}

public void setPhoneNumber(String phoneNumber) {
	this.phoneNumber = phoneNumber;
}

public void setName(String name) {
	this.name = name;
}

public void setEmail(String email) {
	this.email = email;
}

Equals Method

We'll use this method to compare whether 2 contacts have the same name, email, and phone number in order to avoid adding duplicate contacts to our contact book.

	public boolean equals(Contact contact) {
		//your implementation here
	}

    	public boolean equals(Contact contact) {
		return this.name.equals(contact.email)
				&& this.email.equals(contact.name)
				&& this.phoneNumber.equals(contact.phoneNumber); //use .equals to compare strings 
	}
 

toString() Method

Java's default toString() method returns a string that represents the object's memory address, which isn't very useful when we want to display meaningful information about an object. By overriding the default toString() method in our class, we can customize how an object is represented as a string. This is important for providing clear and readable output when viewing the details of an object, such as a contact list.

public String toString() {
		//your implementation here
	}

    	public String toString() {
		String name = "Contact name: " + this.name + "\n";
		String email = "Contact email: " + this.email + "\n";
		String phoneNumber = "Contact phone number: " + this.phoneNumber + "\n";
		return name + email + phoneNumber;
	}
 

The ContactBook class

Now that we've defined the attributes of the Contact object, we need to implement the methods that will let users view, add, edit, and delete contacts. To manage these operations, we'll create a new class called ContactBook. This class will serve as a collection and manager for our contacts.

ArrayList of Contacts

This is where we'll store the contact information. Since an ArrayList can hold objects of any type, we'll initialize it to store Contact objects specifically.

public class ContactBook {
   //initialize ArrayList here
}

    	private ArrayList list = new ArrayList();
 

Again, we want to make our instance variables private to follow the principle of encapsulation.

View contact list

Prints out all our entries in our contact book along with each corresponding entry number. Hint: Can you use a method from the Contact class to display Contact info?

	public void view() {
    		System.out.println("\nViewing all Contact Book entries");
		//your implementation here
	}

    public void view() {
		System.out.println("\nViewing all Contact Book entries");
		for (int i = 0; i < list.size(); i++) {
			System.out.println("-----------");
			System.out.println("Entry #" + (i + 1));
			System.out.println(list.get(i).toString());
		}
	}
 

Add a contact

Checks if the contact already exists in the contact book. If so, inform the user that they are trying to add a duplicate contact. Otherwise, add an instance of Contact to our contact book. Hint: Can you use a method from the Contact class to check for duplicates?

	public void add(String name, String email, String phoneNumber) {
    		Contact contact = new Contact(name, email, phoneNumber);
		//your implementation here
	}

    public void add(String name, String email, String phoneNumber) {
		Contact contact = new Contact(name, email, phoneNumber);
		for (Contact c : list) {
			if (c.equals(contact)) {
				System.out.println("\nContact with phone number, name, and " + "email already exists in contact book");
				return;
			}
		}
	list.add(contact);
	int entryNum = list.indexOf(contact) + 1;
	System.out.println("Entry # " + entryNum + " successfully added to contact book!\n");
}

For editing and deleting contacts we will prompt the user for the entry that they would like to edit or delete in the main method.

Edit contact

Retrives and prints out information about the contact. Prompt the user to change the contact's name, email, and phone number and set them to the new values in our Arraylist.

	public void edit(int entry) {
		int index = entry - 1;
		//get the contact from the array list
		
		System.out.println("\nEntry #" + (entry));
        //print contact information
				
		Scanner s = new Scanner(System.in);
		
		System.out.print("\nEdit name: ");
        //read user input and set name of contact
		
		System.out.print("Edit Email: ");
        //read user input and set email of contact
		
		System.out.print("Edit phone number: ");
        //read user input and set phone number of contact
		
		System.out.println("\nContact edited successfully!");
	}

    	public void edit(int entry) {
		int index = entry - 1;
		Contact contact = list.get(index);
	System.out.println("\nEntry #" + (entry));
	System.out.println(contact.toString());
	
	Scanner s = new Scanner(System.in);
	
	System.out.print("\nEdit name: ");
	String name = s.nextLine();
	contact.setName(name);
	
	System.out.print("Edit Email: ");
	String email = s.nextLine();
	contact.setEmail(email);
	
	System.out.print("Edit phone number: ");
	String phoneNumber = s.nextLine();
	contact.setPhoneNumber(phoneNumber);
	
	System.out.println("\nContact edited successfully!");
}

Delete contact

Removes the entry from the ArrayList. Hint: Java ArrayList's use 0 based indexing, meaning that the first element in the ArrayList will have an index of 0.

	public void delete(int entry) {
		//your implementation here
        System.out.println("\nEntry #" + entry + " sucessfully deleted!");
	}

    public void delete(int entry) {
		int index = entry - 1;
		list.remove(index);
		System.out.println("\nEntry #" + entry + " sucessfully deleted!");
	}
 

Putting it all together - The ContactBookClient class

Now that we've finished writing the code for the Contact and Contact Book classes, we are ready to implement our main method (ContactBookClient class) that allows the user to interact with our contact book program through the console. Once again, I will provide you with boilerplate code. I recommend you run the provided code first to get an idea of the expected output.
You can either write your own unit tests or run your program in the console to verify the output is correct. My full implementation is provided in the GitHub repo linked at the bottom of this article.

ContactBookClient.java

import java.util.InputMismatchException;
import java.util.Scanner;

public class ContactBookClient {

    private static Scanner s = new Scanner(System.in);

    public static void main(String[] args) {
        ContactBook contactBook = new ContactBook();
        int userInput;

        do {
            displayMenu();
            userInput = getValidMenuOption();

            switch (userInput) {
                case 1:
                    if (contactBook.getSize() != 0) {
                        //your code here
                    } else {
                        System.out.println("There are no contacts to view.");
                    }
                    break;
                case 2:
                    //your code here
                    break;
                case 3:
                    if (contactBook.getSize() != 0) {
                       //your code here
                    } else {
                        System.out.println("There are no contacts to edit.");
                    }
                    break;
                case 4:
                    if (contactBook.getSize() != 0) {
                          //your code here
                    } else {
                        System.out.println("There are no contacts to delete.");
                    }
                    break;
                case 5:
                    System.out.println("Exiting program...");
                    break;
                default:
                    System.out.println("Invalid option.");
            }
        } while (userInput != 5);

        s.close();
    }

    // Displays the menu options
    private static void displayMenu() {
        System.out.println("Contact Book Menu:");
        System.out.println("1 - View contacts");
        System.out.println("2 - Add a new contact");
        System.out.println("3 - Edit a contact");
        System.out.println("4 - Delete a contact");
        System.out.println("5 - Quit");
        System.out.print("Choose an option: ");
    }

    // Gets a valid menu option between 1 and 5
    private static int getValidMenuOption() {
        int userInput = -1;
        boolean inputValid = false;

        do {
            try {
                userInput = s.nextInt();
                if (userInput >= 1 && userInput <= 5) {
                    inputValid = true;
                } else {
                    System.out.println("Invalid input. Please enter a number between 1 and 5.");
                }
            } catch (InputMismatchException e) {
                System.out.println("Invalid input. Please enter a valid number.");
                s.next(); // Clear invalid input
            }
        } while (!inputValid);

        s.nextLine(); // Consume leftover newline
        return userInput;
    }

    // Adds a new contact to the contact book
    private static void addContact(ContactBook contactBook) {
        System.out.print("Enter contact name: ");
        //read user input

        System.out.print("Enter contact email: ");
       //read user input

        System.out.print("Enter contact phone number: ");
        //read user input

        //add name, phone number, and email to contact book
        System.out.println("Contact added successfully.");
    }

    // Edits a contact from the contact book
    private static void editContact(ContactBook contactBook) {
        //process user input
        //edit the contact's information
        System.out.println("Contact edited successfully.");
    }

    // Deletes a contact from the contact book
    private static void deleteContact(ContactBook contactBook) {
         //process user input
         //delete the contact from the contact book
        System.out.println("Contact deleted successfully.");
    }

    //Processes user input to choose a valid entry from the contact book
     public static int processUserInput(ContactBook contactBook) {
        //implement this method following the same pattern as used in getValidMenuOption() 
       //if the input is invalid print a message to inform the user
       int userInput = -1;
       boolean inputInvalid;
                    
       do {
            System.out.print("Choose an entry (1 to " + contactBook.getSize() + "): ");
            try {
               //your code here
                }
            } catch (InputMismatchException e) {
               //your code here
            }
        } while (inputInvalid);

        s.nextLine(); // Consume leftover newline
        return userInput;
    }

Summary

In this article, I have demonstrated object-oriented programming (OOP) in action. By developing a simple contact book program, I hope you’ve gained a clearer understanding of the core concepts of OOP and how they can be applied in real-world programming.

Key concepts

Class: A blueprint or template for creating objects. It defines the properties (fields) and behaviors (methods) that objects of that class will have.

Object: An instance of a class, representing a specific entity with its own set of values for the defined properties and methods.

Instance variable: A variable defined in a class for which each instantiated object (instance) of the class has its own copy.

Static: Describes a class member that belongs to the class itself rather than to any specific instance. Static members can be accessed directly using the class name, without needing to create an object first. Note that you cannot access non-static members from a static context.

Public: An access modifier that allows a class, method, or variable to be accessible from any other class.

Private: An access modifier that restricts access to a class's variables or methods to only within that class.

Encapsulation: The OOP principle of keeping data (variables) and methods together in a class and restricting direct access to some components using access modifiers like private.

Constructor: A special method in a class that is used to initialize new objects. It often sets the initial values of instance variables.

Getter: A method that retrieves or "gets" the value of a private instance variable.

Setter: A method that updates or "sets" the value of a private instance variable.

toString Method: A method that converts an object into a string representation, often for printing or debugging purposes.

equals Method: A method that compares two objects to determine if they are logically equal based on their content, rather than their memory addresses.

Resources

Complete Implementation: https://github.com/skottchen/ContactBook

The ever-changing online gaming world is built with randomness as an integral part. Randomness is needed because it gives variety and fun purely from the unpredictability of the fate of the characters' abilities.

However, the relentlessness of such simulations is built around a technical, rigorous framework beneath the randomness players put up with. These are fair and unpredictable; all players are on a level field.

Randomness in Game Design

Pixabay

A big part of gaming is randomness, not just games of chance, but across a broad spectrum of gaming genres. Randomness is not always a bad thing, no matter if it's undoubtedly lucky whether an item drops in a role-playing game and then how to work out the probability of an outcome in strategy-based games.

It adds an element of surprise that turns engagement if done correctly. Randomness adds uncertainty, which keeps players on their toes and forces them to adapt and think on their feet.

The randomness created is based on random number generators (RNGs). RNGs simulate real-world unpredictability by generating random sequences that correspond to real-life events.

Without these systems, no two game experiences would be the same, ensuring players have fresh and dynamically spontaneous gameplay each time they interact with the game. Randomness is vital in traditional settings, such as online casino games, so all are fair and captivated.

Statistical Simulations: The Backbone of Fair Play

Randomness is spontaneous, but it’s calculated in the most careful of ways through statistical simulations. Keeping these simulations around helps keep things fair because it puts an algorithmically balanced amount of luck and skill where needed. Statistical models simulate numerous odds and odds outcomes so the odds remain consistent and transparent.

While these simulations mimic unpredictability in online games, everything is planned out behind the scenes. Developers use statistics to adjust probabilities and game mechanics that keep players involved but not manipulated, relying on them.

Perception and Fairness: A Constant Struggle

Pexels

Managing player perception in games that involve randomness is one of the ongoing challenges of game design. Even when RNGs and all other statistical models are 100% fair, players will sometimes perceive it as if the randomness is against them.

Here is where the psychological component comes into play: randomness. Creating an engaging experience with randomised content is a tricky balancing act that developers must remember: random outcomes must be fair.

Too predictable randomness may take the fun out of the game. If it feels chaotic enough, players could feel it’s unfair. One of the most challenging parts of game design is to strike the right balance between those two extremes. The key is making randomness feel reasonable and making statistical simulations as transparent as possible.

The Science Behind Randomness in Games

Randomness and statistical simulation produce positive, engaging, and unpredictable gaming experiences. These are the very concepts that make gameplay fair in traditional games, movies, or online platforms.

Game designers can achieve this by utilising statistical models and RNGs to offer the players an atmospheric space where skill and luck can coexist to produce an exciting dynamic.

However, randomness in online gaming has almost nothing to do with increasing uncertainty; it's about making the experience seem fair and well-balanced, regardless of the actual odds.

Game development is an exciting and interesting area to explore for people who have just finished learning web/app development, or any person who's enthusiastic about gaming and coding. To get started with game development, you must know at least one programming language such as C++, C#, Java or Python. Generally, to develop a 2D/3D game, it would be more convenient to learn a game engine so that much of the complexity of designing your game graphics, rendering audio, animation, etc. is abstracted. Keep in mind, game development requires many hours of creative and critical thinking to build up the logic for your game, consideration of all possible scenarios that can occur as well as delivering a smooth UX and a beautiful UI for the end users.

As a beginner who's never had any hands-on experience in game dev, you can use the PyGame library. It is a Python library that acts as a simple 2D gaming toolkit, providing features such as allowing you to draw sprites, providing support for sound, functionality for collision detection and more. It is, however, very rudimentary in comparison to other game engines which take into account physics, and help deal with advanced systems. But, it can be used to create beautiful and interesting games and is, most importantly, easy to learn and implement.

So, in this OpenGenus article, let us create a Dodgeball game in Python. You can customize your game along the way without having to stick to my design choices.

TABLE OF CONTENTS:

1. Basics of PyGame

2. Setting up Dodgeball

3. Adding additional functionality

4. Key takeaways

Pre-requisites: Knowledge of Python and Object-Oriented Programming in Python.

1. Basics of PyGame

There are some basic concepts and terms that you'll need to know when you start using Pygame to build your game and we'll go over those in this section.

• Surface- Is like a blank canvas in Pygame. You can fill color in it, put an image onto it or draw shapes on it.
• Screen- Is a special canvas in Pygame representing the game screen.
• Game Loop- Is the flow of control for the entire game. Keeps looping infinitely until a specific event occur, watches all input and handles it according to the programmed logic.
• Event- Is a certain action which occurs in the game duration upon trigger by the user or in a pre-programmed manner by the game itself.
• Sprite- Is an object which has attributes like size, color, etc. that can be customized as well as its own specific methods. Generally used to represent game characters as well as game objects.
• Rect- Represents a rectangular object that stores and manipulates rectangular areas. Used to control coordinates and movements.

2. Setting up Dodgeball

Install the Pygame package by running pip install pygame. Once you've done that, paste this basic code snippet onto a new Python file in your project directory.

import pygame
import sys
# address delay in exiting the game from exit screen


# initializing pygame library
pygame.init()

                
# setting up game screen
WIDTH = 600
HEIGHT = 800

screen = pygame.display.set_mode([HEIGHT, WIDTH]) # provide a list or tuple to define the screen size


# handle game running
while True: # game loop- controls whether the program should be running or when it should quit
    # if user clicks exit window quit game
    for event in pygame.event.get(): 
        if event.type == pygame.QUIT:
            # game_state = 0
            pygame.quit()
            sys.exit()
 
   
        # fill background color of screen: either a list or tuple is its argument
    screen.fill((137, 13, 15))
    
        # simply draw a circle on the screen
    pygame.draw.circle(screen, (0, 0, 0), (250, 250), 75)
    
  
    pygame.display.flip()

I have written detailed comments against each line to help you understand what is going on.
We call pygame.init() so that pygame is able to initialize all its modules, and we define the screen size i.e. the size of the game window which the user interacts with. After that, we define our game loop which is essentially the loop that keeps the game running until the user wants to exit. If the user clicks the exit window, we use pygame.quit() to quit Pygame and sys.exit() to exit from the program. As for what is to be displayed on the game screen, for now we keep it simple and render a circle on the screen. The syntax of the command is pygame.draw.circle(screen (the game screen which we have defined), color to draw with, coordinates of the center, radius). Use pygame.display.flip() to render your graphics on the game window. I have also filled the screen with a dark-red color: rgb(137, 13, 15). Now when you run your Python program, you should be able to see the aforementioned details on the game window and when you click the exit icon, the game should stop and the window must close. What you will notice if everything went smoothly is that there is an infinite number of frames per second, we'll tackle that issue shortly and slow down the fps so that the game is playable in the upcoming section. In case you face any issues, cross-check your code and check the documentation to make sure you are using all the methods in the proper intended way and using the proper syntax.

We have succesfully set up the skeleton for our dodgeball game.

To break down all the features that should be present in our game, let us list them out:

1. Render a player, and enemies (balls) as the main components.
2. Add audio to the game.
3. Add a score tracker to the game.
4. If a collision is detected the game must be ended.
5. Enemies (balls) must constantly fly at the player at a constant rate per level.

Sprites in Pygame are objects with attributes and methods that represent our game characters.

We define the following classes in our game to modularize our code:

1. Image - to load an image path and set its position on the screen

# extend pygame.sprite.Sprite using super() (inheritance, returns a delegate object to the parent and extends its functionality)
class Image:
    def __init__(self, path):
    # load the image path and optimize it for fast blitting as well as preserve its transparent are
        self.avatar = pygame.image.load(path).convert_alpha()
        self.avatar.set_colorkey((255, 255, 255)) # sets a specific color to be treated as transparent
        self.avatar = pygame.transform.smoothscale(self.avatar, (100, 150)) # scales the image to a new size while preserving and providing higher quality resolution
        self.rect = self.avatar.get_rect(
            center = (
                20,
                HEIGHT/2
            )
        )

2. Game - to define the game player, define a group of enemies and a group of all the game sprites so that we can easily implement future functions which deal with those sprites in bulk, and load sound.

class Game:
    def __init__(self):
        self.player = Player()
        self.enemies = pygame.sprite.Group()
        self.all_sprites = pygame.sprite.Group()
        self.all_sprites.add(self.player)
        self.limit = 5 # to help with our score logic, we use it as a lower bound to determine whether to increase our score or not
        self.passbys = 0 # number of balls that have successfully passed by without collision
        main_sound.play()

3. Player - we have images of the player for every direction it turns in, so here we would define the logic for changing the image of the player based on keyboard input and maintain the player's score as well.

class Player(pygame.sprite.Sprite):
    def __init__(self):
        super().__init__()
        image = Image("./positions/left.png")
        self.avatar = image.avatar
        self.rect = image.rect
        self.score = 0
    def update(self, pressed):
        if pressed[pygame.K_UP]:
            image = Image("./positions/up.png")
            self.avatar = image.avatar
            self.rect = self.avatar.get_rect(
                center = (
                    self.rect.centerx,
                    self.rect.centery - 10
                )
             )
            
        if pressed[pygame.K_DOWN]:
            image = Image("./positions/left.png")
            self.avatar = image.avatar
            self.rect = self.avatar.get_rect(
                center = (
                    self.rect.centerx,
                    self.rect.centery + 10
                )
             )
            
        if pressed[pygame.K_RIGHT]:
            image = Image("./positions/left.png")
            self.avatar = image.avatar
            self.rect = self.avatar.get_rect(
                center = (
                    self.rect.centerx + 10,
                    self.rect.centery 
                )
             )
            
        if pressed[pygame.K_LEFT]:
            image = Image("right.png")
            self.avatar = image.avatar
            self.rect = self.avatar.get_rect(
                center = (
                    self.rect.centerx - 10,
                    self.rect.centery
                )
             )
            
        # prevent player from hurtling off screen
        if self.rect.left < 0:
            self.rect.left = 0
        if self.rect.top <= 0:
            self.rect.top = 0
        if self.rect.right > WIDTH:
            self.rect.right = WIDTH - 25
        if self.rect.bottom >= HEIGHT:
            self.rect.bottom = HEIGHT - 25

4. Enemy - we load the enemy image and define its position on the game screen.

class Enemy(pygame.sprite.Sprite):
    def __init__(self):
        super().__init__()
        self.x = 20
        self.y = 10
        self.avatar = pygame.image.load("enemy.jpg").convert()
        self.avatar.set_colorkey((255, 255, 255))
        self.avatar = pygame.transform.scale(self.avatar, (80, 80))
        self.rect = self.avatar.get_rect(
            center = (
                random.randint(WIDTH + 20, WIDTH + 100),
                random.randint(0, HEIGHT)
            )
        )
        self.speed = random.randint(5, 20)
    def update(self):
        self.rect.move_ip(-self.speed, 0)
        if self.rect.right < 0:
            self.kill()

What about the logic for collision and for rendering enemies (balls) periodically on the screen? What if the balls go out of frame- will they still be shown on the game screen?

To handle the logic for collision within the game loop, we typically implement that inside our game loop and using Pygame's inbuilt spritecollideany(sprite1, sprite2) function, we kill the player, stop the retro sound and play the collision sound effect, we render a new screen displaying the player's final score, wait for a few seconds and ask the player whether they are interested to try again, if not quit pygame and exit, else we continue the game loop.
In addition, I have removed the circle and background color used for explanation in the previous section and replaced them with a bg image.

    pressed = pygame.key.get_pressed()
    game.player.update(pressed) # player's image changes based on direction
    game.enemies.update()  # enemy should whizz across the screen from the right to
    # the left and get killed when it goes out of frame
    background = pygame.image.load("bgimage.jpg")
    background = pygame.transform.scale(background, (HEIGHT, WIDTH))
    screen.fill((255, 255, 255))
    bg_rect = background.get_rect() 
    screen.blit(background, bg_rect) # rendering the bg image (image of the 
    # dodgeball court) on our game screen
    for entity in game.all_sprites: # game.all_sprites is a list of all sprite objects
        screen.blit(entity.avatar, entity.rect) # draws the entity's image onto the # surface defined for it
    # check for collisions
    if pygame.sprite.spritecollideany(game.player, game.enemies):
        # you lose! try again page
        game.player.kill()
        main_sound.stop()
        collision_sound.play()
        if event.type == pygame.K_ESCAPE:
            pygame.quit()
            sys.exit()
        else:
            game = Game()
            continue
        # flip display- updates contents of display to the screen, without this nothing appears
    pygame.display.flip()
    clock.tick(30) # program should maintain a rate of 30 fps

To use different game screens based on whether the player has lost or quit or just begun the game, we can use Pygame's render method to display the player's current score and show them that they have lost, and create a new screen to ask the player whether they wish to try again or quit:

        loser = pygame.font.Font('Micro5-Regular.ttf', 50)
        new_surf = loser.render(f"You lost! Your final score is {game.player.score}.", False, (255, 68, 51)) # create a surface off the text
        screen.blit(new_surf, (WIDTH/3, HEIGHT/2))
        pygame.display.flip()
        pygame.time.wait(1000)
        screen = pygame.display.set_mode([HEIGHT, WIDTH])
        screen.fill((144, 238, 144))
        intro_screen = pygame.font.Font('your_font.ttf', 70)
        intro = intro_screen.render("Try again? Press ESC to exit or wait to restart", False, (255, 68, 51))
        screen.blit(intro, (10, HEIGHT/5))
        pygame.display.flip()
        pygame.time.wait(2000)

For rendering enemies, we want our enemies i.e. the balls to constantly come into frame from the right as they do in dodgeball. To tackle this, we define a new event called ADD_ENEMY and use set_timer to have a constant influx of enemies after a pre-defined interval.

''' now we have to create a steady supply of enemies aka obstacles at regular intervals- create a custom event
and set its interval '''
ADD_ENEMY = pygame.USEREVENT + 1
pygame.time.set_timer(ADD_ENEMY, 1000)

We add the event-handling logic for it within the game loop :

elif event.type == ADD_ENEMY:
                new_enemy = Enemy()
                game.enemies.add(new_enemy)
                game.all_sprites.add(new_enemy)
                game.passbys += 1
                if game.passbys > game.limit:
                    game.player.score += 5
                    game.limit += 5
                print(game.player.score)

Lo and behold, the game is ready!

3. Adding additional functionality

Here are some suggestions for you to practice all you have learnt about PyGame so far, you can add on some additional features to the game and refer to the documentation as and when you get stuck.

1. Implement a level feature- if your score hits a threshold, you get to a higher level and update the threshold. At each level upgrade, the speed of the incoming balls increases and it gets more difficult to score.
2. Implement a dark mode level- once you have reached a sufficiently high level, you can make the court go dark as if someone has switched off the lights and focus a spotlight on the player, and one on the incoming ball.
3. Add different ball types- instead of having the same type of ball coming in, you can add an extra bouncy ball, a super slow ball, a super fast one as well as one with a very large stride.
4. Add bonuses- you can increase the player's score by a large amount if they manage to avoid colliding with a special ball such as one that is very fast/extra bouncy.
5. Add a high score feature- Keep track of the highest score that the player has achieved till now.
6. Implement a tutorial mode- Show the player how the game is meant to be played and what the game's rules are by implementing a simple tutorial before starting the game. Add an option to skip it as well.

Key takeaways

• Introduction to Game Development:

  • Game development is ideal for those familiar with web/app development or coding enthusiasts.
  • Requires knowledge of programming languages (C++, C#, Java, Python).
  • Learning a game engine is beneficial for handling game graphics, audio, and animation.

• About PyGame:

  • PyGame is a Python library for 2D game development.
  • It simplifies creating games with features like sprite drawing, sound support, and collision detection.

• Creating a Dodgeball Game:

  • Basics of PyGame:

    • Install PyGame and set up a basic game window with pygame.init().
    • Basic code includes setting up the game loop, handling events, and rendering graphics.

  • Setting Up Dodgeball:

    • Features include rendering player and enemies, adding audio, scoring, and handling collisions.
    • Use classes for game elements: Image, Game, Player, and Enemy.
    • Implement collision detection and different game screens.
    • Add functionality to periodically generate enemies and manage fps.

  • Adding Additional Functionality:

    • Suggestions include implementing levels, dark mode, different ball types, bonuses, high scores, and a tutorial mode.