humberto

Pixl - A Predictable Pal in a Pixelated Playground

Thu, 12 Jun 2025 00:00:00 +0000

Give me a clock, three counters, and a few coloured squares, and I will show you something that sleeps under the stars: Pixl.

A Keychain, a Clock, and a Dream

In the midst of the 2008 financial crysis, my pocket rattled with a plastic egg that beeped for food every two hours. It died often. It taught persistence, empathy, and the power of a single pixel turning from 😊 to 😢.

Pixl is a love-letter to that era—an attempt to prove that, even in a world of trillion-parameter transformers, small deterministic systems still spark genuine delight. There is no server, no randomness, no hidden neural net. Only the browser’s Date object, three integers, and a handful of SVG sprites that look best on a pretend-CRT background.¹

Go play with Pixl right now at pixl.humbertowoody.xyz — the code lives on
GitHub if you want to fork, tweak, or time-travel.

Three Numbers, Infinite Gestures

Stat	Role	Good direction
`happiness`	emotional brightness	higher
`hunger`	distance from a full tummy	lower
`energy`	readiness to bounce on the screen	higher

Every 30s the numbers drift:

\begin{aligned} \text{happiness}_{t+30} &= \text{happiness}_{t}\;-\;2 \\ \text{hunger}_{t+30} &= \text{hunger}_{t} \;+ \;3 \\ \text{energy}_{t+30} &= \text{energy}_{t} \;- \;1 \end{aligned}

Left alone for half an hour Pixl grows hungry, drowsy, and a little gloomy—entropy with boundaries.

The Breath of the Machine

\text{animation}(h) \;=\; \begin{cases} \texttt{sleeping} \;\text{or}\; \texttt{sleepy}, & 22:00 \le h < 5:00 \\ \texttt{awake} \;\text{and others}, & 5:00 \le h < 22:00 \end{cases}

A laptop in Tokyo and a phone in Tijuana will see the same snores at the same moment. Pixl exists as a single, shared creature drifting through each visitor’s local midnight.

Five Axioms of Pixl’s World

Circadian
Pixl dozes whenever the local clock reads between 10 PM and 5 AM.
$h \in [22,24) \cup [0,5) \;\Longrightarrow\; \texttt{sleeping/sleepy}$
Dominant Need
Physical necessities outrank mood: starving pixels grumble, exhausted ones sag.
$\begin{aligned} \text{hunger} > 70 \;&\Longrightarrow\; \texttt{idle\_hungry}\\ \text{energy} < 20 \;&\Longrightarrow\; \texttt{idle\_tired} \end{aligned}$
Mood Gradient
The emotional dial swings between 😊 , 😐 , and 😢 depending on morale.
$\begin{cases} \text{happiness} > 70 &\Rightarrow \texttt{idle\_happy}\\[4pt] \text{happiness} < 30 &\Rightarrow \texttt{idle\_sad}\\[4pt] \text{otherwise} &\Rightarrow \texttt{idle\_neutral} \end{cases}$
Reinforcement
Sustained affection lifts Pixl into brief, exuberant euphoria.
$(\text{pet}+\text{play})_{24h} > 5 \;\land\; \texttt{animation}=\texttt{idle\_happy} \;\Longrightarrow\; \texttt{idle\_ecstatic}$
Scarcity of Kindness
Limiting each action to three times per day turns care into a ritual rather than a click-spree.
$\forall\,a \in \{\text{feed, pet, play}\},\; \text{count}_{\text{day}}(a) \le 3$

Maslow’s hierarchy distilled to five if statements—predictable yet expressive.² Skip one meal and you meet a grumbling blob; lavish attention and you earn that rare ecstatic bounce.

Portraits in Thirty-Two Squares

All art is plain SVG— $8\times8$ or $32\times32$ grids rendered with the property shapeRendering="crispEdges". The result are simple, pixel-perfect images that evoke the retro charm of early computer graphics.

A sleeping Pixl, eyes closed, dreaming of pixelated adventures.

A Walk Through the Source

Conceived as a single event-loop, Pixl’s logic is a few hundred lines of lightweight JavaScript. The core function, tick, runs every 30 seconds, updating the creature’s state and rendering the scene.

function tick(now):  
  stats ← loadStats()   # from localStorage  
  stats ← decay(stats)  # metabolic drift  
  scenery ← chooseScenery(now)  
  animation ← chooseAnimation(stats, now)  
  render(scenery, animation, stats)

A few key functions drive the experience:

chooseScenery maps (month, hour) to spring morning, autumn night, or—on 25 December—christmas.
chooseAnimation applies the five axioms above.
Persistence is two keys in localStorage: one JSON object for stats, one ring-buffer for the last 100 interactions.

The entire illusion stands on ≈200 lines of logic and the viewer’s willingness to anthropomorphise.

Implementation in Brief

Layer	Choice & Rationale
Framework	Next.js 14, App Router – static export, zero backend needed
State & I/O	React hooks + `localStorage`
Art Pipeline	In-code SVG sprites (`shapeRendering="crispEdges"`)
Styling	Tailwind; font VT323 for gentle CRT nostalgia
Hosting	Static files on GitHub Pages

Want to expand the universe? Add a PR to the GitHub repo with some new clothing, behaviour, or scenery! Anything to keep Pixl’s world fresh and captivating.

Constraint as a Lens

The contemporary narrative says emergent behaviour requires a datacentre’s worth of silicon. Pixl demurs. Here, a single event-loop— armed only with a clock and three counters—displays recognisable moods, invites care, and even teaches patience through daily limits. The marvel is not that such simplicity suffices but that our minds long to complete the pattern.

Technology, at its most humane, is a conversation between what is specified and what is imagined. Pixl is my contribution to that conversation: a reminder that small, transparent mechanisms can still whisper stories.

As always, if you have any comments, want to chat, kill some time or cook some pancakes, you can always find me on Twitter: @humbertowoody.

Go play with Pixl right now at pixl.humbertowoody.xyz — the code lives on
GitHub if you want to fork, tweak, or time-travel.

Using shapeRendering="crispEdges" forces the browser to snap edges to the pixel grid, preventing the antialias blur that would otherwise undermine the retro aesthetic. ↩
Psychologist Abraham Maslow arranged human needs into five tiers; hunger and fatigue sit at the base, self-actualisation at the apex. Pixl’s rules mirror that order: physiological demands override emotional colour, yet repeated affection can still lift the creature into a tiny state of “ecstatic” selfhood. ↩

Poetry Generation Using Markov Chains

Mon, 01 Jul 2024 00:00:00 +0000

Far from current generation Large Language Models (LLMs) like LLaMA, GPT or BERT, Markov chains offer a simple yet effective method for generating poetry. By analyzing a corpus of text (a poem), we can create a probabilistic model that predicts the next word based on the current word. This post explores a Poetry Generator that uses Markov chains to showcase a blend of technology and creativity.

Poetry Generation Using Markov Chains

Crafting verses with code

The Poetry Generator (poetry.humbertowoody.xyz) is in itself a web application designed to showcase the process of analyzing text, creating a probabilistic model from it, and using that model to generate new text. The application uses Markov chains¹ to generate poems that mimic the style of the original corpus. This project highlights the intersection of technology and creativity, providing a platform where users can visualize the data-driven process behind poetry generation.

Visit the Poetry Generator (poetry.humbertowoody.xyz) to provide a poem, see the transition probabilities between words, and generate new poems based on the input text.

So, what are Markov chains?

Markov chains are mathematical models that predict the next state based on the current state. In the context of text generation, each word represents a state, and the transition to the next word depends on the current word. Here’s how it works:

Corpus Analysis: The application analyzes the provided poem to extract the words and their relationships. For example, given the phrase “the quick brown fox,” the words “the” and “quick” are connected, as are “quick” and “brown,” and so on.
Transition Matrix: A transition matrix is created, where each cell represents the probability of transitioning from one word to another. This way, the model learns the likelihood of each word following another.
Text Generation: Starting with an initial random word, the Markov chain generates the next word based on the transition probabilities. This process continues until the poem reaches a specified length.

By repeating this process, the Poetry Generator creates new poems that capture the stylistic patterns of the original text.

A visual journey through the data

The project provides the user with three visualizations for the transition probabilities between words: a heatmap, a network graph, and a relationship matrix. These visualizations offer different perspectives on the data and highlight the connections between words in the corpus.

Relationship Matrix

This section displays the original code object that represents the transition probabilities between words. Each word contains a list of possible next words and their probabilities. This matrix provides a detailed view of the data structure used to generate the poems, allowing users to inspect the underlying model.

For example, for the following input poem:

The sun sets in the west
And birds return to their nest

The relationship matrix would look like this:

{
  "the": {
    "sun": 1,
    "west": 1
  },
  "sun": {
    "sets": 1
  },
  "sets": {
    "in": 1
  },
  "in": {
    "the": 1
  },
  "west": {
    "and": 1
  },
  "and": {
    "birds": 1
  },
  "birds": {
    "return": 1
  },
  "return": {
    "to": 1
  },
  "to": {
    "their": 1
  },
  "their": {
    "nest": 1
  }
}

This matrix represents the transition probabilities between words in the corpus, with each word mapping to the possible next words and their probabilities.

Heatmap

The heatmap visualizes the transition probabilities between words, with each cell representing the likelihood of transitioning from one word to another. The color intensity indicates the strength of the relationship, allowing users to identify patterns and connections within the text.

Network Graph

The network graph illustrates the words as nodes and the transition probabilities as edges between them. This visualization provides a clear representation of the connections between words, making it easier to identify clusters and relationships within the text. It’s also interactive, allowing users to explore the network, drag nodes, and zoom in for a closer look.

Comparison to Current Generation LLMs

While Markov chains offer a straightforward approach to text generation, current generation Large Language Models (LLMs) like GPT-3.5 provide a more sophisticated and nuanced method. Here’s a comparison:

Simplicity vs. Complexity

Markov Chains: Relatively simple and easy to implement, Markov chains rely on direct probabilities between words. They are effective for capturing local patterns but struggle with long-range dependencies.
LLMs: LLMs, such as GPT-3.5, use deep learning techniques to understand context and generate text. They can capture complex patterns and maintain coherence over longer passages, making them more versatile.

Training Data and Flexibility

