<h1>What Is Randomness?</h1>
<img src="/images/numbers_on_a_screen.jpg" alt="Numbers on a screen">
In case you were born yesterday, let's go over it.
Randomness is, at the most basic level, something that cannot be predicted.
In computer science, when we talk about randomness, we are usually talking about random numbers and the tools we use to get them, random number generators (RNGs).
<h2>Pseudorandomness</h2>
We say an RNG is “pseudorandom” when we have to give it a fixed seed, and it generates random numbers based on that seed.
If we give it the same seed, we will get the same numbers.
It is deterministic.
I thought, for a very long time, that computers could only create pseudorandom numbers.
The main reason I thought this, and why you might too, is because utilities like the Random class in .NET are pseudorandom and are seeded by some arbitrary information, like the current time.
Computers aren't useful if they aren't deterministic.
In a perfect, enclosed system, it would be impossible for a computer to generate truly random numbers.
<h2>True Randomness</h2>
The phrase “true randomness” is used to describe things that are impossible to predict. Provably so. This is different from chaotic systems, which are predictable under short spans of time.
True randomness is impossible to predict on all scales.
<h2>The Everyday Method</h2>
Allow me to introduce you to <a href="https://en.wikipedia.org/wiki/RDRAND">RDRAND</a> and <a href="https://en.wikipedia.org/wiki/RDRAND#RDSEED">RDSEED</a>, two CPU instructions originally introduced by Intel, that allow programs access to truly random numbers.
These instructions gather data from an on-chip entropy source to provide random numbers.
These instructions utilize thermal noise to produce white noise, which is used to generate said random numbers.
The advantage of thermal noise is that it produces actually random values, as explained here.
Its also fast, which means it can be used for everyday things, like generating SSL or TLS keys and the like.
<h3>Do It Yourself</h3>
If you happen to be on a Linux system, you can actually use these instructions yourself. Just run this command:
<pre><code class="hljs language-bash">dd if=/dev/random count=4 bs=1 status=none | od -An --format=dI
</code></pre>
This command uses <code>dd</code> to generate 4 random bytes.
Then it pipes those bytes into <code>od</code> , which will format those 4 bytes into human-readable text as a signed 32-bit integer.
<h2>The Nuclear Method</h2>
<img src="/images/nuclear_plant.jpg" alt="A Nuclear Plant">
One of the big advancements of the 20th Century was the creation of a branch of research called quantum physics.
One of the things we learned was that on the scale of individual particles, it becomes provably impossible to predict state.
Every time a measurement is taken of a subatomic particle, its state changes randomly.
One way we could sample subatomic particles is by placing a Geiger counter next to a bit of radioactive ore.
Because whether an individual atom will decay at any given moment, we can know that the time between ticks of the Geiger counter is random.
<h2>The Cloudflare Method</h2>
<img src="/images/lava_lamp.jpg" alt="A Lava Lamp">
Cloudflare uses some especially interesting sources of entropy to seed its random number generators.
One way is via lava lamps.
In their lobby, they have a large array of lava lamps.
There is a camera running a live feed of the lava lamps to their servers.
There are two main sources of randomness.
First, the lava lamps themselves.
The movement of even a single lava lamp, if we forget the second law of thermodynamics, is far too chaotic to predict.
If we include the second law of thermodynamics, it becomes true randomness.
Second, the camera sensor's noise.
Thanks to the photoelectric effect the noise that appears on a camera's sensor, however unnoticeable, is truly random.
By combining these two sources, you get a pool of truly random numbers ~60 times a second.
If that doesn't fit your needs, you can use those numbers to feed a cryptographically secure pseudorandom number generator (CSPRNG) to get as many as you want.

We look at several interesting ways computers generate random numbers. It may fascinate you to know that some methods are not *truly* random, but only an approximate.

We look at several interesting ways computers generate random numbers. It may fascinate you to know that some methods are not truly random, but only an approximate.

3 Awesome Ways Computers Generate Randomness

