MatecDev

Best C++ Libraries for Scientific Computing in 2025 (with Boilerplate Project)

An opinionated selection of the best C++ libraries for numerical and scientific computing, with a ready-to-build CMake boilerplate using FetchContent.

Building a Budget GPU Rig with Used Hardware for CUDA and AI

A practical guide to buying used GPUs from miners, gamers, and data centers to build a budget GPU server for CUDA development, AI experiments, and scientific computing.

When Does On-Prem HPC Beat the Cloud? A TCO Analysis

We build a simple total cost of ownership model to find the break-even utilization rate at which owning your own HPC hardware beats renting from the cloud - and explore what happens when you stretch depreciation beyond the usual 3 years.

Nanobind vs Pybind11: Calling C++ from Python in 2026

A hands-on comparison of nanobind and pybind11 for calling C++ from Python, with working code examples, benchmarks, and practical advice on which to choose.

Choosing a GPU Cloud Provider for Learning CUDA

In this post we compare the different GPU cloud providers and try to find the best ones for those who want to learn CUDA.

Budget GPUs for CUDA development: a short buying guide

In this post we go through some important considerations on how to pick a budget GPU for CUDA development.

3 Python Packages for the Yahoo Finance (unofficial) API

Get started with stock market data analysis in Python using yfinance, yahooquery, or yahoo_fin.

How Early Programming Training Prepares Students for a Software Development Career

A quick review of some programming languages, platforms, and reasons to teach your kid how to program

Resizing and Concatenating Arrays

Get started handling multidimensional arrays in Julia with this simple guide.

How to Call Fortran from Python

Combining the incredible flexibility of Python with Fortran for high-performance number-crunching is an excellent idea, especially if you already have some legacy Fortran code hanging around. Here's how to do it.

Using Numpy's FFT in Python

There are numerous ways to call FFT libraries both in Numpy, Scipy or standalone packages such as PyFFTW. In this post, we will be using Numpy's FFT implementation.

Organizing Your Julia Code

Julia has several tools to help you organize your code

Performance of C-style arrays vs C++ std::vector

The floating-point performance of various array-type structures in C++ can be confusing, as there are several options to pick from, and different ways to use them. This article presents a simple benchmark to try to clarify some of the basic differences.

Developing Local Packages

Stack vs Heap Allocation in C: Pros and Cons

In this blog post, we will explore the differences between stack and heap allocation, their advantages, disadvantages, and when it's appropriate to use each one.

Data Analysis Without Using Math: An example workflow

In this post, we'll discuss how you can indeed perform data analysis tasks without using anything beyond basic high-school math.

Is the Julia Language Worth Learning? (Pros and Cons)

Julia promises high-performing code and ease of use, but also has a few downsides. Is it worth learning it?

Tuples and Named Tuples

Tuples in Julia are fixed-length collections of values, of potentially different data types, which can't be modified once initialized. Tuples are closely related to function arguments.

Julia: 17X Faster than Python's Scipy, and Easier Too!

Nobody expects good performance from native Python, but we do expect it when calling compiled functions in libraries like Scipy... However, is this really the case?

Creating a New Project

If you want to keep you code well organized, the first step is to create a project.

Performance Optimizations Checklist

A quick overview of things to do when your Julia code performance is not what you expected.

Axis Limits and Aspect Ratios

Control where and how data appears in a plot by setting limits and aspect ratios.

Text and Font Sizes

Make your plot informative and readable with text and proper font sizes.

Community Plots.jl Gallery

A collection of example plots with source code

Gridlines

Configure or get rid of the gridlines in a plot by setting the grid parameters.

Legend Position

Set the legend locatin in a convenient position, including outside the plot.

Lines Styles and Markers

Set the basic series attributes in order to choose between solid, dashed or dotted line plots, bar plots, or scatter plots

Log and semilog plots

A good way to plot numerical data that spans a very wide range of values, is to employ a logarithmic scale in one or both axis.

Multiple Subplots

Multiple plots can be combined together into a single figure using layouts.

Plots.jl Quick Reference

Quick reference guide on how to get started with Plots.jl

Structs

Structs are a great way to represent data in a compact and easy-to-understand way. Additionally, there is so much that can be accomplished with just an array of struct.

How to Call C++ from Python

Math for Game Developers: What to Learn (And Why!)

Mathematics comes into play in many areas of game (and especially game-engine) development. This post will highlight what are the most useful areas, and discuss why they are important for developers.

Industry vs Academia for STEM PhDs: 4 Things to Consider

Domain Knowledge in Data Science: An Overview

Acquiring data-skills (coding and statistics) and combining them with domain-specific knowledge is increasingly more important as the field matures.

How Much Math do Data Analyst or Data Scientists Need?

In this post, we'll discuss what are the main professional roles in the data industry, and where mathematics actually fits.

Bisection Method

The bisection method is the simplest rootfinding algorithm. It starts from two points where a given continuous function has opposite signs, to iteratively to approximate a root.

Newton-Raphson Method

The Newton-Raphson method is a rapidly-converging method to approximate roots of a smooth function. In this post we show an implementation that uses automatic differentiation to obtain the function derivative.

Rootfinding and Optimization

In this section we will briefly review existing packages within the Julia ecosystem for rootfinding and optimization. Subsequent sections focus on building various algorithms from scratch.

Generate Random Points in a Polygon

We present two alternatives to generate random points within a polygon in python: a very simple (but slow) method, and a faster one that relies on Geopandas spatial joins.

Geospatial Python Tutorial

Learn the most popular geospatial python libraries such as shapely, geopandas and rasterio, with this hands-on, detailed tutorial.

Extract Points from Shapely Polygon

We can extract points from a polygon using the mapping() function, or with detail, extracting the polygon's boundaries.

Merge a List of Polygons

In order to merge shapely polygons, we can resort to the unary_union() function in shapely.

Plot Shapely Polygon with Matplotlib

We can plot Shapely polygons by resorting to Geopandas plot() function, or directly, extracting the polygon's boundaries.

Create Polygon from Points

You can create a Shapely polygon from a list of points, either by providing the point's coordinates or extracting them from a list of Shapely points.

Polygon Gridding

We can split a polygon into equal-sized rectangles that form a grid, using Shapely.

Landsat & Sentinel-2 Data on AWS

This post will show you how to leverage cloud-optimized GeoTiffs and the AWS free tier to access satellite imagery, using Python.

Google Earth Engine Goes Commercial: 5 Things to Consider

Google Earth Engine (GEE) is no doubt a powerful service, kindly provided for free by Google. However, it is not a one-size-fits-all solution...

How to Work with Legacy Fortran Code: A Short Guideline

Working with legacy Fortran code can be challenging as it requires deep knowledge of several programming languages and the ability to interact with the domain experts.

Examples of Multiple Dispatch

Multiple dispatch is a simple idea with far-reaching consequences. Understand the use cases of this interesting feature easily with the following examples.