Markov Chains: Require a smaller corpus and are less resource-intensive to train. They are ideal for specific tasks like poetry generation where simplicity and artistic value are prioritized.
LLMs: Trained on vast amounts of diverse data, LLMs are flexible and can handle a wide range of text generation tasks, from poetry to technical writing.

Output Quality

Markov Chains: Produce text that mimics the style of the original corpus but may lack depth and coherence over longer texts.
LLMs: Generate high-quality, coherent text that can adapt to various contexts, making them suitable for applications requiring sophisticated language understanding.

Conclusion: Exploring the Poetic Potential of Technology

Markov chains offer a fascinating glimpse into the intersection of technology and creativity. Through the Poetry Generator, users can experience firsthand how a simple probabilistic model can craft delightful verses. This project not only showcases the capabilities of Markov chains but also invites us to ponder the broader implications of machine-generated art. Whether you’re a tech enthusiast or a poetry lover, I hope this journey through data-driven poetry inspires you to explore the poetic potential of statistical models.

Visit the Poetry Generator to try it out yourself and create your own unique poems. As always, thanks for reading!

Markov chains are mathematical models that predict the next state based on the current state. In the context of text generation, each word represents a state, and the transition to the next word depends on the current word. If you want to learn more, check out the Wikipedia page on Markov chains. ↩

SkyPrice: Predicting Apartment Prices in Mexico City

Tue, 04 Jun 2024 00:00:00 +0000

Estimate the price of apartments in Mexico City using regression models trained on current data from the real estate market.

SkyPrice

Introduction

SkyPrice is a web application designed to estimate the prices of apartments in Mexico City using advanced regression models. This project, part of my BSc thesis at ESCOM, IPN, leverages current data from the real estate market to provide accurate price predictions, helping potential buyers and investors make informed decisions.

Visit the SkyPrice website: https://skyprice.xyz to explore the application and learn more about the project.

Motivation

The motivation behind creating SkyPrice was to address the challenges faced in real estate valuation, where accuracy and efficiency are crucial¹. The complexity of the real estate market often makes it difficult to determine appropriate prices, and existing tools do not fully meet the needs of the Mexican market².

Technologies Used

SkyPrice integrates various technologies, including:

Machine Learning (ML) for the regression models trained on real estate data.
FastAPI for backend API development.
React and Next.js with Material-UI for frontend
KeplerGL for data visualization
Telegram API for Chatbot
OpenAI for natural language processing.
Docker for containerization
AWS for deployment

Data

The data for SkyPrice was sourced from various reliable platforms such as datos.gob.mx and the Mexico City data portal. The datasets incorporated include:

Real estate listings with price and property details, extracted from online platforms.
Locations of hospitals, schools, universities, malls, supermarkets.
Historical earthquake data.
Postal codes.
Demographic information.
Acoustic and water contamination data.

Importance of Each Dataset

Each dataset plays a crucial role in the prediction models:

Real estate listings: Provide the core data for price estimation, including property details and prices. This data is used for training and testing the models.
Hospitals, schools, etc.: Influence the desirability and value of the location.
Earthquake data: Important for assessing risk factors.
Demographic information: Help in geospatial analysis and segmentation.

Data Challenges and Solutions

We faced several challenges in data collection and cleaning:

Inconsistencies in data formats: Addressed by standardizing formats during preprocessing.
Missing values: Handled through imputation techniques.
Data integration: Managed by using KeplerGL for seamless visualization and analysis.
Natural language processing: Utilized OpenAI for processing unstructured data in the chatbot.

Methodology

The methodology of SkyPrice involves several key steps:

Data Collection and Cleaning: Gathering data from multiple online platforms and cleaning it to ensure accuracy and consistency.
Model Selection and Training: Using regression models such as SVM, Random Forest, and Neural Network. A grid of hyperparameters was used to fine-tune the models.
Model Evaluation: Comparing the performance of different models using metrics like R², Mean Absolute Error (MAE), and Root Mean Squared Error (RMSE).

The following diagram illustrates the methodology of SkyPrice (in spanish):

Detailed Process

Data Preprocessing: Included handling missing values, normalizing data, and encoding categorical variables.
Feature Selection: Identified key features that impact apartment prices, such as location, size, and proximity to amenities.
Model Training: Used a combination of SVM, Random Forest, and Neural Network with hyperparameter tuning.

Model Performance

We evaluated the models using metrics like R², Mean Absolute Error (MAE), and Root Mean Squared Error (RMSE), and selected the best-performing model based on these evaluations for each algorithm.

The following plots show the predictions vs. actual prices for each model:

Public API

SkyPrice offers a public API built with FastAPI, allowing users to integrate apartment price predictions into their own applications. The API endpoints provide functionalities such as:

Predicting apartment prices based on input features.
Accessing metadata about the model and data.
Retrieving adjustment plots for the models (as shown above).

The API is deployed on AWS and is accessible at https://api.skyprice.xyz.

The public API is intended to be “fair use” and is available for free to users who comply with the terms of service, which include rate limiting and proper attribution.

API Documentation

In this blog post, we provide a brief overview of the API endpoints and their functionality. The API documentation is available through Swagger UI and Redoc, providing detailed information on the available endpoints and their usage.

You can access each of the following API documentation interfaces:

In the following image you can see both the Swagger UI and Redoc interfaces:

Predict Endpoint

The /predict endpoint allows users to input property details and get price predictions. The input JSON should include the following fields:

Size_Terrain: Size of the terrain in square meters.
Size_Construction: Size of the construction in square meters.
Bedrooms: Number of bedrooms.
Bathrooms: Number of bathrooms.
Parking: Number of parking spaces.
Age: Age of the property in years.
Lat: Latitude of the property.
Lon: Longitude of the property.
Municipality: Municipality where the property is located.

And the output JSON will include the predicted price for each model, allowing users to compare the predictions.

Example API Request

{
  "Size_Terrain": 140,
  "Size_Construction": 130,
  "Bedrooms": 3,
  "Bathrooms": 2,
  "Parking": 2,
  "Age": 7,
  "Lat": 19.4326,
  "Lon": -99.1332,
  "Municipality": "Álvaro Obregón"
}

Example API Response

{
  "Random_Forest": 6420750.0,
  "SVM": 6164968.58,
  "Neural_Network": 5167572.5
}

Metadata Endpoint

The /models endpoint provides metadata about the models used in the API, including information about the features, hyperparameters, and evaluation metrics. It also includes information about the data used for training the models.

Example Metadata Response

{
  "dataset": {
    "original": [32520, 18],
    "training": {
      "X": [11169, 9],
      "y": [11169, 1]
    },
    "testing": {
      "X": [3724, 9],
      "y": [3724, 1]
    }
  },
  "models": {
    "random_forest": {
      "mse": 2767108007816.376,
      "rmse": 1663462.6559728885,
      "ci": [-3288575.5823341985, 3232135.171812599],
      "mae": 704079.571484675,
      "r2": 0.9038900065218292,
      "feature_importances": [
        0.0011281899895630631, 0.0017738994702383077, 0.0019866359182250486,
        0.0007018637582167237, 0.0014665387673904304, 0.0023498577692012985,
        0.00004089436452670091, 0.000018750183784930174,
        0.000025032684545761422, 0.0001471126291344862, 0.0022393854044217604,
        0, 0.0000018591757405458183, 0.00033878248531502486,
        0.000024947352434527034, 0.000004803359328795989, 0.10737325614938063,
        0.6581596171662714, 0.018088970068768237, 0.0078064922484012405,
        0.011072231256017567, 0.06306614405016867, 0.05947059290138905,
        0.06271414284753582
      ],
      "max_features": 1,
      "max_depth": 30,
      "n_estimators": 1000,
      "oob_score": true
    },
    "svm": {
      "mse": 8718507842976.787,
      "rmse": 2952711.947172766,
      "ci": [-6072782.238924998, 5435880.829712623],
      "mae": 1843353.6959805356,
      "r2": 0.697179969281674,
      "kernel": "linear",
      "C": 1000,
      "epsilon": 0.01
    },
    "neural_network": {
      "mse": 6774725145058.313,
      "rmse": 2602830.2182544125,
      "ci": [-5522911.848758079, 4471074.026658187],
      "mae": 1597042.1520542428,
      "r2": 0.637984037399292,
      "learning_rate": 0.10000000149011612,
      "beta_1": 0.9,
      "beta_2": 0.999,
      "epsilon": 1e-7
    }
  }
}

Web Application

The web application for SkyPrice is developed using React and Next.js with Material-UI for a responsive and user-friendly interface. Key features of the application include:

Price Prediction Tool: Users can input property details and get instant price predictions.
Interactive Map: Integrated with KeplerGL to visualize apartment listings and nearby amenities, hospitals, schools, etc.
Model and project information: Provides details about the models used, data sources, and methodology.

User Interface Design

The web application emphasizes usability and accessibility, with features like:

Responsive Design: Ensures usability across devices.
User-friendly Forms: Simplifies the input process for users.
Visual Data Representation: Helps users easily interpret the data and predictions.
Translatable Content: Supports multiple languages for a wider audience ( Spanish, French, Portuguese, English).

Price Prediction Tool

The price prediction tool allows users to input property details and get instant price estimates based on the trained models. Users can compare the predictions from different models and make informed decisions.

In the following image, you can see the price prediction tool form:

Now let’s see an example of the results obtained from the price prediction tool:

Currency Conversion

The prices are displayed in Mexican Pesos (MXN), but the application also provides a currency conversion feature that allows users to view the prices in other currencies, such as USD, EUR, or CAD.

Interactive Map

The interactive map provides a visual representation of apartment listings and nearby amenities, such as hospitals, schools, and supermarkets. Users can explore the map to understand the distribution of properties and their proximity to essential services.

By integrating KeplerGL, we were able to create an interactive map that provides valuable insights into the real estate market in Mexico City while also allowing users to explore the data in a user-friendly manner.

If you want to explore the interactive map, you can visit the SkyPrice website: https://skyprice.xyz.

Model Information

The web application also includes detailed information about the models used for price prediction, the data sources, and the methodology followed. This section provides transparency and helps users understand the process behind the price predictions.

In the following image, you can see the model information section, particularly the charts showing the models used and their performance:

Telegram Chatbot

