Thermocouple made from a nail and copper wire.

Thermocouple is a simple device to measure temperature by using Seebeck effect where a current is created in a heated conductor. The amount of current depends on temperature and the material from which the conductor was made. It's a common tool when measurement of relatively high temperatures is needed, also a lot of altimeters can measure temperature by using a thermocouple that usually is part of the multimeter set.

The thermocouple consist of two different conductors placed in the same temperature, because each one is made from a different material, the voltage that they produce differs. A thermocouple measure difference between those voltages.

In this post, I will present a simple version of a thermocouple, that I made by myself. If you like the idea of building your own sensors (even just for fun), you might be also interested in articles about home-made photo-element and DYI pressure sensor

I've tried built this sensor as simple as possible, so I used iron nail and a copper wire as parts of the thermocouple. I used a multimeter to measure voltage created by the thermocouple.

Is it possible to write a program in C without using semicolons?

Yes, it's possible! In this text I will show a set of tricks to do it. I will present this on a simple program that that reads two numbers from STDIN and prints theirs sum to the STDOUT.

Normally I would start this program from declaring two variables:

int a, b;

Unfortunately, there's a semicolon at the end of the line. It can be omitted by using variables already declared for the main function:

int main(int argc, char* argv[])

I will use argc as a and argv[0] as b. Normally, next thing would be reading two values from STDIN and placing them in a and b variables. It could be like this:

scanf("%d%d", &a, &b);

Once again, there's a semicolon! This one can be skipped by using 'if' statement:

if (scanf("%d%d", &a, &b)) {}

The same trick can be used for printing to STDOUT:

if( printf("%d", a + b ) ){}

Above code compiles and works correctly, but normally the main function should return zero if everything went OK:

return 0;

This semicolon can't be avoided by using the trick with 'if' statement, but we other construction can help here:


That's all, below is full source code:

#include <stdio.h>
#include <unistd.h>

int main(int argc, char* argv[]) {
    if (scanf("%d%d", &argc, &argv[0])) {}
    if (printf("%d", argc+argv[0])) {}
    if (brk(0)) {}

Leave a comment, if you know other interesting riddles or tricks that can be used here!

Breaking CAPTCHA in Python

Usually CAPTCHAs are analyzed by using neural network, it's a good approach, but it may be overcomplicated in simple cases. Presented below, much shorter algorithm can produce sufficient results for uncomplicated CAPTCHAs.

In this algorithm an image with unknown letter is compared with samples of known letters, the letter in the most similar sample is probably also the letter in analyzed image. It was implemented as a Python script, usage presented below:

captcha breaker in python, sample of usage
bash-3.2$ python test1.png 
other sample of usage of the script for breaking CAPTCHAs in Python
bash-3.2$ python test2.png 

It can't be directly used on a raw CAPTCHA, firstly small artifacts have to be removed from the CAPTCHA, secondly each letter should be stored in a separate image.

Edge Detection by using Genetic Algorithms


In this post I will present an algorithm for searching edges in images by using genetic approach.


The image is preprocessed before its usage, firstly Gaussian blur is used to remove small artifacts that could pollute the result. I could be also done by using image downsizing and upsizing as I presented in the post about breaking captcha. Secondly the image is converted to black and white version to simplify the implementation.

Original image:

input image used in edge detection based on genetic algorithm

Edges found by using a genetic algorithm (100 generations):

output image produced by genetic algorithm applied to search edges in the image

In presented version each children has only one parent, so gene change is provided only by mutation. Each specimen has two genes: X and Y that describes a location on the image. If a specimen has a good set of genes (they point to a location near the edge), then he's healthy and strong so he can breed, but if his genes are weak, then he's weak too and soon he dies. The edge is defined by a fitness function as a point that has neighbor points with different color.

Strong species breed so after couple of generations theirs children will cover the whole edge. The final result is a set of genes (each is a point on the image) in the last generation.

Virtual Machine implemented as a Domain Specific Language in Ruby


Some time ago I created a simple programming language that was compiled to its own assembly language, a file in this assembly language could be executed in a Virtual Machine or be compiled to an executable form. Today I will present an idea how to use Domain Specific Language (DSL) created in Ruby to load and execute the assembly file just as a regular Ruby script.


A sample of an assembly file is presented below, it's intuitive except the "int" mnemonic, it means "interruption", int 0 pops element from the stack and prints it on STDOUT. There aren't any registers, everything is done by using a stack.

    int 0

    call bar

    push 13
    call foo

Motion estimation in super-resolution algorithms


One of important steps in super resolution algorithms is the estimation of initial constants, without this the algorithms will produce useless higher resolution images.

From mathematical view, we may say that during taking a photo, the original scenery is gathered in high resolution, with some movement between each image (e.g. shaking hand or satellite moving on its orbit), next psf and the noise is added, at the end the image is downscaled.

motion estimation in python, used for super resolution algorithms

To obtain higher resolution we need to somehow revert this process, to do that we need to estimate mentioned movements. In this post I will present two simple algorithms that I used to estimate the movement between images.

German tank problem

Sometimes science is applied in really amazing ways, one of examples is German tank problem. During World War II, the Allies observed that the Nazis created a new model of tank. Total number of manufactured units was unknown, but the Allies, know serial numbers of some tanks. In this case, the first produced tank has serial number starts = 1, the second has serial number = 2, etc. How the Allies could estimate total amount of manufactured tanks?

Answer may be estimated by using simple equitation. Let's assume that N = estimated total amount of enemy tanks, k = amount of observed tanks, m = maximum observed serial number. Then:

N = m - 1 + m/k


We observed enemy tanks with serial numbers: 20, 23, 45, 47, 48. In this case, m=48, k=4, answer can be computed on calculator or for example in R language (I really like to use it as a powerful "calculator"):

> 48 - 1 + 48/4
[1] 59

Other use cases

The same as used for German tank problem was used to estimate amount of sold Apple's products. The customers were asked to upload their serial numbers.

Zapper built from NAND gates

Zapper, what's that?

The zapper is a simple device intended to fight against parasites that, if present in the human body, can do a lot of harm. As far as I know, it's not proved by any scientific source that it actually works, and despite time, it still stays in the zone of unproven/unscientific inventions. Personally, I think that it can work as described.

From a technical point of view, a zapper consists of a square wave generator, a resistor connected to its output that limits the power of the signal delivered to the body and two electrodes. One of the electrodes is connected to the mass of the circuit, second one is connected to mentioned resistor. Frequency can be adjusted from tens of Hz to tens of kHz.

Is it safe?

I don't claim that it is, but personally I think that it is if someone doesn't have cardiac problems. If you want to build it by yourself, you do this on your own risk.

Circuit of a zapper

Almost all Zippers are build from NE555, unfortunately I hadn't has it, so instead I used 4093 (2-input Schmitt NAND gates). The electrodes were made from aluminium foil.

The value of R1 should be 33k.

You can also visit this site to get more similar circuits including the original one.