<h1>How to Write a Discord Bot in Rust</h1>
Discord is an instant message platform with more than 150 million monthly active users. The main appeal seems to a combination of the wide reach that platforms like StackOverflow have, as well as the instant delivery of the instant messaging concept. One of the best features of Discord is it’s seemingly unlimited hackability of the platform via it’s “Bot” system. The Bot system allows developers to add functionality to Discord communities by writing software that interfaces in a similar way that people do. I want to give you an introduction on how to do that in Rust.
<img src="/images/flat_ferris.png" alt="A Flat Render of Rust&#x27;s Mascot, Ferris">
<h2>Interaction</h2>
Most interaction with Discord bots happens via commands, not dissimilar to terminal applications. Commands may look like <code>!play Eat it by Weird Al</code>.
<img src="/images/ping_pong.png" alt="Ping! Pong!">
The bot we are going to make now will simply respond to <code>!ping</code> with "Pong!".
<h2>Template</h2>
<img src="https://github.com/elijah-potter/discord-bot-template" alt="cargo generator template">
<h2>Setup the Project</h2>
Using a functioning Rust environment, use cargo to create a new project. E.g:
<pre><code class="hljs language-bash">cargo new tutorial-bot
</code></pre>
Next, we have to add <a href="https://github.com/serenity-rs/serenity">Serenity</a>, the library for creating Discord bots in Rust. We also have to drop in Tokio, because Serenity takes advantage of it's async runtime.
You can do this either via cargo-edit:
<pre><code class="hljs language-bash">cargo add serenity
cargo add tokio --features full
</code></pre>
or by just adding them to Cargo.toml:
<pre><code class="hljs language-toml">[dependencies]
serenity = "0.10.5"
tokio = { version = "1.5.0", features = ["full"] }
</code></pre>
<h2>Setting up the Standard Framework</h2>
Serenity has a lot of flexibility. You have access to a event handler that allows fine grain control of events. You also have access to a standard framework that makes it ridiculously easy to respond to commands.
Before we do anything else, we have to make our main function async. It is super easy to do that, just replace it with:
<pre><code class="hljs language-rust">#[tokio::main]
async fn main() {
}
</code></pre>
First, we want to get our bot token in. In an actual bot, please obtain it via an environment variable or some other method. We are only doing it this way for simplicity.
<pre><code class="hljs language-rust">let token = "{your bot token}";
</code></pre>
If you do not know how to get a bot token, please follow <a href="https://www.getdroidtips.com/discord-bot-token/">this tutorial</a>.
The Serenity Standard Framework splits your bot's commands into groups. Each group can have multiple commands. For example, a bot might have two groups: one focused on fun and one focused on math. The former has commands like !meme, while the latter may have various math functions, like sin!. This is also how we will add commands to our bot.
First, add the needed structs and macros to the file:
<pre><code class="hljs language-rust">use serenity::{Client, client::Context, framework::{StandardFramework, standard::{CommandResult, macros::{group, command}}}, model::channel::Message};
</code></pre>
Next, create a struct that we will attach our commands to:
<pre><code class="hljs language-rust">#[group]
#[commands()]
struct HelloWorld;
</code></pre>
Once we have added our commands, we will enter them into the commands sub-macro.
Create an instance of <code>StandardFramework</code> and add our group to it. We can also configure our command prefix now.
<pre><code class="hljs language-rust">let framework = StandardFramework::new()
 .configure(|c|{
 c.prefix("!")
 })
 .group(&#x26;HELLOWORLD_GROUP);
</code></pre>
Notice that we used a reference to a static struct called HELLOWORLD_GROUP instead of just adding our group. This is the output of the #[group] macro.
Now that we have created our framework, we have to attach it to a Discord client.
<pre><code class="hljs language-rust">let mut client = Client::builder(token).framework(framework).await.expect("Could not start Discord");
</code></pre>
Start it.
<pre><code class="hljs language-rust">client.start().await.expect("The bot stopped");
</code></pre>
<h2>Adding the Command</h2>
Now that we have the framework set up, let's add a command.
<pre><code class="hljs language-rust">#[command]
async fn ping(ctx: &#x26;Context, msg: &#x26;Message) -> CommandResult{
}
</code></pre>
This command only needs the Discord client's Context, the message that contains the command, and returns a <code>CommandResult</code>.
 Do not forget to add the command to the group:
<pre><code class="hljs language-rust">#[group]
#[commands(ping)]
struct HelloWorld;
</code></pre>
If you don't, it will simply not get run.
We want the bot to reply to the !ping command with "Pong!", so let's add that to the inside of the ping function:
<pre><code class="hljs language-rust">msg.reply(ctx, "Pong!").await?;
Ok(())
</code></pre>
<h2>Full Code</h2>
Here is the full code for the bot:
<pre><code class="hljs language-rust">use serenity::{Client, client::Context, framework::{StandardFramework, standard::{CommandResult, macros::{group, command}}}, model::channel::Message};
#[tokio::main]
async fn main() {
 let token = "Your bot token";
 let framework = StandardFramework::new()
 .configure(|c|{
 c.prefix("!")
 })
 .group(&#x26;HELLOWORLD_GROUP);
 let mut client = Client::builder(token).framework(framework).await.expect("Could not start Discord");
 client.start().await.expect("The bot stopped");
}
#[group]
#[commands(ping)]
struct HelloWorld;
#[command]
async fn ping(ctx: &#x26;Context, msg: &#x26;Message) -> CommandResult{
 msg.reply(ctx, "Pong!").await?;
 Ok(())
}
</code></pre>
<h2>That's it</h2>
If you build and run your app, you should have a functioning Discord bot!
Serenity is an amazing crate and is an absolute joy to work with. I hope you learned something. There is a ton more stuff that I did not cover here. Feel free to look at the <a href="https://docs.rs/serenity/latest/serenity/">Serenity docs</a> and examples to learn more!

We go through step-by-step how to build a Discord bot using the Rust Serenity Framework.

We go through step-by-step how to build a Discord bot using the Rust Serenity Framework.

How to Write a Discord Bot in Rust

<h1>The Simplest Neovim Markdown Setup</h1>
I am not one who enjoys complexity.
I am also someone who likes to make their <a href="https://github.com/elijah-potter/harper">own tools</a>.
As a student, I write a lot.
That includes notes, papers, and documentation for my wide variety of projects.
A lot of classes request to submit assignments as either PDF, HTML or <code>.docx</code>.
For a while, I submitted PDF's.
I had a whole orchestrated setup.
I would write everything in <a href="https://neovim.io/">Neovim</a>, save it, and <a href="https://github.com/frabjous/knap">KNAP</a> would render it using <a href="https://pandoc.org/">Pandoc</a>.
Finally, it would be rendered to my screen using <a href="https://sioyek.info/">Sioyek</a>.
This worked fine, I guess, but it was far from perfect.
<ol>
<li>It was slow. Each edit I made in Markdown could take as many as 10 seconds to show up in Sioyek.</li>
<li>It wasn't interesting. While I made modifications to my Pandoc settings, my PDF's still looked like every other <code>pdflatex</code> document ever made.</li>
<li>I couldn't make my documents interactive if I wanted to.</li>
</ol>
Markdown was designed to be turned into HTML, I reasoned.
So why not just do that?
<img src="/images/tatum_screenshot.webp" alt="A screenshot of Tatum at work">
That's why I created <a href="https://github.com/elijah-potter/tatum">Tatum</a>.
It does one thing, really well.
Point it at a Markdown file, and it will run a tiny web server to render the resulting HTML to.
If the file changes, a WebSocket connection tells the browser to refresh.
Tatum renders in milliseconds and creates beautiful pages with <a href="https://katex.org/"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mtext>KaTeX</mtext></mrow><annotation encoding="application/x-tex">\KaTeX</annotation></semantics></math>KATE​X</a>, <a href="https://simplecss.org/">Simple.css</a> and <a href="https://highlightjs.org/"><code>highlight.js</code></a>.
I can embed interactive HTML, CSS and JavaScript elements directly into my Markdown to get the interactivity and aesthetics I desire.
Once I'm done working, I just run <code>tatum render &#x3C;file.md></code> and I get a single file (images and all) that I can submit for my assignments.
Tatum isn't for you to use.
Feel free to poke around at how it works, or even fork it and make your own modifications.
It fits my use case perfectly.

How I preview my Markdown quickly and reliably.

How I preview my Markdown quickly and reliably.

The Simplest Neovim Markdown Setup

local-first_software_is_easier_to_scale

<h1>Local-First Software is Easier to Scale</h1>
<img src="/images/flatirons.webp" alt="The Flatirons">
The title of this post is somewhat misleading. Local-first software rarely needs to be scaled at all.
<a href="https://writewithharper.com">Harper</a> recently received a massive increase in both traffic and user count.
How?
By making it to the front page of Hacker News.
If you couldn't tell by the extent to which I talk about this, I'm thrilled.
This amounted to a tremendous amount of free advertising, if nothing else.
I've been thinking a lot about the wondrous benefits of working at the edge.
That's just one term of many that people use to describe Harper: "edge-first".
Others include "local-first" or simply "on-device".
They are all just jargon for a simple idea: We run all the relevant grammar checking code as physically close to the users as possible.
That way, we can serve up suggestions faster than anyone else.
To achieve our goal, we make sure that everything is well-optimized and lean.
Harper barely uses any CPU or memory at all.
What does all this mean in the context of the recent uptick in user acquisition? Imagine, for a moment, we are LanguageTool.
Our software is written in Java, with questionable attendance to the efficiency of our code.
Since our software requires a big server to run, we have a certain number of servers on standby to handle a certain amount of expected load.
If suddenly the number of requests we received were to double (as it did for the Chrome extension), we would be big trouble.
To avoid increasing the latency on requests (or dropping requests all together), we would need to scale up the number of running servers.
This not only takes hiring an expert in cloud architecture, but also additional funding to pay the AWS (or whatever) bill at the end of the month.
Because Harper runs at the edge (no server required), we don't have to worry about that.
In fact, I only noticed that our user count had spiked after I visited Hacker News the morning after.
No hiccups at all.
Lots of cloud providers like to brag about being able to scale with their users. I like to brag about not having to scale at all.

The title of this post is somewhat misleading. Local-first software rarely needs to be scaled at all.

The title of this post is somewhat misleading. Local-first software rarely needs to be scaled at all.

Elijah Potter

Local-First Software is Easier to Scale

Other Stuff

3 Awesome Ways Computers Generate Randomness

How to Write a Discord Bot in Rust

The Simplest Neovim Markdown Setup