SkyPrice features an advanced Telegram chatbot, “SkyPriceChatbot,” which leverages the power of natural language processing using GPT-3.5. This chatbot connects to the SkyPrice API and provides users with instant price predictions. While the primary language for instructions is Spanish, the chatbot can interpret multiple languages.

You can access the chatbot in Telegram by searching for @SkyPriceChatbot or using the following URL: https://t.me/SkyPriceChatbot.

Setup and Features

Easy Setup: Start using the chatbot by adding it on Telegram.
Multilingual Support: Though instructions are in Spanish, the chatbot can understand other languages.
Quick Predictions: Get instant price estimates by providing property details.
Link to Web Application: Users can access the web application for more detailed information and analysis.

Example Interaction

The chatbot tries to extract the necessary information from the user’s input and provides a detailed response with price predictions. Here’s an example interaction:

User: “Quiero saber el precio de un departamento en Álvaro Obregón con 3 recámaras, 2 baños y 2 estacionamientos, de 140m² de terreno y 130m² de construcción, con 7 años de antigüedad.”³

SkyPriceChatbot:

🏢 Detalles del departamento extraídos:

📏 Tamaño del terreno: 140m²
🏗️ Tamaño de la construcción: 130m²
🛏️ Número de habitaciones: 3
🚽 Número de baños: 2.5
🚗 Número de estacionamientos: 2
🕰️ Antigüedad: 7 años
🌍 Alcaldía: Álvaro Obregón

💰 Precios estimados:

🌳 Random Forest: $6,420,750.00 MXN
📈 SVM: $6,164,968.58 MXN
🧠 Neural Network: $5,167,572.50 MXN

🔍 Puedes encontrar más detalles en https://skyprice.xyz 🏡

⁴

Methodology and Implementation

The chatbot’s functionality is divided into three main components:

Natural Language Processing: The chatbot uses OpenAI’s GPT-3.5 for natural language processing to understand user queries and extract the required information for the SkyPrice API.
API Integration: The chatbot connects to the SkyPrice API to retrieve price predictions based on the user’s input.
Response Generation: The chatbot generates a detailed response with the extracted property details and price predictions.

Conclusion

SkyPrice represents a comprehensive approach to predicting apartment prices in Mexico City, combining data science, machine learning, and web development. This project not only serves as a valuable tool for users but also showcases the integration of multiple technologies to solve real-world problems.

Impact and Lessons Learned

SkyPrice has demonstrated the potential of machine learning in real estate valuation. Throughout the project, we learned about the importance of data quality, feature engineering, and model evaluation.

Future Enhancements

SkyPrice has great potential for future enhancements, such as:

Incorporating more sophisticated machine learning models: Exploring deep learning techniques for improved accuracy.
Expanding to other cities: Adapting the model for use in other metropolitan areas.
Improving user interaction: Enhancing the chatbot with more functionalities and extending it to other messaging platforms and extending the web application to provide better market-analysis tools.
Integrating additional data sources: Incorporating more data for better predictions.
Predict other real estate property types: Extend the model to predict the prices of houses, commercial properties, etc.

E. Pagourtzi, V. Assimakopoulos, and T. Hatzichristos, “Real estate appraisal: a review of valuation methods,” J. Property Invest. Finance, vol. 21, no. 4, pp. 383–401, 2003. ↩
Z. Nedović-Budić, A. K. Pinto, and L. D. Budic, “Gis database deve- lopment and exchange: Interaction mechanisms and motivations,” J. Urban Plan. Dev., vol. 126, no. 2, pp. 51–73, 2000. ↩
“I want to know the price of an apartment in Álvaro Obregón with 3 bedrooms, 2 bathrooms, and 2 parking spaces, 140m² of land and 130m² of construction, 7 years old.” ↩
- 🏢 Apartment details extracted:
- 📏 Land size: 140m²
- 🏗️ Construction size: 130m²
- 🛏️ Number of bedrooms: 3
- 🚽 Number of bathrooms: 2.5
- 🚗 Number of parking spaces: 2
- 🕰️ Age: 7 years
- 🌍 Borough: Álvaro Obregón
- 💰 Estimated prices:
- 🌳 Random Forest: $6,420,750.00 MXN
- 📈 SVM: $6,164,968.58 MXN
- 🧠 Neural Network: $5,167,572.50 MXN
- 🔍 You can find more details at https://skyprice.xyz 🏡
↩

Maze generator game in C

Fri, 07 Apr 2023 00:00:00 +0000

Writing an interactive Maze generator is a task that helps to illustrate various computer science concepts in a simple way. This is a C implementation based of one school project I did a while ago.

Introduction

During my school subject of Operating Systems we had to write a simple program demonstrating the usage for the ncurses library. I choose to write a Maze generator and it turned out to be a really great challenge and fun project.

Maze generation is a really interesting area of application of diverse algorithms and user interaction techniques for it to become a game. I will try to share with you how to write a maze game using the C language and the ncurses library.

The game should generate a random maze and allow the player to navigate through it using the arrow keys. The goal is for the user to reach the finish point. Let’s dive into the code!

Libraries and Constants

The very first thing we need to do is to include the ncessary libraries and define the constatns required for the game:

// Libraries
#include <stdio.h>      // We need standard I/O!
#include <ncurses.h>    // 🪄 magic for our text UI! 🪄
#include <time.h>       // We need to have a random(ish) seed for our map generation!
#include <stdlib.h>     // We use `malloc()` and such.

// Constants
#define WALL_CHAR         '#' // The character to show as a wall.
#define EMPTY_CHAR        ' ' // The character to show as an empty space.
#define PLAYER_CHAR       '@' // The character to show a player.
#define GOAL_CHAR         'G' // The character to show at the finish point!
#define DIRECTION_UP      0   // The int ID for up direction.
#define DIRECTION_LEFT    1   // The int ID for left direction.
#define DIRECTION_RIGHT   2   // The int ID for right direction.
#define DIRECTION_DOWN    3   // The int ID for down direction.
#define EXIT_OPTION_LOWER 'q' // Lowercase letter for exiting the game.
#define EXIT_OPTION_UPPER 'Q' // Uppercase letter for quitting the game.

In the libraries section, we include ncurses.h in order to use the ncurses library and manipulate more efficiently our terminal interface. We also have time.h over there because we’ll have to initilize the random seed for our map using functions from that library.

The constants defined are for redifining the characters we use to display the map, the direction ID’s and the letter that quits the game.

Enumerations and Structures

We define an enumeration CellContent for the cell’s content and a structure Cell to represent the maze cells:

enum CellContent {
    Wall,
    Empty,
    Player,
    Goal
};

typedef struct Cell{
    int row,    // Y coordinate.
        column; // X coordinate.
    enum CellContent content;
} Cell;

Each cell has to be in one of the following states: Wall, Empty, Player or Goal. We are going to be working with cartesian coordinates for the map so we store the row and column for each Cell.

Function Prototypes

By declaring our prototypes at the top of the file we can use the functions in our main() code without having to implement the function there (it doesn’t even need to be in the same file!).

With just the signatures we’re able to grasp what the print_map, depth_first_search and get_available_directions do:

void print_map(WINDOW *maze_window, int rows, int cols, Cell **map);
void depth_first_search(int current_row, int current_col, int rows, int cols, Cell **map);
void get_available_directions(int current_row, int current_col, int rows, int cols, Cell **map, int available_directions[4]);

However, if you’d like, you can jump into the implementation section where you can find the details of what (and why) each function does what it does.

Main Function

The main function does a bunch of stuff:

Initializes the ncurses’ screen.
Allocates memory for the maze.
Generates a random maze using Depth-First Search.
Handles the player’s input to move through the maze.

Many other things happen under the hood, but they’re mostly ramifications of those ones. Take a look:

int main()
{
    WINDOW *maze_window; // ncurses Window.
    int rows,             // The amount of rows in the screen.
        cols,             // The amount of columns in the screen.
        current_row,      // The current row for iterations.
        current_col,      // The current column for iterations.
        maze_window_rows, // The amount of rows in the maze window.
        maze_window_cols; // The amount of columns in the maze window.
    int player_row = 1,   // The  current row of the player.
        player_col = 1,   // The current column of the player.
        goal_row,         // The row for the goal.
        goal_col,         // The column for the goal.
        key_pressed;      // The ID of the key pressed by the user.
    Cell **map;           // The map is a matrix of Cells.

    // Initialize the random seed.
    srand(time(NULL));

    // Initialize the screen.
    initscr();

    // Get the maximum amount of rows and columns for the current screen.
    getmaxyx(stdscr, rows, cols);

    // Calculate the amount of rows and columns available (margin).
    maze_window_rows = rows - 2;
    maze_window_cols = cols - 2;

    // Allocate memory for the array of pointers (arrays).
    map = malloc(maze_window_rows * sizeof(*map));

    // Allocate memory for each row.
    for (current_row = 0; current_row < maze_window_rows; current_row++)
    {
        map[current_row] = malloc(maze_window_cols * sizeof *map[current_row]);
    }

    // Clear the screen.
    clear();

    // Deactivate the "echo" function of the prompt.
    noecho();

    // Eliminate the breaks.
    cbreak();

    // Create the window.
    maze_window = newwin(maze_window_rows, maze_window_cols, 2, 1);

    // Associate the keypad to the window.
    keypad(maze_window, TRUE);

    // Print simple information.
    mvprintw(0, 0, "Dynamic Maze using ncurses.h - ESCOM Operating Systems");
    mvprintw(1, 0, "Use the arrow keys to move through the window, reach the goal '%c' to win or press '%c' to exit.", GOAL_CHAR, EXIT_OPTION_LOWER);

    // Refresh the screen to show the changes.
    refresh();

    // We randomly generate the maze by using a custom DFS function which will
    // go through the map and _carve_ its path through it.
    depth_first_search(1, 1, maze_window_rows, maze_window_cols, map);

    // Set the player in the map.
    map[player_row][player_col].content = Player;

    // Set the goal location in the map, the condition is to deal with odd sizes.
    if (map[maze_window_rows - 1][maze_window_cols - 1].content == Empty)
    {
        goal_row = maze_window_rows - 1;
        goal_col = maze_window_cols - 1;
    }
    else
    {
        goal_row = maze_window_rows - 2;
        goal_col = maze_window_cols - 2;
    }
    map[goal_row][goal_col].content = Goal;

    // Print the initial map.
    print_map(maze_window, maze_window_rows, maze_window_cols, map);

    // While the player doesn't reach the goal...
    while (player_row != goal_row || player_col != goal_col)
    {
        // Get the key pressed by the user.
        key_pressed = wgetch(maze_window);

        // Erase the user from it's current position.
        map[player_row][player_col].content = Empty;

        // Act based on the key entered.
        switch (key_pressed)
        {
        case KEY_UP:
            if (player_row > 1 && map[player_row - 1][player_col].content != Wall)
            {
                player_row -= 1;
            }
            break;

        case KEY_DOWN:
            if (player_row < (maze_window_rows - 1) && map[player_row + 1][player_col].content != Wall)
            {
                player_row += 1;
            }
            break;

        case KEY_LEFT:
            if (player_col > 1 && map[player_row][player_col - 1].content != Wall)
            {
                player_col -= 1;
            }
            break;

        case KEY_RIGHT:
            if (player_col < (maze_window_cols - 1) && map[player_row][player_col + 1].content != Wall)
            {
                player_col += 1;
            }
            break;

        case EXIT_OPTION_UPPER:
        case EXIT_OPTION_LOWER:
            // Set the coordinates to win to break the loop.
            player_col = goal_col;
            player_row = goal_row;
            break;
        }

        // Set the position of the player in the map.
        map[player_row][player_col].content = Player;

        // Print the map.
        print_map(maze_window, maze_window_rows, maze_window_cols, map);
    }

    // If the user won or lost, end the window.
    endwin();

    // Free the memory allocated to each row within the map.
    for (current_row = 0; current_row < maze_window_rows; current_row++)
    {
        free(map[current_row]);
    }

    // Now free the map itself.
    free(map);

    // Print a simple message.
    printf("Congratulations! You reached the goal!\n");

    // End the execution.
    return 0;
}

