New articles - OurBigBook.com

x86 Paging Tutorial / Example: multi-level paging scheme by

Ciro Santilli 40 Updated 2025-07-16

x86 Paging Tutorial / Multi-level paging scheme numerical translation example by

Ciro Santilli 40 Updated 2025-07-16

Page directory given to process by the OS:

entry index   entry address      page table address  present
-----------   ----------------   ------------------  --------
0             CR3 + 0      * 4   0x10000             1
1             CR3 + 1      * 4                       0
2             CR3 + 2      * 4   0x80000             1
3             CR3 + 3      * 4                       0
...
2^10-1        CR3 + 2^10-1 * 4                       0

Page tables given to process by the OS at PT1 = 0x10000000 (0x10000 * 4K):

entry index   entry address      page address  present
-----------   ----------------   ------------  -------
0             PT1 + 0      * 4   0x00001       1
1             PT1 + 1      * 4                 0
2             PT1 + 2      * 4   0x0000D       1
...                                  ...
2^10-1        PT1 + 2^10-1 * 4   0x00005       1

Page tables given to process by the OS at PT2 = 0x80000000 (0x80000 * 4K):

entry index   entry address     page address  present
-----------   ---------------   ------------  ------------
0             PT2 + 0     * 4   0x0000A       1
1             PT2 + 1     * 4   0x0000C       1
2             PT2 + 2     * 4                 0
...
2^10-1        PT2 + 0x3FF * 4   0x00003       1

where PT1 and PT2: initial position of page table 1 and page table 2 for process 1 on RAM.

With that setup, the following translations would happen:

linear    10 10 12 split  physical
--------  --------------  ----------
00000001  000 000 001     00001001
00001001  000 001 001     page fault
003FF001  000 3FF 001     00005001
00400000  001 000 000     page fault
00800001  002 000 001     0000A001
00801004  002 001 004     0000C004
00802004  002 002 004     page fault
00B00001  003 000 000     page fault

Let's translate the linear address 0x00801004 step by step:

In binary the linear address is:

0    0    8    0    1    0    0    4
0000 0000 1000 0000 0001 0000 0000 0100

Grouping as 10 | 10 | 12 gives:

0000000010 0000000001 000000000100
0x2        0x1        0x4

which gives:

page directory entry = 0x2
page table     entry = 0x1
offset               = 0x4

So the hardware looks for entry 2 of the page directory.

The page directory table says that the page table is located at 0x80000 * 4K = 0x80000000. This is the first RAM access of the process.
Since the page table entry is 0x1, the hardware looks at entry 1 of the page table at 0x80000000, which tells it that the physical page is located at address 0x0000C * 4K = 0x0000C000. This is the second RAM access of the process.
Finally, the paging hardware adds the offset, and the final address is 0x0000C004.

Page faults occur if either a page directory entry or a page table entry is not present.

The Intel manual gives a picture of this translation process in the image "Linear-Address Translation to a 4-KByte Page using 32-Bit Paging": Figure 1. "x86 page translation process"

Figure 1.
x86 page translation process
.

x86 Paging Tutorial / Memory management unit by

Ciro Santilli 40 Updated 2025-07-16

Paging is done by the Memory Management Unit (MMU) part of the CPU.

Like many others (e.g. x87 co-processor, APIC), this used to be by separate chip on early days.

It was later integrated into the CPU, but the term MMU still used.

Type of processor by

Ciro Santilli 40 Updated 2025-07-16

Field-programmable gate array by

Ciro Santilli 40 Updated 2025-07-16

It basically replaces a bunch of discrete digital components with a single chip. So you don't have to wire things manually.

Particularly fundamental if you would be putting those chips up a thousand cell towers for signal processing, and ever felt the need to reprogram them! Resoldering would be fun, would it? So you just do a over the wire update of everything.

Vs a microcontroller: same reason why you would want to use discrete components: speed. Especially when you want to do a bunch of things in parallel fast.

One limitation is that it only handles digital electronics: electronics.stackexchange.com/questions/25525/are-there-any-analog-fpgas There are some analog analogs, but they are much more restricted due to signal loss, which is exactly what digital electronics is very good at mitigating.

First FPGA experiences with a Digilent Cora Z7 Xilinx Zynq by Marco Reps (2018)

Source. Good video, actually gives some rationale of a use case that a microcontroller wouldn't handle because it is not fast enough.

Video 2.

FPGA Dev Board Tutorial by Ben Heck (2016)

Source.

Video 3.

The History of the FPGA by Asianometry (2022)

