togglebit.io

Fifteen to one

2026-05-10T00:00:00+00:00

🔗</a>Intro</h2>
A few days ago I was feeling particularly tired but had a lot of things I wanted to get done that day, so I casually asked my wife "how long do you need to sit before you are rested and can get on with things again". She didn't have an answer, and that makes sense because the answer depends on way too many variables.
The next day I was on a call with a friend and I asked him the same question in the passing, and he blurted out "fifteen minutes". Thinking it was a rather funny (because of how he said it) and definitive answer it kind of stuck with me.
Fast forward a few days and it's Sunday morning and we are doing the No-Internet</a> challenge again, which is a perfect time to sit down and write, and I asked the wife if she was up for another challenge.
The whole family has adopted the No-Internet one without too many complaints so she was game.

🔗</a>The rules</h2>

You can sit for at most 15 minutes at a time.</li>
After 15 minutes you have to stand up and perform a task before you sit down again.</li>
Repeat this for seven hours</li> </ul>
What qualifies as a task is up to you but I'll share a few examples:

Clear something away / put something back where it belongs</li>
Empty the dish washer</li>
Spend a minute or two petting the family pet, assuming it's alive and also not a tiger.</li>
Water the plants</li>
Go for walk</li> </ul>
A task doesn't have to be big, but it doesn't have to be small either as long as you don't sit down while you perform it.
🔗</a>Run time</h2>
This challenge runs for one day
Feel free to post your summary each day on our Discord!
The format of the post:
`Challenge: 15-1 Did you manage: yes / no (only answer "no" if you gave up) Did you feel productive yes / no</code></pre> Good luck!`


No-Internet challenge
2026-03-23T00:00:00+00:00
This challenge came about from having my ISP do a sneaky shutdown of my internet
due to technical issues (they claim, but I suspect it was malice).</p>
I found my self being rather productive during this time and so I told the wife
about this.</p>
We then decided to try this out the coming Saturday and turned the modem off
between 06:00 and 13:00.</p>
As a result we got so much done we decided to do it again the next day, but for
a shorter period, so we turned it off between 06:00 and 11:00.</p>
For me this runs from Saturday to Sunday, however if you wanna do this and those
days doesn't work then pick two other consecutive days, and make the second day
shorter.</p>
The TL;DR is this:
Turn off your modem / router / fibre-magic-box / FrizBox for a few hours and log your
productivity.</p>
The goal of this is just a bit of fun but it can also help with getting things done.</p>
🔗</a>The rules</h2>

No internet connection for a dedicated time slot during two consecutive days</li>
</ul>
🔗</a>Optional rules</h3>

Allow a singular device for information lookup (e.g a phone with mobile data).</li>
Don't allow any screen time whatsoever.</li>
</ul>
🔗</a>Run time</h2>
This challenge runs for two days (feel free to repeat it).</p>

Day 1: seven hours</li>
Day 2: five hours</li>
</ul>
Write down the tasks you have worked on or even finished during this
time window and post your summary each day on our Discord</p>
The format of the post:</p>
Day #</span></span>
Tasks: </span></span>
    * list</span></span>
    * of</span></span>
    * tasks</span></span>
Did you manage: yes / no (only answer "no" if you gave up)</span></span></code></pre>
E.g</p>
Day 1</span></span>
Tasks:</span></span>
    * Wrote some Rust</span></span>
    * Did some CAD</span></span>
    * Invented a card game</span></span>
Did you manage the entire time: yes</span></span></code></pre>
Good luck!</p>


Focus challenge
2025-04-20T00:00:00+00:00
I issued a challenge to my self ( and my community on Discord ) to see if we
could reclaim some of our stolen focus.</p>
The TL;DR is this:
see if you can focus on a specific task for a given amount of time each day for
five days.</p>
The goal of this is just a bit of fun but it can also help with getting things done
through pre-commitment.</p>
🔗</a>The rules</h2>

Use of the browser: only documentation sites (no videos)</li>
No phone (I set mine to Do Not Disturb, it really helps)</li>
Music: yes of course (make a playlist even)</li>
Get up and stretch is fine, but don't engage in another activity</li>
</ul>
Notes for clever clogs and smarty pants:</strong></p>

Yes of course you can use the bathroom, you lark</li>
If you are doing mobile dev or web dev then of course you have to use the
browser / phone, the point is that you don't use it to browse social media or
drown your brain in YouTube videos.</li>
</ul>
🔗</a>Set a timer for when you start:</h2>