Helper Functions

Remember the functions’ prototypes we declared earlier? It’s time to look at the implementation. Each function is written with simplicity in mind, however you may have to look into the main function section to trace where is everything getting called.

Printing the map

The print_map function does what it’s name says, maybe the only peculiarities regarding this implementation is that we need to map our current map into the size of the maze_window, other than that is read-and-display.

void print_map(WINDOW *maze_window, int rows, int cols, Cell **map)
{
    int row, col;

    // We iterate through each row.
    for (row = 0; row < rows; row++)
    {
        // We iterate throgh each column in each row.
        for (col = 0; col < cols; col++)
        {
            // Switch the content of the Cell.
            switch (map[row][col].content)
            {
            case Wall:
                mvwaddch(maze_window, row, col, WALL_CHAR);
                break;

            case Empty:
                mvwaddch(maze_window, row, col, EMPTY_CHAR);
                break;

            case Player:
                mvwaddch(maze_window, row, col, PLAYER_CHAR);
                break;

            case Goal:
                mvwaddch(maze_window, row, col, GOAL_CHAR);
                break;

            default:
                mvwaddch(maze_window, row, col, '?');
            }
        }
    }

    // We have to refresh the window to show our changes in the screen.
    wrefresh(maze_window);
}

Depth-First Search (DFS)

We use a modified version of the well-known Depth-First Search algorithm (known also as DFS) to get a random maze generated when the game starts. If you see our main program we initialize the map by filling it in with the Wall enumeration value. Our DFS will try to carve into the map the valid pathways for the player to navigate. Let’s see the definition:

void depth_first_search(int current_row, int current_col, int rows, int cols, Cell **map)
{
    int available_directions[4] = {0, 0, 0, 0}, // Array for storing the available directions for each cell.
        direction; // The selected direction.

    do
    {
        // Set the current location as Empty.
        map[current_row][current_col].content = Empty;

        // Get the UPDATED and available directions for the current Cell.
        get_available_directions(current_row, current_col, rows, cols, map, available_directions);

        // Check for the base case for our recursion: no available directions.
        if (!available_directions[DIRECTION_UP] && !available_directions[DIRECTION_DOWN] && !available_directions[DIRECTION_LEFT] && !available_directions[DIRECTION_RIGHT]);
        {
            // Bye bye!
            return;
        }

        // Get a random, avilable, direction.
        do
        {
            // Random value between 0 and 4 (0-3).
            direction = rand() % 4;
        } while(availble_directions[direction] == 0); // While the random direction is a not available direction.

        // We move to the next Cell based on the direction.
        switch(direction)
        {
        case DIRECTION_UP:
            // Carve the wall with a space to walk through.
            map[current_row - 1][current_col].content = Empty;

            // Move recursively to the next Cell.
            depth_first_search(current_row - 2, current_col, rows, cols, map);
            break;
        case DIRECTION_LEFT:
            // Carve the wall with a space to walk through.
            map[current_row][current_col - 1].content = Empty;

            // Move recursively to the next Cell.
            depth_first_search(current_row, current_col - 2, rows, cols, map);
            break;
        case DIRECTION_RIGHT:
            // Carve the wall with a space to walk through.
            map[current_row][current_col + 1].content = Empty;

            // Move recursively to the next Cell.
            depth_first_search(current_row, current_col + 2, rows, cols, map);
            break;
        case DIRECTION_DOWN:
            // Carve the wall with a space to walk through.
            map[current_row + 1][current_col].content = Empty;

            // Move recursively to the next Cell.
            depth_first_search(current_row + 2, current_col, rows, cols, map);
            break;
        }
    } while (available_directions[DIRECTION_UP] || available_directions[DIRECTION_DOWN] || available_directions[DIRECTION_LEFT] || available_directions[DIRECTION_RIGHT])
}

So what we are doing here is:

Set the current position as empty.
Get the available_directions for our current Cell.
Check for the base case of recursion: no directions available.
Select pseudo-randomly¹ a direction.
Carve an Empty space between our current Cell and our destination.
Repeat from 1 until there are no available directions.

Get available directions

Each Cell can have four available directions (ideally): DIRECTION_UP, DIRECTION_DOWN, DIRECTION_RIGHT and DIRECTION_LEFT. A direction is available if, 2 blocks from our Cell, in the direction we’re testing, the Cell is a Wall.

// Get the available directions for a cell.
void get_available_directions(int current_row, int current_col, int rows, int cols, Cell **map, int available_directions[4])
{
    // DIRECTION_UP
    if ((current_row - 2) >= 1 && map[current_row - 2][current_col].content == Wall)
    {
        available_directions[DIRECTION_UP] = 1;
    }
    else
    {
        available_directions[DIRECTION_UP] = 0;
    }

    // DIRECTION_DOWN
    if ((current_row + 2) <= (rows - 2) && map[current_row + 2][current_col].content == Wall)
    {
        available_directions[DIRECTION_DOWN] = 1;
    }
    else
    {
        available_directions[DIRECTION_DOWN] = 0;
    }

    // DIRECTION_RIGHT
    if ((current_col + 2) <= (cols - 2) && map[current_row][current_col + 2].content == Wall)
    {
        available_directions[DIRECTION_RIGHT] = 1;
    }
    else
    {
        available_directions[DIRECTION_RIGHT] = 0;
    }

    // DIRECTION_LEFT
    if ((current_col - 2) >= 1 && map[current_row][current_col - 2].content == Wall)
    {
        available_directions[DIRECTION_LEFT] = 1;
    }
    else
    {
        available_directions[DIRECTION_LEFT] = 0;
    }
}

Compilation

In order to compile this program we need to have the ncurses library installed, for this you can follow the online instructions for your specific operating system.

If you’re on macOS and using Homebrew, you just need to run the following command:brew install libncurses

Once instaled the compilation flag required for linking our project is: -lncurses.

The final command looks like this:

1	$ gcc -o MazeGame.out -lncurses MazeGame.c

Execution

It’s time for the show time! Here are some screen captures of the mazes generated by the game:

And now here’s a GIF of me winning a game:

Final Code

The final code for this simple project is:

// Libraries
#include <stdio.h>      // We need standard I/O!
#include <ncurses.h>    // 🪄 magic for our text UI! 🪄
#include <time.h>       // We need to have a random(ish) seed for our map generation!
#include <stdlib.h>     // We use `malloc()` and such.

// Constants
#define WALL_CHAR         '#' // The character to show as a wall.
#define EMPTY_CHAR        ' ' // The character to show as an empty space.
#define PLAYER_CHAR       '@' // The character to show a player.
#define GOAL_CHAR         'G' // The character to show at the finish point!
#define DIRECTION_UP      0   // The int ID for up direction.
#define DIRECTION_LEFT    1   // The int ID for left direction.
#define DIRECTION_RIGHT   2   // The int ID for right direction.
#define DIRECTION_DOWN    3   // The int ID for down direction.
#define EXIT_OPTION_LOWER 'q' // Lowercase letter for exiting the game.
#define EXIT_OPTION_UPPER 'Q' // Uppercase letter for quitting the game.

// Enumerations and Structures.
enum CellContent {
    Wall,
    Empty,
    Player,
    Goal
};

typedef struct Cell{
    int row,    // Y coordinate.
        column; // X coordinate.
    enum CellContent content;
} Cell;

// Function prototypes.
void print_map(WINDOW *maze_window, int rows, int cols, Cell **map);
void depth_first_search(int current_row, int current_col, int rows, int cols, Cell **map);
void get_available_directions(int current_row, int current_col, int rows, int cols, Cell **map, int available_directions[4]);