Source.

Heroku by

Ciro Santilli 40 Updated 2025-07-16

This feels good.

One problem though is that Heroku is very opinionated, a likely like other PaaSes. So if you are trying something that is slightly off the mos common use case, you might be fucked.

Another problem with Heroku is that it is extremely difficult to debug a build that is broken on Heroku but not locally. We needed a way to be able to drop into a shell in the middle of build in case of failure. Otherwise it is impossible.

Deployment:

git push heroku HEAD:master

View stdout logs:

heroku logs --tail

PostgreSQL database, it seems to be delegated to AWS. How to browse database: stackoverflow.com/questions/20410873/how-can-i-browse-my-heroku-database

heroku pg:psql

Drop and recreate database:

heroku pg:reset --confirm <app-name>

All tables are destroyed.

Restart app:

heroku restart

Supercomputer by owner by

Ciro Santilli 40 Updated 2025-07-16

Raspberry Pi Pico W MicroPython example by

Ciro Santilli 40 Updated 2025-07-27

An upstream repo at: github.com/raspberrypi/pico-micropython-examples

Some generic Micropython examples most of which work on this board can be found at: Section "MicroPython example".

Pico W specific examples are under: rpi-pico-w/upython.

The examples can be run as described at Program Raspberry Pi Pico W with MicroPython.

rpi-pico-w/upython/led_on.py: turn on-board LED on and leave it on forever. Useful to quickly check that you are still able to update the firmware.
rpi-pico-w/upython/led_off.py: turn on-board LED off and leave it off forever
rpi-pico-w/upython/pwm.py: pulse width modulation. Using the same circuit as the rpi-pico-w/upython/blink_gpio.py, you will now see the external LED go from dark to bright continuously and then back

The best television series by

Ciro Santilli 40 Updated 2025-07-16

The BBC 1979-1982 adaptations of John Le Carré's novels are the best miniseries ever made:

They are the most realistic depiction of spycraft ever made.

Some honorable mentions:

Futurama
- S02E15 The Problem With Popplers, see also: animal rights. There has to be prior art on this idea, there has to, can someone please point it out?
- S06E09 A Clockwork Origin
Rick and Morty before it turned to shit on season 3 had some genius moments:
- S02E04 Total Rickall
- Rick and Morty A Life Well Lived

Bibliography:

British
- www.telegraph.co.uk/tv/0/best-tv-shows-ever-all-time-greatest-british-series-uk-2021/
- www.reddit.com/r/CasualUK/comments/qqaie8/suggest_me_some_good_british_tv_series/
TODO:
- Porterhouse Blue
- Oranges are Not the Only Fruit
- The Prisoner

Fax by

Ciro Santilli 40 Updated 2025-07-16

Uses telephone lines, and therefore were still usable much much after the Internet made them obsolete, which is quite funny.

Teletype ASR 33 Part 10: ASR 33 demo by CuriousMarc (2020)

Source.

Video 2.

Fax Machine by Museum of Obsolte Objects (2011)

Source.

Amateur radio by

Ciro Santilli 40 Updated 2025-07-16

Information theory by

Ciro Santilli 40 Updated 2025-07-16

Programmer's model of quantum computers by

Ciro Santilli 40 Updated 2025-07-16

This is a quick tutorial on how a quantum computer programmer thinks about how a quantum computer works. If you know:

a concrete and precise hello world operation can be understood in 30 minutes.

Although there are several types of quantum computer under development, there exists a single high level model that represents what most of those computers can do, and we are going to explain that model here. This model is the is the digital quantum computer model, which uses a quantum circuit, that is made up of many quantum gates.

Beyond that basic model, programmers only may have to consider the imperfections of their hardware, but the starting point will almost always be this basic model, and tooling that automates mapping the high level model to real hardware considering those imperfections (i.e. quantum compilers) is already getting better and better.

The way quantum programmers think about a quantum computer in order to program can be described as follows:

the input of a N qubit quantum computer is a vector of dimension N containing classic bits 0 and 1
the quantum program, also known as circuit, is a $2^{n} \times 2^{n}$ unitary matrix of complex numbers $Q \in C^{2^{n}} \times C^{2^{n}}$ that operates on the input to generate the output
the output of a N qubit computer is also a vector of dimension N containing classic bits 0 and 1

To operate a quantum computer, you follow the step of operation of a quantum computer:

set the input qubits to classic input bits (state initialization)
press a big red "RUN" button
read the classic output bits (readout)

Each time you do this, you are literally conducting a physical experiment of the specific physical implementation of the computer:

