b.stefanuk.ca | b.stefanuk.ca

Skip to content

b.stefanuk.ca

Main NavigationCatalog

Appearance

Sidebar Navigation

Technology

Home

Data structures+algos

Arrays

Binary Search Trees

Binary Trees

Dynamic Programming

Graphs

Greedy Algorithms & Invariants

Hash Tables

Heaps & Priority Queues

Linked Lists

Primitive Types

Recursion

Searching

Sorting

Stacks & Queues

Strings

Algorithms

Algorithms and How to Solve Them

Binary Tree Traversal

Web Crawler and Scraper Rust Implementation

Databasing

Using InfluxDB

Using Redis

Devops

Automated Software Testing

Deploying Rust to Production

Loads of Useful DevOps Articles

Production Grade Rust Deployments

Production Grade Workflow with Docker

Reproducible GitLab Runner

Using AWS for Infrastructure

Using Ansible

Using Docker CLI

Using Docker Compose

Using GitLab CI

Using Kubernetes

Using Nginx & Traeffic

Using Pre commit

Using Terraform

Writing Dockerfiles

Fullstack

Deploying Flask with Elastic Beanstalk

Essential Tech Stacks

Getting a Service on Rancher

Understanding OSS Directories

Understanding Vite

Using APIs with JS

Using Serverless

Using Vite

Hardware

Flashing an NVIDIA Jetson

Understanding I2C

Understanding PCI Devices

Understanding SPI

Understanding UART and Serial

Languages

Cpp

C++ Best Practices

C++ Patterns Thread safe Queue

C++ Patterns Threadsafe Queue

C++ Syntax Cheatsheet

CMake Tips 'n Tricks

Key Keywords and Builtins

Parameter Packing and Varadic Templates

Understanding Inheritance

Understanding RAII

Using CMake + Make to Build from Source

Using CMake + Ninja to Build from Source

Using CMake with Clang

Using CMake with pkg config

Using Mutexes and Lock Guards

Using Pointers

Using System Calls in C++

Using Threads in C++

Writing Tests and Mocks with GTest and GMock

Python

Python Best Practices, Tips, and Tricks

Python Key Keywords and Builtins

Python Tree Traversel Examples

Python Using Generators

Using Django

Using Jupyter

Using Pandas

Using Poetry and Pip with Nix Flakes

Rust

Best Practices for Rust Projects

Essential Crates

Essential Macros

Essential Rust Syntax Explained

Generics, Traits, and Lifetimes

Rust Cross compiling x86_64 for arm64

Understanding Rust Futures

Using Cargo and Crates

Using Command Line Arguments and Environment Variables

Using Concurrency

Using File IO and Configs

Using Redis in Rust

Using Rust in VSCode with Nix

Using Rust with Nix Flakes

Using Rustc and Rustup

Using Smart Pointers

Using Tests and Mocks

Using Tokio

Writing Documentation

Shell

Coloring Logging

Shell Scripting Tips

Working with JSON Using JQ

Sql

SQL Fundamentals

SQL Patterns and Problems

Linux

Checking Unix Ports

Connecting to a NAS with Samba

Creating an Image of a Linux Environment

Having Fun with the Terminal

Linux Command Line Quick Guide

Loads of Useful Linux Articles

Making DEB Packages

Probing Unfamiliar Devices

Syncing a Local Filesystem with Google Drive

Understanding Devicetree

Understanding Sysfs and Procfs

Using Cron Jobs

Using Linux Logs

Using PPA Repositories

Using Routes

Using Serial Ports

Using Systemd Service Files

Using Udev Rules

Using Update Alternatives

Using Video 4 Linux

Using the Systemd Suite

Working with Dates & Times

Working with the Linux Kernel

Networking

Ethernet

How to Expose a Server to the Internet

Loads of Useful Networking Articles

Networking Acronyms & Terminology

Setting up SSH Key Pairs

Setting up an AMQP Broker (RabbitMQ)

Setting up an AMQP Client (RabbitMQ)

Setting up an SSH SOCKS Tunnel

Understanding TCP and UDP

Understanding TLS and SSL

Understanding gRPC

Using CAN

Using Curl

Using Gstreamer for AV Streaming

Using IP

Using Network Interfaces

Using Socat and Netcat

Working with DNS

Principles

Components of Distributed Systems

Elements of System Design

Race Conditions

Tables Data Structures & Algorithms

Understanding Big O

Understanding Recursion

Debug+optim

Performance Profiling

Using Breakpoints

Using GNU Debugger (GDB)

Design patterns

Actor Model

Concurrency Active Object

Essential Software Design Principles

Factory Method

Software design

Template Mermaid Diagrams

UML Diagrams Simplified

Wireframes, Mockups, and Prototypes

Simulation

Using Gazebo

Tools+libraries

Essential Vim Commands

Home Automation Toolkit

Understanding Apache Spark

Using Grafana + Prometheus

Using Grafana

Using MQTT

Using Nix

Using Syncthing

Wicked CLI Tools

Git

Essential Git Operations

Forking from GitHub to GitLab

Git Contributing Template

Simple Git Workflow

Using Git Rebase

Using Multiple Git Accounts with SSH Keys

Libp2p

Essential libp2p

Nix

Essential Nix Commands

Nix Tips 'n Tricks

Using Derivations

Using Docker with Nix Flakes

Using Nix Flakes

Npm+yarn+pnpm

Building and Using NPM Packages Locally

Package Managers (P)NPM and Yarn

Understanding NPM Packages

Opencv

Using OpenCV in a C++ Application

Serialization

Tools for Serialization

Using Flatbuffers

Zeromq

ZeroMQ Basics

ZeroMQ Sockets and Patterns

On this page

Table of Contents for current page

Next pageHome