int main()
{
    WINDOW *maze_window; // ncurses Window.
    int rows,             // The amount of rows in the screen.
        cols,             // The amount of columns in the screen.
        current_row,      // The current row for iterations.
        current_col,      // The current column for iterations.
        maze_window_rows, // The amount of rows in the maze window.
        maze_window_cols; // The amount of columns in the maze window.
    int player_row = 1,   // The  current row of the player.
        player_col = 1,   // The current column of the player.
        goal_row,         // The row for the goal.
        goal_col,         // The column for the goal.
        key_pressed;      // The ID of the key pressed by the user.
    Cell **map;           // The map is a matrix of Cells.

    // Initialize the random seed.
    srand(time(NULL));

    // Initialize the screen.
    initscr();

    // Get the maximum amount of rows and columns for the current screen.
    getmaxyx(stdscr, rows, cols);

    // Calculate the amount of rows and columns available (margin).
    maze_window_rows = rows - 2;
    maze_window_cols = cols - 2;

    // Allocate memory for the array of pointers (arrays).
    map = malloc(maze_window_rows * sizeof(*map));

    // Allocate memory for each row.
    for (current_row = 0; current_row < maze_window_rows; current_row++)
    {
        map[current_row] = malloc(maze_window_cols * sizeof *map[current_row]);
    }

    // Clear the screen.
    clear();

    // Deactivate the "echo" function of the prompt.
    noecho();

    // Eliminate the breaks.
    cbreak();

    // Create the window.
    maze_window = newwin(maze_window_rows, maze_window_cols, 2, 1);

    // Associate the keypad to the window.
    keypad(maze_window, TRUE);

    // Print simple information.
    mvprintw(0, 0, "Dynamic Maze using ncurses.h - ESCOM Operating Systems");
    mvprintw(1, 0, "Use the arrow keys to move through the window, reach the goal '%c' to win or press '%c' to exit.", GOAL_CHAR, EXIT_OPTION_LOWER);

    // Refresh the screen to show the changes.
    refresh();

    // We randomly generate the maze by using a custom DFS function which will
    // go through the map and _carve_ its path through it.
    depth_first_search(1, 1, maze_window_rows, maze_window_cols, map);

    // Set the player in the map.
    map[player_row][player_col].content = Player;

    // Set the goal location in the map, the condition is to deal with odd sizes.
    if (map[maze_window_rows - 1][maze_window_cols - 1].content == Empty)
    {
        goal_row = maze_window_rows - 1;
        goal_col = maze_window_cols - 1;
    }
    else
    {
        goal_row = maze_window_rows - 2;
        goal_col = maze_window_cols - 2;
    }
    map[goal_row][goal_col].content = Goal;

    // Print the initial map.
    print_map(maze_window, maze_window_rows, maze_window_cols, map);

    // While the player doesn't reach the goal...
    while (player_row != goal_row || player_col != goal_col)
    {
        // Get the key pressed by the user.
        key_pressed = wgetch(maze_window);

        // Erase the user from it's current position.
        map[player_row][player_col].content = Empty;

        // Act based on the key entered.
        switch (key_pressed)
        {
        case KEY_UP:
            if (player_row > 1 && map[player_row - 1][player_col].content != Wall)
            {
                player_row -= 1;
            }
            break;

        case KEY_DOWN:
            if (player_row < (maze_window_rows - 1) && map[player_row + 1][player_col].content != Wall)
            {
                player_row += 1;
            }
            break;

        case KEY_LEFT:
            if (player_col > 1 && map[player_row][player_col - 1].content != Wall)
            {
                player_col -= 1;
            }
            break;

        case KEY_RIGHT:
            if (player_col < (maze_window_cols - 1) && map[player_row][player_col + 1].content != Wall)
            {
                player_col += 1;
            }
            break;

        case EXIT_OPTION_UPPER:
        case EXIT_OPTION_LOWER:
            // Set the coordinates to win to break the loop.
            player_col = goal_col;
            player_row = goal_row;
            break;
        }

        // Set the position of the player in the map.
        map[player_row][player_col].content = Player;

        // Print the map.
        print_map(maze_window, maze_window_rows, maze_window_cols, map);
    }

    // If the user won or lost, end the window.
    endwin();

    // Free the memory allocated to each row within the map.
    for (current_row = 0; current_row < maze_window_rows; current_row++)
    {
        free(map[current_row]);
    }

    // Now free the map itself.
    free(map);

    // Print a simple message.
    printf("Congratulations! You reached the goal!\n");

    // End the execution.
    return 0;
}

// Helper functions.

// Print the map.
void print_map(WINDOW *maze_window, int rows, int cols, Cell **map)
{
    int row, col;

    // We iterate through each row.
    for (row = 0; row < rows; row++)
    {
        // We iterate throgh each column in each row.
        for (col = 0; col < cols; col++)
        {
            // Switch the content of the Cell.
            switch (map[row][col].content)
            {
            case Wall:
                mvwaddch(maze_window, row, col, WALL_CHAR);
                break;

            case Empty:
                mvwaddch(maze_window, row, col, EMPTY_CHAR);
                break;

            case Player:
                mvwaddch(maze_window, row, col, PLAYER_CHAR);
                break;

            case Goal:
                mvwaddch(maze_window, row, col, GOAL_CHAR);
                break;

            default:
                mvwaddch(maze_window, row, col, '?');
            }
        }
    }

    // We have to refresh the window to show our changes in the screen.
    wrefresh(maze_window);
}

// Depth-First Search to randomly generate the Maze map.
void depth_first_search(int current_row, int current_col, int rows, int cols, Cell **map)
{
    int available_directions[4] = {0, 0, 0, 0}, // Array for storing the available directions for each cell.
        direction; // The selected direction.

    do
    {
        // Set the current location as Empty.
        map[current_row][current_col].content = Empty;

        // Get the UPDATED and available directions for the current Cell.
        get_available_directions(current_row, current_col, rows, cols, map, available_directions);

        // Check for the base case for our recursion: no available directions.
        if (!available_directions[DIRECTION_UP] && !available_directions[DIRECTION_DOWN] && !available_directions[DIRECTION_LEFT] && !available_directions[DIRECTION_RIGHT]);
        {
            // Bye bye!
            return;
        }

        // Get a random, avilable, direction.
        do
        {
            // Random value between 0 and 4 (0-3).
            direction = rand() % 4;
        } while(availble_directions[direction] == 0); // While the random direction is a not available direction.

        // We move to the next Cell based on the direction.
        switch(direction)
        {
        case DIRECTION_UP:
            // Carve the wall with a space to walk through.
            map[current_row - 1][current_col].content = Empty;

            // Move recursively to the next Cell.
            depth_first_search(current_row - 2, current_col, rows, cols, map);
            break;
        case DIRECTION_LEFT:
            // Carve the wall with a space to walk through.
            map[current_row][current_col - 1].content = Empty;

            // Move recursively to the next Cell.
            depth_first_search(current_row, current_col - 2, rows, cols, map);
            break;
        case DIRECTION_RIGHT:
            // Carve the wall with a space to walk through.
            map[current_row][current_col + 1].content = Empty;

            // Move recursively to the next Cell.
            depth_first_search(current_row, current_col + 2, rows, cols, map);
            break;
        case DIRECTION_DOWN:
            // Carve the wall with a space to walk through.
            map[current_row + 1][current_col].content = Empty;

            // Move recursively to the next Cell.
            depth_first_search(current_row + 2, current_col, rows, cols, map);
            break;
        }
    } while (available_directions[DIRECTION_UP] || available_directions[DIRECTION_DOWN] || available_directions[DIRECTION_LEFT] || available_directions[DIRECTION_RIGHT])
}

// Get the available directions for a cell.
void get_available_directions(int current_row, int current_col, int rows, int cols, Cell **map, int available_directions[4])
{
    // DIRECTION_UP
    if ((current_row - 2) >= 1 && map[current_row - 2][current_col].content == Wall)
    {
        available_directions[DIRECTION_UP] = 1;
    }
    else
    {
        available_directions[DIRECTION_UP] = 0;
    }

    // DIRECTION_DOWN
    if ((current_row + 2) <= (rows - 2) && map[current_row + 2][current_col].content == Wall)
    {
        available_directions[DIRECTION_DOWN] = 1;
    }
    else
    {
        available_directions[DIRECTION_DOWN] = 0;
    }

    // DIRECTION_RIGHT
    if ((current_col + 2) <= (cols - 2) && map[current_row][current_col + 2].content == Wall)
    {
        available_directions[DIRECTION_RIGHT] = 1;
    }
    else
    {
        available_directions[DIRECTION_RIGHT] = 0;
    }

    // DIRECTION_LEFT
    if ((current_col - 2) >= 1 && map[current_row][current_col - 2].content == Wall)
    {
        available_directions[DIRECTION_LEFT] = 1;
    }
    else
    {
        available_directions[DIRECTION_LEFT] = 0;
    }
}

If you’re interested in reading my class project from which all of this is based on, you can visit the GitHub Repository for it:

https://github.com/humbertowoody/sistemas-operativos-escom/blob/main/practicas/practica-7/Programa71.c

Thank you for reading!

As you can imagine, generating real random numbers is a bit of a hassle in computer science. We must assume the output of rand() to be a pseudo-random value. If you have more questions about it you can read it’s documentation at: https://en.cppreference.com/w/c/numeric/random/rand ↩

Parametric approach to visualize parabolic trajectories

Thu, 06 Apr 2023 00:00:00 +0000

Join me with a Python-based project that helps visualize parabolic trajectories with user-defined impact points and maximum heights. We’ll talk about the underlying math, parametric equations, and visualization techniques to enhance your understanding of parabolic motion.

Visualizing a Parabola with a Given Impact Point

In this blog post, we will explore a project that calculates the parametric equation of a parabola and visualizes it in three-dimensional space, given a user-defined impact point and maximum height. We will begin with a brief introduction to the mathematics behind the problem and then delve into the details of the project.

Mathematical Background

The problem we are trying to solve involves finding a parabolic trajectory that passes through an origin $(0, 0, 0)$ , reaches a given maximum height $h_{max}$ , and lands at a user-defined impact point $(x_f, y_f, 0)$ . To do this, we will use parametric equations to describe the parabola in three-dimensional space. These equations are as follows:

x = at^2 + bt + c

y = dt^2 + et + f

z = gt^2 + ht + i

Where $t$ is the parameter that varies along the trajectory.

We know three points on our parabola: the origin $(0, 0, 0)$ , the maximum point $(\frac{x_f}{2}, \frac{y_f}{2}, h_{max})$ , and the impact point $(x_f, y_f, 0)$ . Using these points, we can set up a system of linear equations for each dimension to solve for the coefficients $a$ , $b$ , $c$ , $d$ , $e$ , $f$ , $g$ , $h$ , and $i$ .

Once we have these coefficients, we can construct the parametric equation of the parabolic trajectory as follows:

(x(t), y(t), z(t))

Which can be rewritten as:

(at^2 + bt + c, dt^2 + et + f, gt^2 + ht + i)

This equation can be directly inputted into graphing software like GeoGebra (or similar) to visualize the trajectory and manipulate it dynamically:

(at^2 + bt + c, dt^2 + et + f, gt^2 + ht + i)

Project Overview