setup your physical system to represent the classical 0/1 inputs
let the state evolve for long enough
measure the classical output back out

and each run as the above can is simply called "an experiment" or "a measurement".

The output comes out "instantly" in the sense that it is physically impossible to observe any intermediate state of the system, i.e. there are no clocks like in classical computers, further discussion at: quantum circuits vs classical circuits. Setting up, running the experiment and taking the does take some time however, and this is important because you have to run the same experiment multiple times because results are probabilistic as mentioned below.

Unlike in a classical computer, the output of a quantum computer is not deterministic however.

But the each output is not equally likely either, otherwise the computer would be useless except as random number generator!

This is because the probabilities of each output for a given input depends on the program (unitary matrix) it went through.

Therefore, what we have to do is to design the quantum circuit in a way that the right or better answers will come out more likely than the bad answers.

We then calculate the error bound for our circuit based on its design, and then determine how many times we have to run the experiment to reach the desired accuracy.

The probability of each output of a quantum computer is derived from the input and the circuit as follows.

First we take the classic input vector of dimension N of 0's and 1's and convert it to a "quantum state vector"

q_{in}

of dimension

2^{n}

q_{in} \in C^{2^{n}}

(1)

We are after all going to multiply it by the program matrix, as you would expect, and that has dimension

2^{n} \times 2^{n}

Note that this initial transformation also transforms the discrete zeroes and ones into complex numbers.

For example, in a 3 qubit computer, the quantum state vector has dimension

2^{3} = 8

and the following shows all 8 possible conversions from the classic input to the quantum state vector:

000 -> 1000 0000 == (1.0, 0.0, 0.0, 0.0,  0.0, 0.0, 0.0, 0.0)
001 -> 0100 0000 == (0.0, 1.0, 0.0, 0.0,  0.0, 0.0, 0.0, 0.0)
010 -> 0010 0000 == (0.0, 0.0, 1.0, 0.0,  0.0, 0.0, 0.0, 0.0)
011 -> 0001 0000 == (0.0, 0.0, 0.0, 1.0,  0.0, 0.0, 0.0, 0.0)
100 -> 0000 1000 == (0.0, 0.0, 0.0, 0.0,  1.0, 0.0, 0.0, 0.0)
101 -> 0000 0100 == (0.0, 0.0, 0.0, 0.0,  0.0, 1.0, 0.0, 0.0)
110 -> 0000 0010 == (0.0, 0.0, 0.0, 0.0,  0.0, 0.0, 1.0, 0.0)
111 -> 0000 0001 == (0.0, 0.0, 0.0, 0.0,  0.0, 0.0, 0.0, 1.0)

This can be intuitively interpreted as:

if the classic input is 000, then we are certain that all three bits are 0.
Therefore, the probability of all three 0's is 1.0, and all other possible combinations have 0 probability.
if the classic input is 001, then we are certain that bit one and two are 0, and bit three is 1. The probability of that is 1.0, and all others are zero.
and so on

Now that we finally have our quantum state vector, we just multiply it by the unitary matrix

Q

of the quantum circuit, and obtain the

2^{n}

dimensional output quantum state vector

q_{o u t}

q_{o u t} = Q q_{in}

(2)

And at long last, the probability of each classical outcome of the measurement is proportional to the square of the length of each entry in the quantum vector, analogously to what is done in the Schrödinger equation.

For example, suppose that the 3 qubit output were:

q_{o u t} = \frac{3}{2} 0.0 \frac{1}{2} 0.0 0.0 0.0 0.0 0.0

(3)

Then, the probability of each possible outcomes would be the length of each component squared:

P (000) P (001) P (010) P (011) P (100) P (101) P (110) P (111) = \frac{3}{2}^{2} = ∣ 0 ∣^{2} = \frac{1}{2}^{2} = ∣ 0 ∣^{2} = ∣ 0 ∣^{2} = ∣ 0 ∣^{2} = ∣ 0 ∣^{2} = ∣ 0 ∣^{2} = \frac{3}{2}^{2} = 0^{2} = \frac{1}{2}^{2} = 0^{2} = 0^{2} = 0^{2} = 0^{2} = 0^{2} = \frac{3}{4} = 0 = \frac{1}{4} = 0 = 0 = 0 = 0 = 0

(4)

i.e. 75% for the first, and 25% for the third outcomes, where just like for the input:

first outcome means 000: all output bits are zero
third outcome means 010: the first and third bits are zero, but the second one is 1

