cpq

#!/usr/bin/env python
# Copyright (c) 2011 by Sergey Lyubka
# All rights reserved
#
# This program calculates note frequencies for chromatic and natural scale.

# Chromatic scale is built by splitting an octave (2x frequency bump) onto
# 12 equal intervals (semitones).
semitones = ['%.5f' % pow(pow(2, x), 1 / 12.0) for x in range(13)]
tones = [0, 2, 4, 5, 7, 9, 11]  # Major scale

cpq

// Copyright (c) Sergey Lyubka, 2013.
// All rights reserved.
// Released under the MIT license.

// This program is used to embed arbitrary data into a C binary. It takes
// a list of files as an input, and produces a .c data file that contains
// contents of all these files as collection of char arrays.
// Usage:
//   1. Compile this file:
//      cc -o embed embed.c

cpq

/*
 * Large integer manipulation functions.
 * All integers are assumed to be unsigned and represented as
 * a contiguous array of bytes (unsigned char *ptr, int len)
 * in little-endian byte order (ptr points to the least significant byte).
 */

#define  HUGE	4096	/* Length of the biggest integer in bytes */

/*

cpq

// Copyright (c) 2013 Sergey Lyubka
// All rights reserved
//
// An example of mjpg streaming using mongoose web server.
// Usage:
//    cc mjpg.c mongoose.c && ./a.out
// This code is public domain.

#include <sys/stat.h>
#include <string.h>

cpq

// Usage:
// cc -W -Wall ~/tmp/quoted_string_parser.c
// ./a.out "  dwedewd, dede"  " 'sds ee' ,'ddd'"

#include <stdio.h>
#include <string.h>

static const char *whitespaces = " \r\n";
static const char *whitespaces_or_comma = " \r\n,";

cpq

What is a mutex and how does it work

Imagine a big office (your program), with many assets (shared resources) and many employees (threads). For example, all employees share one common resource - a toilet. They have agreed to use a label on a toilet's door (mutex).

When an employee wants to use the toilet he checks a label on a door (locks a mutex). If it is "engaged" he waits (blocks on a mutex), then when it is "free", he enters the toilet and changes the label to

cpq

What is a hash and how does it work

Let us start from a practical example. Imagine we are writing a traffic monitoring application. The purpose of application would be to calculate a number of bytes sent by each IP address. To do that, let create a structure that does that accounting:

struct ipstat {

uint32_t ip; /* Source IP address */

cpq

Why stack grows down

Any running process has several memory regions: code, read-only data, read-write data, et cetera. Some regions, such as code and read-only data, are static and do not change over time. Other regions are dynamic: they can expand and shrink. Usually there are two such regions: dynamic read-write data region, called heap, and a region called stack. Heap holds dynamic memory allocations, and stack is mostly used for keeping function frames.

Both stack and heap can grow. An OS doesn't know in advance whether stack or heap will be used predominantly. Therefore, an OS must layout these two memory regions in a way to guarantee maximum space for both. And here is the solution:

1. Layout static memory regions at the edges of process's virtual memory
2. Put heap and stack on edges too, and let them grow towards each other: one grows up, one grows down

cpq

// Copyright (c) 2014 Sergey Lyubka. All rights reserved.
// Arithmetic expression evaluator.
//
// Compilation:   cc -o eval_arith eval_arith.c
// Usage:         ./eval_arith "2 - 3 * ( 4 - 2.7 * 11.5 ) + 1.78"

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

cpq

#define END_OF_PARAMS   (-1)

// Each extensible function is going to have it's own params enum
enum {
  SEND_FILE_EXTRA_HEADER,  // next arg is const char *
  SEND_FILE_BYTE_RANGE,    // next args are size_t, size_t
  SEND_FILE_NUM_PARAMS
};

int mg_send_file(const char *path, ...) {