The project takes a user-defined impact point $(x, y)$ and the maximum height ( $h_{max}$ ), calculates the parametric equation describing the parabola, and then visualizes the resulting graph in three-dimensional space.

Technologies

Python
Libraries:
- matplotlib
- numpy

Dependencies

To install the dependencies:

$ pip install -r requirements.txt

Execution

To run the program:

$ python main.py

Users will need to input the following data:

$x$ coordinate of the impact point: any real number.
$y$ coordinate of the impact point: any real number.
Maximum height ( $h_{max}$ ) of the parabolic trajectory.

Source code

import matplotlib.pyplot as plt
import numpy as np

# Entradas del usuario.
xf = float(input("Coordenada x final: "))
yf = float(input("Coordenada y final: "))
hmax = float(input("Altura máxima: "))

# Planteamiento de matrices del sistema de ecuaciones lineales.
primerMatriz = np.array([
    [0, 0, 1],
    [(xf/2)**2, xf/2, 1],
    [xf**2, xf, 1]
])
segundaMatriz = np.array([
    [0, 0, 1],
    [(xf/2)**2, xf/2, 1],
    [xf**2, xf, 1]
])
tercerMatriz = np.array([
    [0, 0, 1],
    [(xf/2)**2, xf/2, 1],
    [xf**2, xf, 1]
])

# Términos independientes para nuestro sistema de ecuaciones lineales.
terminosIndependientes1 = np.array([0, xf/2, xf])
terminosIndependientes2 = np.array([0, yf/2, yf])
terminosIndependientes3 = np.array([0, hmax, 0])

# Cálculo de las soluciones de los sistemas 3x3
solucionesX = np.linalg.solve(primerMatriz, terminosIndependientes1)
solucionesY = np.linalg.solve(segundaMatriz, terminosIndependientes2)
solucionesZ = np.linalg.solve(tercerMatriz, terminosIndependientes3)

# Imprimir en la terminal la ecuación paramétrica de la parábola resultante.
print("Ecuación paramétrica:")
print(f"({solucionesX[0]:.2f}t²+{solucionesX[1]:.2f}t+{solucionesX[2]:.2f}, {solucionesY[0]:.2f}t²+{solucionesY[1]:.2f}t+{solucionesY[2]:.2f}, {solucionesZ[0]:.2f}t²+{solucionesZ[1]:.2f}t+{solucionesZ[2]:.2f})")

# Creamos la figura de Matplotlib
fig = plt.figure()

# Creamos la gráfica
ax = fig.add_subplot(projection='3d')

# Creamos los ejes.
xx, yy = np.meshgrid(range(20), range(20))

# Creamos el rango de valores para t
t_line = np.linspace(0, 10, 100)

# Planteamos las ecuaciones paramétricas en función de t
x_line = (solucionesX[0] * (t_line ** 2)) + \
    (solucionesX[1] * t_line) + solucionesX[2]
y_line = (solucionesY[0] * (t_line ** 2)) + \
    (solucionesY[1] * t_line) + solucionesY[2]
z_line = (solucionesZ[0] * (t_line ** 2)) + \
    (solucionesZ[1] * t_line) + solucionesZ[2]

# Añadimos el punto de impacto
punto = ax.plot([xf], [yf], [0], markerfacecolor='k',
                markeredgecolor='k', marker='o', markersize=5, alpha=0.6)

# Añadimos las ecuaciones paramétricas a nuestra gráfica en 3D
curva = ax.plot3D(x_line, y_line, z_line,
                  label='Curva Paramétrica', color="red")

# Colocamos los límites de graficación en los ejes.
ax.set_xlim(-1, 15)
ax.set_ylim(-1, 15)
ax.set_zlim(-1, 15)

# Colocamos las etiquetas en los ejes.
ax.set_xlabel('x', color='blue')
ax.set_ylabel('y', color='blue')
ax.set_zlabel('z', color='blue')

# Colocamos el título de la gráfica
ax.set_title("Curva Paramétrica de Tiro Parabólico")

# Proxies para colores de la leyenda.
proxy_grafica = plt.Rectangle((0, 0), 1, 1, fc='r')
proxy_punto = plt.Line2D(
    [0], [0], linestyle="none", marker='o', alpha=0.6, markersize=10, markerfacecolor='black')

# Mostrar la leyenda
ax.legend([proxy_grafica, proxy_punto], [f"({solucionesX[0]:.2f}t²+{solucionesX[1]:.2f}t+{solucionesX[2]:.2f}, {solucionesY[0]:.2f}t²+{solucionesY[1]:.2f}t+{solucionesY[2]:.2f}, {solucionesZ[0]:.2f}t²+{solucionesZ[1]:.2f}t+{solucionesZ[2]:.2f})",
          f"Impacto ({xf:.2f},{yf:.2f},0)"], numpoints=1, loc='lower left')


# Mostramos la gráfica
plt.show()

Credits

This program was created for the Vector Analysis course at the Escuela Superior de Cómputo of the Instituto Politécnico Nacional, taught by Dr. Dárwin Gutiérrez Mejía.

May 2021

Note from 2023.

This project was written in May 2021, however I never had the time to get to write a little about it. If you’re curious about the code and/or the original written report (which is basically the spanish version of what you just read) you can find it here:

https://github.com/humbertowoody/analisis-vectorial-escom-parabola

If you run the code with the following command:

The output will be something like these options:

Thank you for reading! I hope you can find some inspiration here to make some cool visualizations for your classes.

Simple Packet Sniffer in C

Wed, 05 Apr 2023 00:00:00 +0000

As my final project for my Computer Networks subject at ESCOM I wrote a simple packet sniffer in C, it was a fun little project and this is my documentation about it.

Hello! This is a translation from an old post (2019) I wrote in spanish (that you can find here, in my school subject repository) and it includes a detailed description on the rationale behind its design, implementation and usage. If you’d like to get the source code you can visit the github repository at github.com/humbertowoody/redes-escom/Proyecto-Final.

Building a Simple Network Packet Sniffer

“There was a time when people felt the internet was another world, but now people realize it’s a tool we use in this world”.

Tim Berners Lee.

As my final project for my Computer Networks subject at ESCOM, I decided to implement a network packet sniffer that allows capturing, analyzing, and exporting data quickly and easily. The program is written in C/C++ using the libpcap library for analysis and data export functionalities.

Building a Simple Network Packet Sniffer

Objectives

There are many network packet capturing (and interpreting) software applications available, each with various features depending on the intended use case. This project aims to cover only basic functionalities, providing a sort of guide for developing more complex programs requiring similar features. The functionalities considered include:

Displaying available capture interfaces.
Allowing the user to choose and configure capture interface parameters.
Allowing the user to specify capture filters.
Allowing the user to choose the number of packets to capture.
Enabling packet analysis on the fly or from a file.
Displaying information of each protocol of each captured packet.
Displaying captured packet statistics.
Exporting the capture rate to a standard capture program format (.pcap).

Implementation

To develop this program, we started by analyzing the user flow while interacting with the software, focusing on simplicity and efficiency.

First, the program prints a welcome header and follows this flow:

Ask the user if they want to capture packets on the fly or from a file.
On the Fly
1. Display a list of available network cards.
2. User selects a network card.
3. Ask the user for the maximum packet size; the recommended value is 65536.
4. Ask the user if the interface should operate in promiscuous mode.
5. Ask the user for the timeout for packet capture; the recommended value is 1000 (in ms).
6. Ask the user if they want to save captured packets in a file.
7. Save
  1. Ask for the filename.
  2. Open the file.
From a File
1. Ask the user for the filename to read packets.
Ask the user for the number of packets to capture.
Ask the user if they want to use a capture filter.
With Filter
1. Ask the user for the filter.
2. Compile the filter.
3. Apply the filter.
Analyze packets.
1. Receive the packet.
2. Print capture date.
3. Analyze Ethernet/802.3.
4. Analyze IP.
5. Analyze ICMP, TCP, or UDP.

The source code closely follows this flow and is how the compiled program operates.

Testing

To test the program correctly, we need to consider all valid use cases. Instead of listing hundreds of tests, we’ll focus on the crucial use cases for our Sniffer:

Capture packets on the fly.
Capture packets from a file.
Apply capture filters.
Export capture to a .pcap file.

Capturing Packets on the Fly

To capture packets on the fly, select the first option in the main menu. Then, fill in the configuration, and the program will produce an output similar to:

Hey there! So, the output was just too long to fit nicely in this blog post. No worries though - I’ve moved it to this GitHub gist for you to check out whenever you like. Enjoy!

This output confirms that the capture was performed correctly using the specified network card.

Capturing Packets from a File

To test the program by reading packets directly from a file, select the second option in the main application menu. Fill in the filename, specify the number of packets, and choose whether to apply a capture filter. The output will be similar to:

Hey there! So, the output was just too long to fit nicely in this blog post. No worries though - I’ve moved it to this GitHub gist for you to check out whenever you like. Enjoy!

This output verifies that our program can analyze packets contained in a standard packet capture format file (.pcap).

The packets I used for this demo are in the paquetes.pcap file, which is specific for testing packet analysis with an Ethernet 802.3 header, but it works with any type of packets. Please visit the GitHub repository if you’d like to see the file.

Applying Capture Filters

It’s essential for our program to apply capture filters, allowing the user to make better use of our Sniffer. We can use capture filters with either on-the-fly or file-based captures, and the filter should have specific syntax. Suppose we want to capture only all DNS traffic, which is UDP using port 53. In that case, our program will display output like:

Hey there! So, the output was just too long to fit nicely in this blog post. No worries though - I’ve moved it to this GitHub gist for you to check out whenever you like. Enjoy!

This output proves that the program can successfully specify and apply capture filters.

Exporting Capture to a `.pcap` File

Exporting our capture to a standard format file (like .pcap) allows us, as users, to capture packets and analyze them using specialized analysis software like WireShark for more detailed analysis with more comprehensive (and complex) tools.

To test this option, select the on-the-fly packet capture and choose to export the capture to a file when prompted. Specify the filename to store the capture rate. Suppose we want to capture all ICMP packets and export them to an icmp.pcap file for further analysis with WireShark. In that case, the program execution with those steps in mind will display:

Hey there! So, the output was just too long to fit nicely in this blog post. No worries though - I’ve moved it to this GitHub gist for you to check out whenever you like. Enjoy!