All other outcomes have probability 0 and cannot occur, e.g.: 001 is impossible.

Keep in mind that the quantum state vector can also contain complex numbers because we are doing quantum mechanics, but we just take their magnitude in that case, e.g. the following quantum state would lead to the same probabilities as the previous one:

\frac{1 + 2 i}{2}^{2} \frac{i}{2}^{2} = \frac{1 ^{2} + 2 ^{2}}{2 ^{2}} = \frac{1 ^{2}}{2 ^{2}} = \frac{3}{4} = \frac{1}{4}

(5)

This interpretation of the quantum state vector clarifies a few things:

the input quantum state is just a simple state where we are certain of the value of each classic input bit
the matrix has to be unitary because the total probability of all possible outcomes must be 1.0
This is true for the input matrix, and unitary matrices have the probability of maintaining that property after multiplication.
Unitary matrices are a bit analogous to self-adjoint operators in general quantum mechanics (self-adjoint in finite dimensions implies is stronger)
This also allows us to understand intuitively why quantum computers may be capable of accelerating certain algorithms exponentially: that is because the quantum computer is able to quickly do an unitary matrix multiplication of a humongous $2^{N}$ sized matrix.
If we are able to encode our algorithm in that matrix multiplication, considering the probabilistic interpretation of the output, then we stand a chance of getting that speedup.

As we could see, this model is was simple to understand, being only marginally more complex than that of a classical computer, see also: quantumcomputing.stackexchange.com/questions/6639/is-my-background-sufficient-to-start-quantum-computing/14317#14317 The situation of quantum computers today in the 2020's is somewhat analogous to that of the early days of classical circuits and computers in the 1950's and 1960's, before CPU came along and software ate the world. Even though the exact physics of a classical computer might be hard to understand and vary across different types of integrated circuits, those early hardware pioneers (and to this day modern CPU designers), can usefully view circuits from a higher level point of view, thinking only about concepts such as:

logic gates like AND, NOR and NOT
a clock + registers

as modelled at the register transfer level, and only in a separate compilation step translated into actual chips. This high level understanding of how a classical computer works is what we can call "the programmer's model of a classical computer". So we are now going to describe the quantum analogue of it.

Bibliography:

arxiv.org/pdf/1804.03719.pdf Quantum Algorithm Implementations for Beginners by Abhijith et al. 2020

Comedian by

Ciro Santilli 40 Updated 2025-07-16

Hertz electromagnetic wave experiments by

Ciro Santilli 40 Updated 2025-07-16

en.wikipedia.org/wiki/Heinrich_Hertz#Electromagnetic_waves

Heinrich Hertz's main initial experiment used a spark-gap transmitter. It is not something that transmits recorded sounds like voice: it only transmits noisy beeps. And as such was used for wireless telegraphy.

Hertz Experiment on Electromagnetic Waves by Ludic Science (2015)

Source. Simplified recreation with cheap modern equipment. Uses as transmitter power source both:

a piezo igniter from a barbequeue lighter
a more powerful home-made transformer

and the signal is observed on the receiver with a neon lamp

Video 2.

Hertz and Radio waves Explained by PhysicsHigh (2016)

Source. Simple schematics showing the basics of the experiments. No choice of components rationale.

Quantum optimization algorithm by

Ciro Santilli 40 Updated 2025-07-16

Quantum computing is hard because we want long coherence but fast control by

Ciro Santilli 40 Updated 2025-07-16

Mentioned e.g. at:

These are two conflicting constraints:

long coherence times: require isolation from external world, otherwise observation destroys quantum state
fast control and readout: require coupling with external world

Pasqal by

Ciro Santilli 40 Updated 2025-07-16

pasqal.io/

Funding:

2023: $100m techcrunch.com/2023/01/23/pasqal-raises-100m-to-build-a-neutral-atom-based-quantum-computer/

Qiskit hello world by

Ciro Santilli 40 Updated 2025-07-16

The official hello world is documented at: qiskit.org/documentation/intro_tutorial1.html and contains a Bell state circuit.

Our version at qiskit/hello.py.

 Pinned article: Introduction to the OurBigBook Project

Welcome to the OurBigBook Project! Our goal is to create the perfect publishing platform for STEM subjects, and get university-level students to write the best free STEM tutorials ever.

Everyone is welcome to create an account and play with the site: ourbigbook.com/go/register. We belive that students themselves can write amazing tutorials, but teachers are welcome too. You can write about anything you want, it doesn't have to be STEM or even educational. Silly test content is very welcome and you won't be penalized in any way. Just keep it legal!