Day 1: 30 min</li>
Day 2: 30 min</li>
Day 3: 45 min</li>
Day 4: 45 min</li>
Day 5: 60 min</li>
</ul>
If you get distracted don't give up,
note down what distracted you and how far into the countdown you were, so you can track your distractions.</p>
Find a task / project to work on and post your daily summary either on our
Discord or on Bluesky (I use #focuschallenge</code>).</p>
The format of the post:</p>
Day #</span></span>
Working on: <task></span></span>
Number of interruptions #</span></span>
Did you manage the entire time: yes / no (only answer "no" if you gave up before the time ran out)</span></span></code></pre>
E.g</p>
Day 1</span></span>
Working on: a text layout engine in Rust</span></span>
Number of interruptions: 3</span></span>
Did you manage the entire time: yes</span></span></code></pre>
Good luck!</p>


Setting up a personal crates repository using Git
2024-08-26T00:00:00+00:00
For this post Github is used, but any Git repository could be used.</p>
🔗</a>Create the crate</h2>
The first crate is to have something that can be added to the registry.
This is to confirm that it's working, and for the sake of this post the crate
will be referred to as greeter</code>.</p>
An example (which is used for the remainder of this post) would be a library
with a public function:</p>
pub fn</span> greet</span>() { </span></span>
    println!</span>(</span>"hello"</span>);</span></span>
}</span></span></code></pre>
To generate a .crate</code> file run cargo package</code>.
The package will be located in target/package/greeter-0.1.0.crate</code>.</p>
The checksum can be generated with sha256sum greeter-0.1.0.crate</code>, assuming
it's available.</p>
🔗</a>Create the Registry</h2>
Create and initialise a git repository.
For the sake of this post the repository will be named pubreg</code>.</p>
The repository should contain a config.json</code> file, along with index files.
An index file contains version and meta information about a
crate, so each crate has its own index file with the same name as the crate.</p>
Given a crate by the name greeter</code> there should be two files:</p>

greeter</code> the index file</li>
greeter.crate</code> the crate</li>
</ul>
First step is to define the config.json</code> file that describes the download path
for each crate.</p>
This file should only contain a single entry:</p>
{</span></span>
    "dl"</span>:</span> "https://raw.githubusercontent.com/<username>/pubreg/main/crates/{crate}/{version}.crate"</span>,</span></span>
    "api"</span>:</span>null</span>,</span></span>
    "auth-required"</span>:</span>false</span></span>
}</span></span></code></pre>
The dl</code> value describes how to create the url for each crate.</p>

    
    Note that api</code> and auth-required</code> are not in use here.
For more information about these settings see: Index configuration</a>.</p>

</div>
Each crate should be uploaded to the crates</code> directory, under a sub directory
with the same name as the crate, and finally the crate it self should have the
version name as the filename.</p>
So the greeter</code> crate should, in the git repository, be located at:
crates/greeter/0.1.0.crate</code></p>
Each crate needs an index file with the same name as the crate, so for
the greeter</code> crate the index file would look as follows:</p>
{"name": "greeter","vers": "0.1.0","deps": [],"cksum": "2044d936f85f45c316aecc9159712c4a10c1e10413e6491eee0282825f499cce","features": {},"yanked": false,"links": null}</span></span></code></pre>
Each line in the index file represents a version of the crate, so the example
above is for one version of the greeter crate, and can not take up more than
one line in the index file.</p>
The file structure for index files are as follows:</p>
The following paragraph is taken directly from Index files</a>:</p>


Packages with 1 character names are placed in a directory named 1</code>.</li>
Packages with 2 character names are placed in a directory named 2</code>.</li>
Packages with 3 character names are placed in the directory 3/{first-character}</code> where {first-character}</code> is the first character of the package name.</li>
All other packages are stored in directories named {first-two}/{second-two}</code> where the top directory is the first two characters of the package name, and the next subdirectory is the third and fourth characters of the package name. For example, cargo would be stored in a file named ca/rg/cargo</code>.</li>
</ul>
</blockquote>
For more information see Index files</a>.</p>
So for the greeter</code> crate the index file would be located in gr/ee/</code> under the
name greeter</code>.</p>
🔗</a>Use the Registry</h2>
Create a project that will make use of the registry.</p>
Create a directory in the root of your project, named .cargo</code>, and add a
config.toml</code> file to that directory: .cargo/config.toml</code>.</p>
Inside the config.toml</code> file specify the registry settings:</p>
[</span>registries</span>]</span></span>
my-registry</span> =</span> { index</span> =</span> "https://github.com/<username>/pubreg/"</span> }</span></span></code></pre>
Adding greeter</code> as a dependency to Cargo.toml</code>:</p>
[</span>dependencies</span>]</span></span>
greeter</span> =</span> { version</span> =</span> "0.1.0"</span>,</span> registry</span> =</span> "my-registry"</span> }</span></span></code></pre>
    
    Note the registry</code> attribute.</p>

</div>
🔗</a>Sources</h2>

https://doc.rust-lang.org/cargo/reference/running-a-registry.html</a></li>
https://github.com/integer32llc/margo</a></li>
</ul>


Rust enums: a bit about size and optimisations
2022-11-14T00:00:00+00:00
🔗</a>Under the hood</h2>
An enum is made up of zero or more variants and a discriminator.</p>
enum</span> Choice</span> {</span></span>
    A</span>,</span>        // <-|</span></span>
    B</span>,</span>        // <-|- variants</span></span>
    C</span>         // <-|</span></span>
}</span></span></code></pre>
The discriminator is an integer indicating which variant is held.</p>
Given the following code: let a = Choice::A;</code> the discriminant would be zero.</p>
Given the following code: let c = Choice::C;</code> the discriminant would be two.</p>
🔗</a>Fieldless enums</h2>
An enum without associated data is a "fieldless" enum.</p>
It is possible to assign a custom discriminant value to a fieldless enum:</p>
enum</span> Choice</span> {</span></span>
    A</span> =</span> 10</span>,</span></span>
    B</span> =</span> 20</span>,</span></span>
    C</span>,</span></span>
}</span></span>
</span>
assert_eq!</span>(</span>Choice</span>::</span>A</span> as</span> usize</span>,</span> 10</span>);</span></span>
assert_eq!</span>(</span>Choice</span>::</span>B</span> as</span> usize</span>,</span> 20</span>);</span></span>
assert_eq!</span>(</span>Choice</span>::</span>C</span> as</span> usize</span>,</span> 21</span>);</span></span></code></pre>
If no specific value is
given as a discriminant the value is that of the previous variant plus one.</p>

    
    Note that Choice::C</code> is the same as Choice::B + 1</code>.</p>

</div>
🔗</a>Zero variant enum</h2>
An enum with no variants can never be created.
There are few use cases for such an enum but they do exist.</p>
One such use case is the error type on a Result<T, E></code> that can never fail, but
the return type still has to be a Result<T, E></code>.</p>
There is currently an enum in the standard library that exists for this reason:
Infallible</a>.</p>
🔗</a>Size</h2>
The size of an enum is the size of its largest variant + the discriminant
(unless the discriminant can be optimised away, more on this below).</p>
Given the following enum, we can look at the size of each variant:</p>
use</span> std</span>::</span>mem</span>::</span>size_of;</span> // returns the size of a type</span></span>
</span>
enum</span> Data</span> {</span></span>
    SingleByte</span>(</span>u8</span>),</span> // size of u8</span></span>
    Bytes</span>(</span>Vec</span><</span>u8</span>>),</span> // size of Vec<u8></span></span>
    NoData</span>          // zero size</span></span>
}</span></span></code></pre>
The size of Data::SingleByte(u8)</code> is one (as one byte is needed to store a u8</code>).</p>
A Vec<T></code> contains more
information:</p>

A pointer to the first value (a pointer has the same size as a usize</code>)</li>
The capacity (usize</code>) of the vector</li>
The size (usize</code>)</li>
</ul>
On a 64 bit architecture a usize</code> is a 64 bit integer, making it eight bytes in
size.</p>
use</span> std</span>::</span>mem</span>::</span>size_of;</span></span>
</span>
let</span> size</span> =</span> size_of</span>::</span><</span>usize</span>>()</span>  // first the pointer</span></span>
         +</span> size_of</span>::</span><</span>usize</span>>()</span>  // then the capacity</span></span>
         +</span> size_of</span>::</span><</span>usize</span>>();</span> // then the length</span></span>
</span>
// usize = 8 bytes on a 64 bit architecture</span></span>
assert_eq</span>(size,</span> 24</span>);</span></span></code></pre>
This makes Data::Bytes(byte_vec)</code> the largest variant, taking up 24 bytes (assuming 64 bit arch).</p>

    
    The values inside</strong> the vector is not taken into consideration when talking
about the size of the vector here.</p>

</div>
It might seem wasteful that [Data::NoData, Data::NoData]</code> takes up the same
amount of space as [Data::Bytes(bytes), Data::Bytes(more_bytes)]</code>, but it makes
sense from the perspective of a stack frame, or storing
multiple enums in a collection (like an array or a vector).</p>
Given the following:</p>
let</span> data</span>:</span> Vec</span><</span>Data</span>></span> =</span> get_data</span>();</span></span>
let</span> some_payload</span> = &</span>data[</span>4</span>];</span></span></code></pre>
Without a fixed size it would be rather difficult to jump straight to the fifth
entry in the vector, nor would it be possible to determine the size of a stack
frame, something Rust needs to know at compile time.</p>
🔗</a>Optimisations</h2>
The compiler can perform optimisations on an enum depending on the variants.</p>
If the size of an enum is the size of the largest variant plus the discriminant,
and the discriminant is eight bytes by default, the following enum should have a
size of 32 bytes (the Vec<u8></code> is 24, and the discriminant is eight).</p>
enum</span> Data</span> {</span></span>
    Bytes</span>(</span>Vec</span><</span>u8</span>>),</span></span>
    NoData</span></span>
}</span></span></code></pre>
However this enum has a size of 24 bytes.</p>
To observe this it's possible to transmute the enum to bytes:</p>
let</span> data</span> =</span> Data</span>::</span>Bytes</span>(</span>vec!</span>[</span>1</span>,</span> 2</span>,</span> 3</span>]);</span></span>
let</span> bytes</span>:</span> [</span>u8</span>;</span> mem</span>::</span>size_of</span>::</span><</span>Data</span>>()]</span>  =</span> unsafe</span> {</span> mem</span>::</span>transmute</span>(data) };</span></span>
println!</span>(</span>"{:?}"</span>, bytes);</span></span>
</span>
// Bytes:</span></span>
[</span></span>
    // Pointer to the first value on the heap</span></span>
    160</span>,</span> 10</span>,</span> 43</span>,</span> 168</span>,</span> 200</span>,</span> 85</span>,</span> 0</span>,</span> 0</span>, </span></span>
    // Capacity</span></span>
    1</span>,</span> 0</span>,</span> 0</span>,</span> 0</span>,</span> 0</span>,</span> 0</span>,</span> 0</span>,</span> 0</span>,</span></span>
    // Size</span></span>
    1</span>,</span> 0</span>,</span> 0</span>,</span> 0</span>,</span> 0</span>,</span> 0</span>,</span> 0</span>,</span> 0</span></span>
]</span></span></code></pre>
There is no discriminant in this data.</p>
If the second variant was transmuted to bytes the output would look something
like this:</p>
[</span></span>
    0, 0, 0, 0, 0, 0, 0, 0,</span></span>
    47, 236, 38, 139, 176, 127, 0, 0,</span></span>
    16, 170, 58, 244, 208, 85, 0, 0</span></span>
]</span></span></code></pre>
Note that the first eight bytes here are zero, a value that would be invalid for
the vector.
Thus the discriminant can be determined by the first bytes, rather than adding
an additional eight bytes specifically for it.</p>

    
    A vector is composed of three values.</p>
The first value is a pointer to the heap.
This value can never be zero, as that is reserved for the null pointer, and
since Rust doesn't allow null values it would be an invalid vector if the
pointer component was 0x0.</p>

</div>
The compiler can perform something called "niche filling".</p>
A niche in this context means a bit pattern that isn't valid.</p>
Take the following enum:</p>
enum</span> State</span> {</span></span>
    Processing</span>(</span>u8</span>,</span> bool</span>),</span></span>
    Done</span>,</span></span>
}</span></span></code></pre>
The first variant has two types: u8</code> and bool</code>.
This means the first byte can not be used to represent the discriminant as any
byte would be valid here.</p>
However the second type is a boolean, and there are only two valid values for a boolean:
zero or one.
Therefore we can use two to represent the second variant: State::Done</code>.</p>
// State::Processing(42, false)</span></span>
[</span>42</span>,</span> 0</span>]</span></span>
// State::Processing(42, true)</span></span>
[</span>42</span>,</span> 1</span>]</span></span>
// State::Done</span></span>
[</span>16</span>,</span> 2</span>]</span> // here 16 is an arbitrary value, only 2 is relevant</span></span></code></pre>
    
    The layout of types in Rust is not considered stable as Rust has an unstable ABI (Application Binary Interface).</p>
This means that the output of std::mem::transmute</code> might not be the same between
different versions of the compiler.</p>
The advantage of this is that new optimisations can be added to the compiler
without breaking existing code.</p>
The disadvantage is that it's not safe to transmute a series of bytes into a
type as the byte order, or even the size of the type might change from one
compiler to another.</p>

</div>
🔗</a>The end</h2>

The Rust book on enums</a></li>
The Rust reference</a></li>
</ul>
Thanks to twitch.tv/museun</a> for reading and correcting my mistakes</p>


Rust lifetime rules
2021-09-13T00:00:00+00:00
Elision rules are as follows:</p>
🔗</a>1.</h2>
Each elided lifetime in input position becomes a distinct lifetime parameter.</p>
Even though there are two inputs that have different lifetimes according to the
rules of lifetime elision, it is safe to elide the lifetime here as no reference
is returned.</p>
pub fn</span> do_something</span>(input</span>: &</span>str</span>, other_input</span>: &</span>str</span>) {</span></span>
}</span></span></code></pre>🔗</a>2.</h2>
If there is exactly one input lifetime position (elided or not), that lifetime is assigned to all elided output lifetimes.</p>
pub fn</span> first_do_something</span>(input</span>: &</span>str</span>)</span> -></span> (</span>&</span>str</span>,</span> &</span>str</span>) {</span></span>
    (input, input)</span></span>
}</span></span></code></pre>🔗</a>3.</h2>
If there are multiple input lifetime positions, but one of them is &self or &mut self, the lifetime of self is assigned to all elided output lifetimes.</p>
struct</span> Config</span> { </span></span>
    name</span>:</span> String</span></span>
}</span></span>
</span>
impl</span> Config</span> {</span></span>
    fn</span> name</span>(</span>&</span>self</span>, other_useless_val</span>: &</span>str</span>)</span> -> &</span>str</span> {</span></span>
        &</span>self</span>.</span>name </span>// <- same lifetime as &self</span></span>
    }</span></span>
}</span></span></code></pre>🔗</a>4.</h2>
Otherwise, it is an error to elide an output lifetime.</p>

    
    Given the following:</p>
fn</span> lifetimes</span><'</span>a</span>:</span> '</span>b</span>, '</span>b</span>>(a</span>: &</span>'</span>a str</span>, b</span>: &</span>'</span>b str</span>) {}</span></span></code></pre>
Read this as "'a</code> will live for at least as long as 'b</code>, rather than 'a</code> has
to outlive 'b</code>. It's a small distinction but a relevant one.</p>
See: lifetime coercion</a></p>

</div>

Source</a></li>
Common lifetime misconceptions</a></li>
</ul>


Bitwise cheat sheet for Rust
2021-07-06T00:00:00+00:00
🔗</a>Operators</h2>
AND         &</span></span>
OR          |</span></span>
NOT         !</span></span>
XOR         ^</span></span>
Left shift  <<</span></span>
Right shift >></span></span></code></pre>🔗</a>Get a bit</h3>
(i</span> >></span> n)</span> &</span> 1</span></span></code></pre>🔗</a>Set a bit</h3>
🔗</a>Set to 1</h4>
i</span> |</span> (</span>1</span> <<</span> n)</span></span></code></pre>🔗</a>Set to 0</h4>
i</span> & !</span>(</span>1</span> <<</span> n)</span></span></code></pre>🔗</a>Toggle a bit</h3>
i</span> ^</span> (</span>1</span> <<</span> n)</span></span></code></pre>
Source: https://nicolwk.medium.com/bitwise-operations-cheat-sheet-743e09aec5b5</a></p>
🔗</a>Examples</h2>
🔗</a>Clearing bits</h3>
Note that the following examples produce the same asm.</p>
🔗</a>Bit mask</h4>
let</span> mask</span> =</span> 0b00001111</span>;</span></span>
let</span> value</span> =</span> 0b1110101</span>;</span></span>
let</span> result</span> =</span> mask</span> &</span> value;</span></span>
assert_eq!</span>(result,</span> 0b00000101</span>);</span></span></code></pre>🔗</a>Shifting twice</h3>
Clearing half a byte by shifting all bits to the left and then back.</p>
let</span> value</span>:</span> u8</span> =</span> 0b1110101</span>;</span></span>
let</span> result</span> =</span> value</span> <<</span> 4</span> >></span> 4</span>;</span></span>
assert_eq!</span>(result,</span> 0b00000101</span>);</span></span></code></pre>
To clear the other half, change << 4 >> 4</code> to >> 4 << 4</code>.</p>


Debugging Rust with vim and neovim (in Linux)
2021-07-05T00:00:00+00:00
🔗</a>Step 1</h2>
Run :packadd termdebug</code> inside vim/nvim.
This is not some third party package manager, packadd</code> is built into vim.</p>
This has to be done for every instance, so if you want this to always be enabled
then add this to your vimrc.</p>
Also to use rust-gdb</code> rather than standard gdb</code> set let g:termdebugger="rust-gdb"</code>.</p>
🔗</a>Step 2</h2>
Build your project (so you have something to debug in ./target/debug/<your project></code>)</p>
🔗</a>Step 3</h2>
From within vim/nvim run :Termdebug target/debug/<your project></code>.
This will start gdb.</p>
Now you can set a breakpoint with :Break</code> and finally run the code with :Run</code>.</p>
🔗</a>Commands</h2>

:Break</code> sets a breakpoint where the cursor is</li>
:Run</code> starts the debugger</li>
:Clear</code> removes the breakpoint under the cursor</li>
:Over</code> steps over the current line</li>
:Step</code> steps into the current line</li>
:Continue</code> to continue execution</li>
:Evaluate</code> to execute selected code or code under cursor</li>
</ul>
For more information see :help Termdebug</code> inside vim/nvim.</p>
Note</strong> To see the value of the variable under the cursor: K</code> (shift + k) by
default.</p>

🔗</a>GDB dashboard</h2>
If you want to use gdb dashboard (this is useful as it lets you see the locals
all the time) you can get this from https://github.com/cyrus-and/gdb-dashboard/</a>
(check your package manager if you are on Linux as it might exist there as
well).</p>
Create $XDG_CONFIG/gdb-dashboard/init</code> and add the follow lines:</p>
dashboard -layout variables</span></span>
dashboard variables -style compact False</span></span></code></pre>
    
    A hack:
Somewhere around line 527 (at the time of writing) there is an if-statement that checks if you are
running inside gdb</code> or printing to a file.</p>
if</span> fs</span> is not</span> gdb</span> or</span> clear_screen</span>:</span></span>
    buf</span> +=</span> Dashboard</span>.</span>clear_screen</span>()</span></span></code></pre>
By removing the if</code> and changing this to</p>
buf</span> +=</span> Dashboard</span>.</span>clear_screen</span>()</span></span></code></pre>
the locals will stay on top in the NeoVim terminal
(otherwise they will keep scrolling the window).</p>

</div>


Two's complement by Temporus
2021-02-15T00:00:00+00:00
A quick writeup on two's complement by Temporus.</p>
In reality all bytes in memory are unsigned.</p>
The concept of signed values is just an encoding of the bits of those bytes.</p>
It makes use of a property in CPU's that add in general will wrap around the
value (and sets a carry flag)</p>
So</p>
0xFF + 0x01 = 0x00</span></span></code></pre>
What you may notice we can think of it as the other way around</p>
0x01 + 0xFF = 0x00</span></span></code></pre>
Which is the same as</p>
0x01 + -0x01 = 0x00</span></span></code></pre>
Or</p>
0x01 - 0x01 = 0x00</span></span></code></pre>
You keep following it backwards and you realize it acts like going further into negatives:</p>
0x01 + 0xFE = 0XFF</span></span></code></pre>
Which can be the same as</p>
0x01 - 0x02 = -0x01</span></span></code></pre>
You then look at it in bits</p>
00000001 + 11111111 = 00000000</span></span>
0x01     +     0xFF = 0x00</span></span>
0x01     -     0x01 = 0x00</span></span>
</span>
00000001 + 11111110 = 11111111</span></span>
0x01     +     0xFE = 0xFF</span></span>
0x01     -     0x02 = -0x01</span></span></code></pre>
So you notice we can easily split negative numbers based on whether the highest
bit is set</p>
If we treat it in such a manner our byte goes from 0-255 to a -128-127 range.</p>
So how do we turn 1 into -1 easily? Or</p>
00000001 -> 11111111</span></span></code></pre>
we can invert all the bits and add 1</p>
invert(00000001) + 1 = 11111110 + 1 = 11111111</span></span></code></pre>
We can do the same to reverse it</p>
invert(11111111) + 1 = 00000000 + 1 = 00000001</span></span></code></pre>
So this is working in 8 bits, but the same process applies to any bit size
if an unsigned value is 16 bits, with a value range of 0-((2^16) - 1)</code>, or 0-65535</code>
making the highest bit the signed bit our range becomes -(2^(16-1))</code> to
(2^(16-1) - 1)</code>, or -32768</code> to 32767</code>.</p>


Learning resources
2021-01-11T00:00:00+00:00
If you are learning to program from scratch.</p>
🔗</a>Rust</h2>
🔗</a>Reading</h3>

https://doc.rust-lang.org/stable/book/</a></li>
https://learning-rust.github.io/</a></li>
Rust in Easy English</a></li>
Phil Op blog os</a></li>
</ul>
🔗</a>Watching</h3>

300 seconds of Rust</a></li>
Ryan Levick</a></li>
Crust of Rust by Jon Gjengset</a></li>
Doug Milford (3d graphics)</a></li>
Easy Rust</a></li>
Rust Book in video form</a></li>
Introduction to programming with
Rust</a>
(you can find Rhymu over on Twitch</a>)</li>
FE and BE with Rust: Brookzerker</a> (you can find
Brookzerker over on Twitch</a></li>
</ul>
🔗</a>Starter projects</h3>

https://github.com/karan/Projects</a></li>
https://github.com/tuvtran/project-based-learning</a></li>
https://github.com/danistefanovic/build-your-own-x</a></li>
</ul>
🔗</a>Learn by doing</h3>

Rustlings</a></li>
Macros</a></li>
</ul>
🔗</a>Zig</h2>
🔗</a>Reading</h3>

Zig learn</a></li>
Ziglings</a></li>
Zig by example</a></li>
Zig with example</a></li>
</ul>
For experienced developers the standard
library</a> can be a learning
resource.
Information on how to read the standard library source
code</a>.</em></p>
🔗</a>C</h2>

https://www.learn-c.org/</a></li>
https://en.cppreference.com/w/</a></li>
</ul>
🔗</a>C++</h2>

https://www.learncpp.com</a></li>
</ul>
🔗</a>Lua</h2>

https://www.lua.org/pil/contents.html</a></li>
http://tylerneylon.com/a/learn-lua/</a></li>
https://lualearning.com</a></li>
</ul>
🔗</a>Python</h2>

https://docs.python.org/3/tutorial/index.html</a></li>
</ul>
🔗</a>Go</h2>

Go 101</a></li>
A Tour of Go</a></li>
</ul>
🔗</a>Kotlin</h2>

Get started with Kotlin</a></li>
</ul>
🔗</a>Swift</h2>

Swift book</a></li>
</ul>
🔗</a>Scala</h2>

Scala book</a></li>
</ul>


Useful bits
2020-12-19T00:00:00+00:00


    fifo</desc>
    streamlink --twitch-low-latency -p=mpv --player-args="--profile=low-latency {filename}" https://twitch.tv/user best</code>
    Jadlers</span>
</div>



Links
2020-12-18T00:00:00+00:00



Timerfd
2020-12-18T00:00:00+00:00
Creating a timer with libc</code>:</p>
let</span> flags</span> =</span> libc</span>::</span>EFD_CLOEXEC</span> |</span> libc</span>::</span>EFD_NONBLOCK</span>;</span></span>
let</span> clock_id</span> =</span> libc</span>::</span>CLOCK_MONOTONIC</span>; </span></span>
let</span> fd</span> =</span> libc</span>::</span>timerfd_create</span>(clock_id, flags);</span></span>
</span>
// Set the old value to null,</span></span>
// as we are not updating a timer, but rather</span></span>
// creating one.</span></span>
let</span> old_value</span> =</span> std</span>::</span>ptr</span>::</span>null</span>();</span></span>
</span>
// Expiration</span></span>
// Start after ten seconds</span></span>
let</span> expiration</span> =</span> libc</span>::</span>timespec {</span></span>
    tv_sec</span> =</span> 10</span>i64</span>,</span></span>
    tv_nsec</span> =</span> 0</span>i64</span>,</span></span>
};</span></span>
</span>
// Interval</span></span>
// Repeat every second</span></span>
let</span> interval</span> =</span> libc</span>::</span>timespec {</span></span>
    tv_sec</span> =</span> 1</span>i64</span>,</span></span>
    tv_nsec</span> =</span> 0</span>i64</span>,</span></span>
};</span></span>
</span>
let</span> new_value</span> =</span> libc</span>::</span>itmerspec {</span></span>
    it_value</span> =</span> expiration</span> // initial expiration?</span></span>
    it_interval</span> =</span> interval</span></span>
};</span></span>
</span>
</span>
libc</span>::</span>timerfd_settime</span>(fd, new_value, old_value);</span></span></code></pre>
    
    Monotonic clock means that the clock can never go backwards.</p>

</div>


Steam games
2020-12-18T00:00:00+00:00



Eventfd
2020-12-17T00:00:00+00:00
An eventfd</code> contains a 32 bit integer maintained by the kernel.</p>
Creating an eventfd</code>:</p>
let</span> init_val</span> =</span> 0</span>;</span></span>
let</span> flags</span> =</span> libc</span>::</span>EFD_CLOEXEC</span> |</span> libc</span>::</span>EFD_NONBLOCK</span>;</span></span>
libc</span>::</span>eventfd</span>(init_val, flags);</span></span>
</span>
// Register with libc::EPOLLIN | libc::EPOLLET</span></span></code></pre>
Write a value greater than zero to an instance of eventfd</code> to notify user
space.
Reading it will then reset it to zero.</p>
All other reads will get "Resource Temporarily Unavailable", until it's written
again.</p>

`🔗</a>Sources</h2> https://doc.rust-lang.org/cargo/reference/running-a-registry.html</a></li> https://github.com/integer32llc/margo</a></li> </ul>`

`🔗</a>The end</h2> The Rust book on enums</a></li> The Rust reference</a></li> </ul> Thanks to twitch.tv/museun</a> for reading and correcting my mistakes</p>`

🔗</a>Python</h2>

https://docs.python.org/3/tutorial/index.html</a></li> </ul>
🔗</a>Go</h2>

Go 101</a></li>
A Tour of Go</a></li> </ul>
🔗</a>Kotlin</h2>

Get started with Kotlin</a></li> </ul>
🔗</a>Swift</h2>

Swift book</a></li> </ul>
🔗</a>Scala</h2>

Scala book</a></li> </ul>

🔗</a>Go</h2>

Go 101</a></li>
A Tour of Go</a></li> </ul>
🔗</a>Kotlin</h2>

Get started with Kotlin</a></li> </ul>
🔗</a>Swift</h2>

Swift book</a></li> </ul>
🔗</a>Scala</h2>

Scala book</a></li> </ul>

🔗</a>Kotlin</h2>

Get started with Kotlin</a></li> </ul>
🔗</a>Swift</h2>

Swift book</a></li> </ul>
🔗</a>Scala</h2>

Scala book</a></li> </ul>

🔗</a>Swift</h2>

Swift book</a></li> </ul>
🔗</a>Scala</h2>

Scala book</a></li> </ul>

🔗</a>Scala</h2>

Scala book</a></li> </ul>

togglebit.io

Fifteen to one

No-Internet challenge

Focus challenge

Setting up a personal crates repository using Git

Rust enums: a bit about size and optimisations

Rust lifetime rules

Bitwise cheat sheet for Rust

Debugging Rust with vim and neovim (in Linux)

Two's complement by Temporus

Learning resources

Useful bits

Links

Timerfd

Steam games

Eventfd

togglebit.io

Fifteen to one

🔗</a>The rules</h2> You can sit for at most 15 minutes at a time.</li> After 15 minutes you have to stand up and perform a task before you sit down again.</li>

No-Internet challenge

🔗</a>The rules</h2> No internet connection for a dedicated time slot during two consecutive days</li> </ul> 🔗</a>Optional rules</h3> Allow a singular device for information lookup (e.g a phone with mobile data).</li>

🔗</a>Optional rules</h3> Allow a singular device for information lookup (e.g a phone with mobile data).</li>

Focus challenge

🔗</a>The rules</h2> Use of the browser: only documentation sites (no videos)</li> No phone (I set mine to Do Not Disturb, it really helps)</li> Music: yes of course (make a playlist even)</li>

Setting up a personal crates repository using Git

Rust enums: a bit about size and optimisations

🔗</a>The end</h2> The Rust book on enums</a></li> The Rust reference</a></li> </ul> Thanks to twitch.tv/museun</a> for reading and correcting my mistakes</p>

Rust lifetime rules

🔗</a>4.</h2> Otherwise, it is an error to elide an output lifetime.</p> Given the following:</p>

Bitwise cheat sheet for Rust

Debugging Rust with vim and neovim (in Linux)

Two's complement by Temporus

Learning resources

Useful bits

Links

Timerfd

Steam games

Eventfd

`🔗</a>The end</h2> The Rust book on enums</a></li> The Rust reference</a></li> </ul> Thanks to twitch.tv/museun</a> for reading and correcting my mistakes</p>`