This successful test allows us to perform more detailed analysis of raw packets in compatible software like WireShark.

Conclusion

Developing such a simple tool requires a general understanding of networking concepts to break down the captured data into different interpretations useful for the user. Although many packet capture programs currently exist, developing a Sniffer helps us better understand our network’s behavior and the packets that flow through it.

Message from 2023

This was a fun project to write and even it’s code can be improved, the overall networking concepts surrounding the internals of a packet sniffer remain as current as ever.

Thanks for taking the time to read this!

Apple Music CLI with ChatGPT

Sun, 02 Apr 2023 00:00:00 +0000

It’s always useful to be able to manage things from the terminal, for some of us it’s even a thing about comfort. I used ChatGPT to generate a simple set of alias functions to work as CLI for Apple Music.

The first thing to do would be to define the list of functionalities we are going to be asking ChatGPT to perform for us, these functionalities should be enough to properly handle the basic usage scenarios however providing a proper and extensible format so we can add more complicated tasks over time.

Common functionalities

The basic functionalities I would expect from a sensible music player are:

Play.
Pause.
Skip to next track.
Go back to previous track.
Search and play track.
Display current track’s information.

Mapping of functionalities

The proposal would be for ChatGPT to generate the following mapping for the functions described into aliases:

Functionality	Alias	Usage
Play	`music-play`	Plays the current track
Pause	`music-pause`	Pauses the current track
Skip to next track	`music-next`	Skips to the next track in queue
Go back to previous track	`music-prev`	Goes back to the previous track in the queue
Search and play track	`music-play-track <track name>`	Searches for `<track name>` in Apple Music and, if found, plays it
Display current track information	`music-now-playing`	Shows information about the currently-playing track in Apple Music

Asking ChatGPT for scripting superpowers!

The prompt I used for generating the tools:

Me: Hey! Can you write me a set of shell aliases for performing normal tasks from the terminal like a CLI for Apple Music?

I had to go back-and-forth for a while with our Chat friend as there were some issues (explained after the script) regarding the music-now-playing function which wasn’t working at the first try. I would have been really surprised if it generates a perfect working example on the first attempt, honestly.

The resulting script:

#!/bin/bash
# Apple Music Aliases- @humbertowoody
# Creates aliases for Apple Music commands.

# Function for playing music
function music-play()
{
    osascript -e 'tell application "Music" to play';
}

# Function for pausing music
function music-pause()
{
    osascript -e 'tell application "Music" to pause';
}

# Function for skipping to the next track
function music-next()
{
    osascript -e 'tell application "Music" to next track';
}

# Function for skipping to the previous track
function music-prev()
{
    osascript -e 'tell application "Music" to previous track';
}

# Function for searching and playing a music-play-track
function music-play-track()
{
  query="$1"
  osascript -e "tell application \"Music\"
    set search_results to search playlist \"Library\" for \"$query\"
    if search_results is not {} then
      set best_result to item 1 of search_results
      play best_result
    end if
  end tell"
}

# Function for getting information about the currently playing track
function music-now-playing() {
    # Get the current track properties
    track_name=$(osascript -e 'tell application "Music" to get name of current track as string' 2>/dev/null || echo "(not present)");
    artist_name=$(osascript -e 'tell application "Music" to get artist of current track as string' 2>/dev/null || echo "(not present)");
    album_name=$(osascript -e 'tell application "Music" to get album of current track as string' 2>/dev/null || echo "(not present)");
    track_number=$(osascript -e 'tell application "Music" to get track number of current track as integer' 2>/dev/null || echo "(not present)");
    disc_number=$(osascript -e 'tell application "Music" to get disc number of current track as integer' 2>/dev/null || echo "(not present)");
    duration_seconds=$(osascript -e 'tell application "Music" to get duration of current track as integer' 2>/dev/null || echo "(not present)");
    play_count=$(osascript -e 'tell application "Music" to get played count of current track as integer' 2>/dev/null || echo "(not present)");
    rating=$(osascript -e 'tell application "Music" to get rating of current track as integer' 2>/dev/null || echo "(not present)");
    loved=$(osascript -e 'tell application "Music" to get loved of current track as boolean' 2>/dev/null || echo "(not present)");
    genre=$(osascript -e 'tell application "Music" to get genre of current track as string' 2>/dev/null || echo "(not present)");
    year=$(osascript -e 'tell application "Music" to get year of current track as integer' 2>/dev/null || echo "(not present)");
    art_file=$(osascript -e 'tell application "Music" to get location of artwork 1 of current track as string' 2>/dev/null || echo "(not present)");
    track_quality=$(osascript -e 'tell application "Music" to get bit rate of current track as integer' 2>/dev/null || echo "(not present)");
    sampling_rate=$(osascript -e 'tell application "Music" to get sample rate of current track as integer' 2>/dev/null || echo "(not present)");

    # Format the duration as minutes:seconds
    if [[ -n "$duration_seconds" ]]; then
        duration_min=$(( duration_seconds / 60 ))
        duration_sec=$(( duration_seconds % 60 ))
        duration=$(printf "%d:%02d" $duration_min $duration_sec)
    else
        duration="(not present)"
    fi

    # Print the current track information with decorations
    printf "\n%s\n" "--------------------------------------"
    printf "%s\n" "            Now playing"
    printf "%s\n" "--------------------------------------"
    printf "  %-15s %s\n" "Name:" "$track_name"
    printf "  %-15s %s\n" "Artist:" "$artist_name"
    printf "  %-15s %s\n" "Album:" "$album_name"
    printf "  %-15s %s\n" "Track number:" "$track_number"
    printf "  %-15s %s\n" "Disc number:" "$disc_number"
    printf "  %-15s %s\n" "Duration:" "$duration"
    printf "  %-15s %s\n" "Play count:" "$play_count"
    printf "  %-15s %s\n" "Rating:" "$rating"
    printf "  %-15s %s\n" "Loved:" "$( [[ $loved == true ]] && echo "yes" || echo "no" )"
    printf "  %-15s %s\n" "Genre:" "$genre"
    printf "  %-15s %s\n" "Year:" "$year"
    printf "  %-15s %s\n" "Artwork file:" "$art_file"
    printf "  %-15s %s kbps\n" "Track quality:" "$track_quality"
    printf "  %-15s %s Hz\n" "Sampling rate:" "$sampling_rate"
    printf "%s\n" "--------------------------------------"
}


# Helper function to test which track properties are available
# This is useful for debugging
function music-now-playing-test() {
    # Define the track properties to test
    properties=(
        "name"
        "artist"
        "album"
        "track number"
        "disc number"
        "duration"
        "play count"
        "rating"
        "loved"
        "genre"
        "year"
        "artwork location"
    )

    # Test each track property and output the results
    printf "Music track properties:\n\n"
    for prop in "${properties[@]}"; do
        # Get the value of the property
        prop_value=$(osascript -e "tell application \"Music\" to get ${prop} of current track" 2>/dev/null)

        # Print the property name and whether it was available
        if [[ -n "$prop_value" ]]; then
            printf "%-16s%s\n" "${prop}:" "available"
        else
            printf "%-16s%s\n" "${prop}:" "not available"
        fi
    done

    printf "\n"
}

# Function that prints all aliases with examples
function music-help()
{
    echo "music-play: Play music"
    echo "music-pause: Pause music"
    echo "music-next: Skip to the next track"
    echo "music-prev: Skip to the previous track"
    echo "music-play-track: Search and play a track"
    echo "music-now-playing: Get information about the currently playing track"
}

The solution involves two things:

functions to map the commands themselves, that way we cannot get confused with the quote/double-quote dilemma.
osascript, an Apple Script execution engine that, as you can see, receive commands in a really abstract manner, almost plain language¹.

The `music-now-playing` issues

As you may have observed, the provided script includes a function called music-now-playing which pretty-prints in the terminal information from the currently-playing track.

There’s also a function called music-now-playing-test, this is because, depending on Apple Music’s version, there’s no guarantee on the information available to the scripting engine from Apple.

The idea is for you to use the music-now-playing-test alias to debug which features are available in order for you to modify the music-now-playing function accordingly.

The final usage

