Date Archives

October 2023

Memory Management in C++

Memory Management in C++ by Lyron Foster

Memory management is an essential part of any C++ application. While the language provides some basic tools, such as new and delete, it’s crucial to be familiar with advanced techniques for managing memory efficiently and avoiding common issues like memory fragmentation.

1. Memory Pools

Memory pools are contiguous blocks of memory that are split into chunks of uniform size. These chunks are used to quickly allocate and deallocate objects.


class MemoryPool {
    struct Block {
        Block* next;

Block* freeBlocks;
    void expandPoolSize();
    MemoryPool(std::size_t blockSize, unsigned blockCount);
    void* allocate(std::size_t size);
    void deallocate(void* p);

2. Custom Allocators

Custom allocators allow the programmer to decide how and where memory is allocated and deallocated.


template <typename T>
class CustomAllocator {
    using value_type = T;

    CustomAllocator() noexcept {}
    template <typename U> CustomAllocator(const CustomAllocator<U>&) noexcept {}

    T* allocate(std::size_t n);
    void deallocate(T* p, std::size_t n);

3. Techniques to Reduce Memory Fragmentation

Memory fragmentation occurs when free memory space is split into small non-contiguous blocks. These techniques help reduce fragmentation:

Compaction: Rearranges memory by moving data blocks together to create a contiguous free memory block.


void compactMemory(char* memoryArray, size_t size) {
    // Logic to move allocated blocks together, leaving free space at the end

Fixed-size Allocation: Uses fixed-size memory blocks to prevent external fragmentation.


class FixedSizeAllocator {
    size_t blockSize;
    // ... Other members ...

    FixedSizeAllocator(size_t size);
    void* allocate();
    void deallocate(void* p);

Block Reuse: Reuses memory blocks that were previously freed instead of allocating new blocks.


class BlockReuseAllocator {
    void* freeBlockList;
    // ... Other members ...

    void* allocate();
    void deallocate(void* p);

Useful Commands/Operations:

  • Valgrind: A tool to detect memory leaks.
valgrind --tool=memcheck ./your_program
  • gdb: A debugger that can help trace memory issues.
gdb ./your_program

Advanced memory management in C++ is essential to ensure that applications are efficient and do not waste resources. If you successfully employ these strategies, you can significantly improve the memory efficiency of your programs and avoid common memory-related errors.

I hope you this article interesting. If so, please consider following me here and on social media.


Reinforcement Learning with Proximal Policy Optimization (PPO)

Reinforcement Learning (RL) has been a popular topic in the AI community, especially with its potential in training agents to perform tasks in environments where the correct decision isn’t always obvious. One of the most widely used algorithms in RL is Proximal Policy Optimization (PPO). In this tutorial, we’ll discuss its foundational concepts and implement it from scratch.

Traditional policy gradient methods often face challenges in terms of convergence and stability. PPO was introduced as a more stable and robust alternative. PPO’s key idea is to limit the change in policy at each update, ensuring that the new policy isn’t too different from the old one.

Let’s get up to speed

Before diving in, let’s get familiar with some concepts:

  • Policy: The strategy an agent employs to determine the next action based on the current state.
  • Advantage Function: Indicates how much better an action is compared to the average action at a particular state.
  • Objective Function: For PPO, this function helps in updating the policy in the direction of better performance while ensuring changes aren’t too drastic.

PPO Algorithm

PPO’s Objective Function:

Let’s define:

  • L^CLIP(θ) as the PPO objective we want to maximize.
  • r_t(θ) as the ratio of the probability under the current policy to the probability under the old policy for the action taken at time t.
  • A^_t as the estimated advantage at time t.
  • ε as a small value (typically 0.2) which limits the change in the policy.

The objective function is formulated as:

L^CLIP(θ) = Expected value over time [ min( r_t(θ) * A^_t , clip(r_t(θ), 1-ε, 1+ε) * A^_t ) ]

In simpler terms:

  • Calculate the expected value (or average) over all time steps.
  • For each time step, take the minimum of two values:
  1. The product of the ratio r_t(θ) and the advantage A^_t.
  2. The product of the clipped ratio (restricted between 1-ε and 1+ε) and the advantage A^_t.

The objective ensures that we don’t change the policy too drastically (hence the clipping) while still trying to improve it (using the advantage function).


First, let’s define some preliminary code and imports:

import numpy as np
import tensorflow as tf

class PolicyNetwork(tf.keras.Model):
    def __init__(self, n_actions):
        super(PolicyNetwork, self).__init__()
        self.fc1 = tf.keras.layers.Dense(128, activation='relu')
        self.fc2 = tf.keras.layers.Dense(128, activation='relu')
        self.out = tf.keras.layers.Dense(n_actions, activation='softmax')
    def call(self, x):
        x = self.fc1(x)
        x = self.fc2(x)
        return self.out(x)

The policy network outputs a probability distribution over actions.

Now, the main PPO update:

def ppo_update(policy, states, actions, advantages, old_probs, epochs=10, clip_epsilon=0.2):
    for _ in range(epochs):
        with tf.GradientTape() as tape:
            probs = policy(states)
            probs = tf.gather(probs, actions, batch_dims=1)
            old_probs = tf.gather(old_probs, actions, batch_dims=1)
            r = probs / (old_probs + 1e-10)
            loss = -tf.reduce_mean(tf.minimum(
                r * advantages,
                tf.clip_by_value(r, 1-clip_epsilon, 1+clip_epsilon) * advantages

grads = tape.gradient(loss, policy.trainable_variables)
        optimizer.apply_gradients(zip(grads, policy.trainable_variables))

To train an agent in a complex environment, you might consider using the OpenAI Gym. Here’s a rough skeleton:

import gym

env = gym.make('Your-Environment-Name-Here')
policy = PolicyNetwork(env.action_space.n)
optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
for i_episode in range(1000):  # Train for 1000 episodes
    observation = env.reset()
    done = False
    while not done:
        action_probabilities = policy(observation)
        action = np.random.choice(env.action_space.n, p=action_probabilities.numpy())
        next_observation, reward, done, _ = env.step(action)
        # Calculate advantage, old_probs, etc.
        # ...
        ppo_update(policy, states, actions, advantages, old_probs)
        observation = next_observation

PPO is an effective algorithm for training agents in various environments. While the above is a simplistic overview, it captures the essence of PPO. For more intricate environments, consider using additional techniques like normalization, entropy regularization, and more sophisticated neural network architectures.

Implementing JWT (JSON Web Token) Authentication in Go

JSON Web Tokens (JWT) are a popular method for representing claims securely between two parties. In the realm of web applications, they often serve as a way to transmit identity information (as claims) from a client to a server. In this tutorial, we’ll walk through the process of implementing JWT authentication in a Go application.

1. What is JWT?

A JSON Web Token (JWT) is a compact URL-safe means of representing claims to be transferred between two parties. The claims in a JWT are encoded as a JSON object that is digitally signed using JSON Web Signature (JWS).

A JWT typically looks like: xxxxx.yyyyy.zzzzz

  • Header: The header (xxxxx) typically consists of two parts: the type of the token, which is JWT, and the signing algorithm.
  • Payload: The payload (yyyyy) contains the claims. Claims are statements about the subject (user).
  • Signature: To create the signature (zzzzz) part, you have to take the encoded header, the encoded payload, a secret, the algorithm specified in the header, and sign that.

2. Setting Up the Go Environment

First, you’ll need a package to work with JWTs in Go. We’ll use the package:

3. Creating JWTs in Go

Let’s create a function to generate a JWT:

package main

import (
var mySigningKey = []byte("secretpassword")
func GenerateJWT() (string, error) {
 token := jwt.New(jwt.SigningMethodHS256)
 claims := token.Claims.(jwt.MapClaims)
 claims["authorized"] = true
 claims["user"] = "John Doe"
 claims["exp"] = time.Now().Add(time.Minute * 30).Unix()
 tokenString, err := token.SignedString(mySigningKey)
 if err != nil {
  fmt.Errorf("Something went wrong: %s", err.Error())
  return "", err
 return tokenString, nil

4. Validating JWTs in Go

Now, let’s validate the JWT:

func ValidateToken(tokenString string) (*jwt.Token, error) {
	token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
			return nil, fmt.Errorf("There was an error")
		return mySigningKey, nil

if err != nil {
  return nil, err
 return token, nil

5. Using JWTs for Authentication in a Go Web Application

Here’s a simple example integrating JWT generation and validation in a Go HTTP server:

package main

import (

func HomePage(w http.ResponseWriter, r *http.Request) {
 validToken, err := GenerateJWT()
 if err != nil {
  fmt.Fprintf(w, err.Error())
 clientToken := r.Header.Get("Token")
 if clientToken != validToken {
  fmt.Fprintf(w, "Token is not valid")
 fmt.Fprintf(w, "Hello, World!")
func handleRequests() {
 http.HandleFunc("/", HomePage)
 log.Fatal(http.ListenAndServe(":9000", nil))
func main() {

With this setup:

  • The server creates a JWT when the homepage is accessed.
  • To validate, the client needs to send the same JWT back in the header “Token”.
  • This is a basic example. In real scenarios, you’d issue a token after login and check it on each request requiring authentication.

JWTs provide a powerful and flexible method for handling authentication and authorization in web applications. In Go, thanks to packages like, implementing JWT-based authentication is straightforward. However, always remember to keep your signing key secret and use a secure method, preferably RSA, for added security in production applications.

CGO: Embedding and C Interoperability

The Go programming language, commonly known as Golang, is designed to be simple and efficient. However, there are times when you might need to leverage existing C libraries or embed Go into other languages. This tutorial dives deep into the world of CGO — Go’s gateway to the world of C and vice versa.

1. What is CGO?

CGO enables the creation of Go packages that call C code. By using CGO with Go, you get the power to use existing C libraries and also potentially optimize performance-critical portions of your application.

To use CGO, you need to have C development tools installed on your machine. This typically includes a C compiler like gcc.

2. Calling C Code from Go

2.1 Basic Interoperability

Here’s a simple example of how to call C code from Go:

#include <stdio.h>
import "C"

func main() {
    C.puts(C.CString("Hello from C!"))

In the code above:

  • The import "C" is a special import that represents the C space.
  • The C code is wrapped in a Go multi-line string comment.
  • C.puts calls the C function puts.

2.2 Using C Structs and Functions

Suppose you have the following C code:

// mathfuncs.c

#include "mathfuncs.h"
int add(int a, int b) {
    return a + b;
// mathfuncs.h
int add(int a, int b);

You can call the add function from Go like this:

#cgo CFLAGS: -I .
#cgo LDFLAGS: -L . -lmathfuncs
#include "mathfuncs.h"
import "C"
import "fmt"

func main() {
    a, b := 3, 4
    result := C.add(,
    fmt.Printf("%d + %d = %d\n", a, b, int(result))

3. Embedding Go into Other Languages

3.1 Exporting Go Functions for C

To make Go functions accessible from C (and by extension, other languages), you can use the //export directive.

// export.go

package main
import "C"
import "fmt"
//export SayHello
func SayHello(name *C.char) {
    fmt.Printf("Hello, %s!\n", C.GoString(name))
func main() {}

After compiling this Go code into a shared library, the exported SayHello function can be called from C.

3.2 Calling Go from C

After creating a shared library using go build -o -buildmode=c-shared export.go, you can use it in C:

// main.c
#include "export.h"
int main() {
    return 0;

Compile with gcc main.c -L . -lmylib -o output.

4. Best Practices

  • Safety First: Remember that CGO can bypass Go’s memory safety. Always ensure your C code is safe and doesn’t have leaks or buffer overflows.
  • Performance: Crossing the Go-C boundary can be expensive in terms of performance. Avoid frequent transitions if possible.
  • Error Handling: Ensure you handle errors gracefully, especially when transitioning between languages.

CGO offers a powerful way to bridge Go with C, allowing you to leverage existing libraries and functionalities. With careful planning and understanding of both Go and C ecosystems, you can use CGO effectively and safely.

The Artistry of AI: Generative Models in Music and Art Creation

When we think of art and music, we often envision human beings expressing their emotions, experiences, and worldview. However, the digital age has introduced a new artist to the scene: Artificial Intelligence. Through the power of generative models, AI has begun to delve into the realms of artistry and creativity, challenging our traditional notions of these fields.

The Mechanics Behind the Magic

Generative models in AI are algorithms designed to produce data that resembles a given set. They can be trained on thousands of musical tracks or art pieces, learning the nuances, patterns, and structures inherent in them. Once trained, these models can generate new pieces, be it a melody or a painting, that are reminiscent of, but not identical to, the training data.

Painting Pixels: AI in Art

One of the most notable examples in the world of art is Google’s DeepDream. Initially intended to help researchers visualize the workings of neural networks, DeepDream modifies images in unique ways, producing dreamlike (and sometimes nightmarish) alterations.

Another project, the Neural Style Transfer, allows the characteristics of one image (the “style”) to be transferred to another. This means that you can have your photograph reimagined in the style of Van Gogh, Picasso, or any other artist.

These technologies don’t just stop at replication. Platforms like DALL·E by OpenAI demonstrate the capability to produce entirely new, original artworks based on textual prompts, showcasing creativity previously thought exclusive to humans.

Striking a Chord: AI in Music

In the realm of music, AI’s contribution has been equally groundbreaking. OpenAI’s MuseNet can generate compositions in various styles, from classical to pop, after being trained on a vast dataset of songs.

Other tools, like AIVA (Artificial Intelligence Virtual Artist), can compose symphonic pieces used in soundtracks for films, advertisements, and games. What’s fascinating is that these compositions aren’t mere replications but entirely new pieces, bearing the “influence” of classical maestros like Mozart or Beethoven.

The Implications and the Future

With AI’s foray into art and music, a slew of questions arises. Does AI-created art lack the “soul” and “emotion” of human-made art? Can we consider AI as artists, or are they just sophisticated tools? These are philosophical debates that might not have clear answers.

However, from a practical standpoint, AI offers artists and musicians a new set of tools to augment their creativity. Collaborations between human and machine can lead to entirely new genres and forms of expression.

The intersection of AI and artistry is a testament to the incredible advancements in technology. While AI may not replace human artists, it certainly has carved a niche for itself in the vast and diverse world of art and music. As generative models continue to evolve, the line between human-made and AI-generated art will blur, leading to an enriched tapestry of creativity.