These aliases and functions live in my dotfiles repository in GitHub in which I keep my entire configuration. From there you can infer how I’m using them, but basically I load them during ZSH initialization from .zshrc and source through each tools/*.sh file (such as this one: apple-music-aliases.sh) and voilá!

This is just a fun perk to have available on the command line. Here you can see the output of the music-now-playing alias function:

❯ music-now-playing
Now playing:
  Name:           Symphony No. 2 in D Major, Op. 36: III. Scherzo. Allegro
  Artist:         London Symphony Orchestra & Josef Krips
  Album:          Beethoven: The Complete Symphony Collection
  Track number:   7
  Disc number:    1
  Duration:       3:32
  Play count:     2
  Rating:         0
  Loved:          no
  Genre:          Classical
  Year:           1960
  Artwork file:   (not present)

AppleScript is a scripting language created by Apple Inc. that facilitates automated control over scriptable Mac applications. First introduced in System 7, it is currently included in all versions of macOS as part of a package of system automation tools. The term “AppleScript” may refer to the language itself, to an individual script written in the language, or, informally, to the macOS Open Scripting Architecture that underlies the language. – https://en.wikipedia.org/wiki/AppleScript ↩

(Attempt at) estimating environmental impact of planting trees

Thu, 16 Mar 2023 00:00:00 +0000

Planting trees is a simple and effective way to combat climate change, but it’s important to understand the environmental benefits of doing so. Let’s try to explore how to calculate the amount of CO2 compensated and the amount of water required to grow a tree over a 30-year period. How hard could it be?

Measuring, huh?

I want to give a big shoutout to @AlcocerJerry for having the patience to expalin me all of this in an approachable language.

When asked: What are one of the most effective ways to combat climate change? We know that trees are the first thing to come to mind. Trees absorb carbon dioxide (CO2) form the atmosphere and produce oxygen (O2) through photosynthesis. They also provide habitat for wildlife, improve air quality, and reduce soil erosion. However, calculating the amount of CO2 compensated and the amount of H2O required to grow a tree in the next 30 years can be challenging.

How challenging, exactly?

First, you will need to determine the type of tree you want to plant. Different tree species have different growth rates, sizes, and lifespans. For the purpose of this calculation, we will use the red maple tree (Acer rubrum) as an example. The red maple is a fast-growing deciduous tree that can reach a height of 40-60 feet and a spread of 25-45 feet. It has a lifespan of 100-150 years.

Next, you will need to estimate the amount of CO2 that the red maple tree will absorb during its lifetime. According to the US Forest Service, a mature tree can absorb 48 pounds of CO2 per year. Therefore, over a 30-year period, a red maple tree can absorb approximately 1,440 pounds (or 0.72 tons) of CO2.

To compensate for the CO2 emitted during the production and transportation of the tree, you can add an additional 20% to the total amount of CO2 absorbed. This means that the total amount of CO2 compensated by planting a red maple tree over a 30-year period is approximately 1,728 pounds (or 0.86 tons).

Next, you will need to estimate the amount of H2O required to grow a red maple tree over a 30-year period. According to the Arbor Day Foundation, a mature tree can transpire up to 100 gallons of water per day during the growing season. Therefore, over a 30-year period, a red maple tree can transpire approximately 1,095,000 gallons (or 4,142,325 liters) of water.

This is not perfect, to say the least.

It is important to note that the amount of water required to grow a tree can vary depending on the climate, soil type, and other environmental factors. Therefore, this estimate should be used as a rough guideline only.

A calculator!

As a bonus task for the semester I wrote a simple calculator website that showcased how making this knowledge accessible in an interactive way can make people make better informed decisions.

The idea is to select a plant species and then we’ll show you our estimations. However, we cannot assume everyone knows the species of their plants and, in order to get a realistic model of the water requirements, we should ask the user to measure the diameter of the top of the plant which, in most cases, would be enough struggle to make more than one abandon the process.

The first problem is solved by asking the user to visit https://identify.plantnet.org which will help even the trained eye.

The second one is solved by start speculating. Let’s assume a couple of things:

The average measure for the top of trees is impossible, but if we limit our calculations to forest species, now we got a reduced set of options. If we pick only a particular tree: Punica Granatum, Pomegranate, Granada, we can visit it’s wikipedia page and get the average measurement.
The amount of water that evaporates and permeates from the plant itself is a calculation derived from many variables that, again, most users won’t care to: a) correct or b) understand.
The studies regarding the soil itself and terrain conditions are also not
considered, the usability concerns are far bigger than precisement is needed.

Remember, this is just a prototype.

It’s in spanish and has an awful design. Unfortunately, I won’t mantain nor improve and/or translate the site, but feel free to write a better version of it (probably a fun weekend project!).

The website: https://humbertowoody.github.io/estimador-co2-agua

Thank you for reading!

Cron for Homebrew

Sun, 26 Feb 2023 00:00:00 +0000

Homebrew is a wonderful package manager and, for macOS users, it’s the only sensible option around. However, keeping up to date is really tedious. In this article we set a cron entry to update everything on a schedule.

I value my time.

And if you’re here, probably you value yours too. Now, brew install always triggers a brew update before installing new packages anyway, so, after a long period of time without upgrading your packages you install a new one it can take an hour and a half of your life updating all your setup.

In this article we’ll:

Create a script with the update commands.
Add a new crontab entry to execute said script.
Monitor executions.

1. Create a script with the update commands.

This is a simple task, for me the idea was to update homebrew and the gcloud (GCP’s CLI) utility. My script looks like this:

#!/bin/bash
# script to update the system

# absolute paths*
HOMEBREW_BIN=/absolute/path/to/brew
GCLOUD_BIN=/absolute/path/to/gcloud

# update commands.
$HOMEBREW_BIN update && && $HOMEBREW_BIN upgrade && $HOMEBREW_BIN cleanup;
$GCLOUD_BIN components update --quiet;

You can use the which(1) command to figure out the absolute path for the binary of any executable you may need to reference. Remember that the execution environment from cron can vary from system to system and it’s a good idea in these scenarios to be absolutely specific.

2. Add a new crontab entry to execute said script.

Always backup cron’s data before any modification is made, you never now.

In order to access the crontab(1), we’ll need to edit the user’s crontab:

1	$ crontab -e

Within the file, we’ll add a new entry for our script:

*/30 * * * * /path/to/your/script.sh &

If you need help setting up your cron expressions, I’d recommend you to visit the crontab.guru configurator so you can experiment and setup more complicated schedules.

3. Monitor executions

As you may already know, the way crontab(1) works is essentially asynchronous from your terminal. Any output produced from the execution context can be monitored by two mechanisms:

Use the default crontab(1) behavior and check the mail(1) command to get our inbox of messages from Cron.
Pipe the output into a specific logfile by using the > or >> operators in bash.

Using the #2 would be the best way to do it since you will have a searchable and meaningful log. However I would advice against it in this case as the executions may be thousands per week so the file will grow in size exponentially and can cause system disruption.

Using the mail(1) command we can monitor the execution in the following way, this is the output of an interactive session:

❯ mail
Mail version 8.1 6/6/93.  Type ? for help.
"/var/mail/humbertowoody": 1 messages 1 new
>N  1 humbertowoody@cpe-17  Tue Feb 28 16:00  21/968   "Cron <humbertowoody@cpe-172-100-67-24> source /Users/humbertowoody/tools/update-macos"
? 1
Message 1:
From humbertowoody@cpe-172-100-67-24.twcny.res.rr.com  Tue Feb 28 16:00:44 2023
X-Original-To: humbertowoody
Delivered-To: humbertowoody@cpe-172-100-67-24.twcny.res.rr.com
From: humbertowoody@cpe-172-100-67-24.twcny.res.rr.com (Cron Daemon)
To: humbertowoody@cpe-172-100-67-24.twcny.res.rr.com
Subject: Cron <humbertowoody@cpe-172-100-67-24> source /Users/humbertowoody/tools/update-macos.sh && update_macos &
X-Cron-Env: <SHELL=/bin/zsh>
X-Cron-Env: <PATH=/usr/bin:/bin>
X-Cron-Env: <LOGNAME=humbertowoody>
X-Cron-Env: <USER=humbertowoody>
Date: Tue, 28 Feb 2023 16:00:11 -0600 (CST)

Already up-to-date.
Beginning update. This process may take several minutes.

All components are up to date.

? q
(end of session)

Here Cron will send an email with each execution so we can monitor it by using the mail command.

That’s it!

This script has helped me generate a better experience out of Homebrew in my local machine. I hope it helps you on your developer workflow.

Code Reader

Mon, 15 Jun 2020 00:00:00 +0000

Writing code is fun. Period. If someone tells you otherwise, they’re probably lying, frustrated, or gatekeeping (permutations are a possibility.). However, as any skill you can develop in life, you have to be conscious about the environment and the requirements of that particular environment.

Programming is one of those things that change the way you think and see the world around you. With programming, you gain a dramatically different idea of how and why you interact with technology, and the endless permutations you can create with code.

The sole concept of perfect code should be something that every programmer must know to avoid and, in many cases, learn to let go. For many, this involves asking questions, seeking feedback, and learning from others. Have you looked at the Linux Kernel codebase? If not, you totally should! It is an example of how software is crucial to humanity’s advancement.

This is a fragment from one of my favorite pieces from Rachmaninoff: Piano Concerto No. 3, with just the right amount of complexity.

In music, adding complexity is up to the composer, and it may improve (or not) the overall piece into achieving the feel and exact essence of what the musician wanted to include in their masterpiece. It may be applauded, it may not. The key is learning how to read complexity itself, and not be overwhelmed by it. This concept can be applied to programming as well.

Complex code is being changed nowadays. It is being analyzed, erased, rewritten, and refactored to make it more accessible and inclusive. There will always be non-simplifiable systems, as programming is about modeling the world around you, and the world isn’t simple. But the complexity we’re addressing is self-imposed.

In both music and programming, the concept of elegance is essential, referring to the ability to add and remove the exact amount of complexity. Programming is, for the most part, a journey where you get to read billions of lines of other people’s code, and it’s essential to strive for readability.

When you start writing code in the way you’d like to read code, that’s when analytical, logical, and overall elegance kicks in. You are no longer an agent of chaos, but a helpful contributor that acknowledges code as what it is: a language.

As you read more code, you become more conscious of the abstraction techniques and capabilities of each language and how, when, why, and where to apply them. Strive for readability, not just because some random person on the internet is telling you so, but because readability benefits everyone in the programming community.

As always, thanks for reading. For comments and feedback, you can find me on Twitter as: @humbertowoody.

humberto

Pixl - A Predictable Pal in a Pixelated Playground

A Keychain, a Clock, and a Dream

Three Numbers, Infinite Gestures

The Breath of the Machine

Five Axioms of Pixl’s World

Portraits in Thirty-Two Squares

A Walk Through the Source

Implementation in Brief

Constraint as a Lens

Poetry Generation Using Markov Chains

Poetry Generation Using Markov Chains

Crafting verses with code

So, what are Markov chains?

A visual journey through the data

Relationship Matrix

Heatmap

Network Graph

Comparison to Current Generation LLMs

Simplicity vs. Complexity

Training Data and Flexibility

Output Quality

Conclusion: Exploring the Poetic Potential of Technology

SkyPrice: Predicting Apartment Prices in Mexico City

SkyPrice

Introduction

Motivation

Technologies Used

Data

Importance of Each Dataset

Data Challenges and Solutions

Methodology

Detailed Process

Model Performance

Public API

API Documentation

Predict Endpoint

Example API Request

Example API Response

Metadata Endpoint

Example Metadata Response

Web Application

User Interface Design

Price Prediction Tool

Currency Conversion

Interactive Map

Model Information

Telegram Chatbot

Setup and Features

Example Interaction

Methodology and Implementation

Conclusion

Impact and Lessons Learned

Future Enhancements

Maze generator game in C

Introduction

Libraries and Constants

Enumerations and Structures

Function Prototypes

Main Function

Helper Functions

Printing the map

Depth-First Search (DFS)

Get available directions

Compilation

Execution

Final Code

Parametric approach to visualize parabolic trajectories

Visualizing a Parabola with a Given Impact Point

Mathematical Background

Project Overview

Technologies

Dependencies

Execution

Source code

Credits

Note from 2023.

Simple Packet Sniffer in C

Building a Simple Network Packet Sniffer

Table of Contents

Exporting Capture to a `.pcap` File

The `music-now-playing` issues