<h1>What Is Randomness?</h1>
<img src="/images/numbers_on_a_screen.jpg" alt="Numbers on a screen">
In case you were born yes­ter­day, let’s go over it.
Randomness is, at the most ba­sic level, some­thing that can­not be pre­dicted.
In com­puter sci­ence, when we talk about ran­dom­ness, we are usu­ally talk­ing about ran­dom num­bers and the tools we use to get them, ran­dom num­ber gen­er­a­tors (RNGs).
<h2>Pseudorandomness</h2>
We say an RNG is “pseudorandom” when we have to give it a ﬁxed seed, and it gen­er­ates ran­dom num­bers based on that seed.
If we give it the same seed, we will get the same num­bers.
It is de­ter­min­is­tic.
I thought, for a very long time, that com­put­ers could only cre­ate pseudo­ran­dom num­bers.
The main rea­son I thought this, and why you might too, is be­cause util­i­ties like the Random class in&nbsp;.NET are pseudo­ran­dom and are seeded by some ar­bi­trary in­for­ma­tion, like the cur­rent time.
Computers aren’t use­ful if they aren’t de­ter­min­is­tic.
In a per­fect, en­closed sys­tem, it would be im­pos­si­ble for a com­puter to gen­er­ate truly ran­dom num­bers.
<h2>True Randomness</h2>
The phrase “true ran­dom­ness” is used to de­scribe things that are im­pos­si­ble to pre­dict. Provably so. This is dif­fer­ent from chaotic sys­tems, which are pre­dictable un­der short spans of time.
True ran­dom­ness is im­pos­si­ble to pre­dict on all scales.
<h2>The Everyday Method</h2>
Allow me to in­tro­duce 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 in­struc­tions orig­i­nally in­tro­duced by Intel, that al­low pro­grams ac­cess to truly ran­dom num­bers.
These in­struc­tions gather data from an on-chip en­tropy source to pro­vide ran­dom num­bers.
These in­struc­tions uti­lize ther­mal noise to pro­duce white noise, which is used to gen­er­ate said ran­dom num­bers.
The ad­van­tage of ther­mal noise is that it pro­duces ac­tu­ally ran­dom val­ues, as ex­plained here.
Its also fast, which means it can be used for every­day things, like gen­er­at­ing SSL or TLS keys and the like.
<h3>Do It Yourself</h3>
If you hap­pen to be on a Linux sys­tem, you can ac­tu­ally use these in­struc­tions your­self. Just run this com­mand:
<pre><code class="hljs language-bash">dd if=/dev/random count=4 bs=1 status=none | od -An --format=dI
</code></pre>
This com­mand uses <code>dd</code> to gen­er­ate 4 ran­dom bytes.
Then it pipes those bytes into <code>od</code>&nbsp;, which will for­mat those 4 bytes into hu­man-read­able text as a signed 32-bit in­te­ger.
<h2>The Nuclear Method</h2>
<img src="/images/nuclear_plant.jpg" alt="A Nuclear Plant">
One of the big ad­vance­ments of the 20th Century was the cre­ation of a branch of re­search called quan­tum physics.
One of the things we learned was that on the scale of in­di­vid­ual par­ti­cles, it be­comes prov­ably im­pos­si­ble to pre­dict state.
Every time a mea­sure­ment is taken of a sub­atomic par­ti­cle, its state changes ran­domly.
One way we could sam­ple sub­atomic par­ti­cles is by plac­ing a Geiger counter next to a bit of ra­dioac­tive ore.
Be­cause whether an in­di­vid­ual atom will de­cay at any given mo­ment, we can know that the time be­tween ticks of the Geiger counter is ran­dom.
<h2>The Cloudﬂare Method</h2>
<img src="/images/lava_lamp.jpg" alt="A Lava Lamp">
Cloudﬂare uses some es­pe­cially in­ter­est­ing sources of en­tropy to seed its ran­dom num­ber gen­er­a­tors.
One way is via lava lamps.
In their lobby, they have a large ar­ray of lava lamps.
There is a cam­era run­ning a live feed of the lava lamps to their servers.
There are two main sources of ran­dom­ness.
First, the lava lamps them­selves.
The move­ment of even a sin­gle lava lamp, if we for­get the sec­ond law of ther­mo­dy­nam­ics, is far too chaotic to pre­dict.
If we in­clude the sec­ond law of ther­mo­dy­nam­ics, it be­comes true ran­dom­ness.
Second, the cam­era sen­sor’s noise.
Thanks to the pho­to­elec­tric ef­fect the noise that ap­pears on a cam­er­a’s sen­sor, how­ever un­no­tice­able, is truly ran­dom.
By com­bin­ing these two sources, you get a pool of truly ran­dom num­bers ~60 times a sec­ond.
If that does­n’t ﬁt your needs, you can use those num­bers to feed a cryp­to­graph­i­cally se­cure pseudo­ran­dom num­ber gen­er­a­tor (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 sev­eral in­ter­est­ing ways com­put­ers gen­er­ate ran­dom num­bers. It may fas­ci­nate you to know that some meth­ods are not truly ran­dom, but only an ap­prox­i­mate.

3 Awesome Ways Computers Generate Randomness

<h1>A Harper Record</h1>
When we started work on <a href="https://writewithharper.com/docs/harperjs/introduction"><code>harper.js</code></a>, our goal was sim­ple.
We wanted it to take less than 24 hours for a de­vel­oper to em­bed high-qual­ity gram­mar check­ing in their app.
A friend of mine, <a href="https://lukaswerner.com/">Lukas Werner</a> re­cently set a record for this.
In just over 15 min­utes, he was able to em­bed Harper into Raycast, a com­mand palate for MacOS.
This is fan­tas­tic news.
It’s al­ways great to see when your goals are hav­ing a real im­pact on some­one’s abil­ity.
I hope you take the time to look at <a href="https://github.com/lukasmwerner/harper-raycast">the pro­ject on GitHub</a>.
In other news, we have some other small pro­jects us­ing Harper:
<ul>
<li><a href="https://github.com/lockbook/lockbook">Lockbook</a></li>
<li><a href="https://stubby.io/">Stubby CMS</a></li>
</ul>

🎉

A Harper Record

<h1>How to Write a Discord Bot in Rust</h1>
Discord is an in­stant mes­sage plat­form with more than 150 mil­lion monthly ac­tive users. The main ap­peal seems to a com­bi­na­tion of the wide reach that plat­forms like StackOverﬂow have, as well as the in­stant de­liv­ery of the in­stant mes­sag­ing con­cept. One of the best fea­tures of Discord is it’s seem­ingly un­lim­ited hack­a­bil­ity of the plat­form via it’s “Bot” sys­tem. The Bot sys­tem al­lows de­vel­op­ers to add func­tion­al­ity to Discord com­mu­ni­ties by writ­ing soft­ware that in­ter­faces in a sim­i­lar way that peo­ple do. I want to give you an in­tro­duc­tion 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 in­ter­ac­tion with Discord bots hap­pens via com­mands, not dis­sim­i­lar to ter­mi­nal ap­pli­ca­tions. 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 go­ing to make now will sim­ply re­spond 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 func­tion­ing Rust en­vi­ron­ment, use cargo to cre­ate a new pro­ject. 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 li­brary for cre­at­ing Discord bots in Rust. We also have to drop in Tokio, be­cause Serenity takes ad­van­tage of it’s async run­time.
You can do this ei­ther 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 ﬂex­i­bil­ity. You have ac­cess to a event han­dler that al­lows ﬁne grain con­trol of events. You also have ac­cess to a stan­dard frame­work that makes it ridicu­lously easy to re­spond to com­mands.
Be­fore we do any­thing else, we have to make our main func­tion async. It is su­per easy to do that, just re­place it with:
<pre><code class="hljs language-rust">#[tokio::main]
async fn main() {
}
</code></pre>
First, we want to get our bot to­ken in. In an ac­tual bot, please ob­tain it via an en­vi­ron­ment vari­able or some other method. We are only do­ing it this way for sim­plic­ity.
<pre><code class="hljs language-rust">let token = "{your bot token}";
</code></pre>
If you do not know how to get a bot to­ken, please fol­low <a href="https://www.getdroidtips.com/discord-bot-token/">this tu­to­r­ial</a>.
The Serenity Standard Framework splits your bot’s com­mands into groups. Each group can have mul­ti­ple com­mands. For ex­am­ple, a bot might have two groups: one fo­cused on fun and one fo­cused on math. The for­mer has com­mands like !meme, while the lat­ter may have var­i­ous math func­tions, like sin!. This is also how we will add com­mands to our bot.
First, add the needed structs and macros to the ﬁle:
<pre><code class="hljs language-rust">use serenity::{Client, client::Context, framework::{StandardFramework, standard::{CommandResult, macros::{group, command}}}, model::channel::Message};
</code></pre>
Next, cre­ate a struct that we will at­tach our com­mands to:
<pre><code class="hljs language-rust">#[group]
#[commands()]
struct HelloWorld;
</code></pre>
Once we have added our com­mands, we will en­ter them into the com­mands sub-macro.
Create an in­stance of <code>StandardFramework</code> and add our group to it. We can also con­ﬁg­ure our com­mand pre­ﬁx 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 ref­er­ence to a sta­tic struct called HELLOWORLD_GROUP in­stead of just adding our group. This is the out­put of the #[group] macro.
Now that we have cre­ated our frame­work, we have to at­tach 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 frame­work set up, let’s add a com­mand.
<pre><code class="hljs language-rust">#[command]
async fn ping(ctx: &#x26;Context, msg: &#x26;Message) -> CommandResult{
}
</code></pre>
This com­mand only needs the Discord clien­t’s Context, the mes­sage that con­tains the com­mand, and re­turns a <code>CommandResult</code>.
 Do not for­get to add the com­mand to the group:
<pre><code class="hljs language-rust">#[group]
#[commands(ping)]
struct HelloWorld;
</code></pre>
If you don’t, it will sim­ply not get run.
We want the bot to re­ply to the !ping com­mand with “Pong!”, so let’s add that to the in­side of the ping func­tion:
<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 func­tion­ing Discord bot!
Seren­ity is an amaz­ing crate and is an ab­solute joy to work with. I hope you learned some­thing. 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 ex­am­ples 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 us­ing the Rust Serenity Framework.

How to Write a Discord Bot in Rust

chatgpt_for_the_moms

<h1>ChatGPT for the Moms</h1>
<img src="/images/guggenheim.webp" alt="Spring has sprung, and Guggenheim shows it.">
My mom is a vi­o­lently in­tel­li­gent woman.
But she lives in the un­for­tu­nate re­al­ity of not be­ing a soft­ware en­gi­neer or math­e­mati­cian.
While she is just as ex­cited about ChatGPT (and all the other nascent AI tech­nol­ogy) as the rest of us, she is­n’t aware of the un­in­tel­li­gent pit­falls ar­ti­ﬁ­cial in­tel­li­gence has these days.
If you’re mom is ex­per­i­ment­ing with ChatGPT, I’d highly rec­om­mend send­ing this list to her.
Pow­er­ful tech­nol­ogy is in their hands, but I’ve got three things they should know be­fore re­ly­ing on it.
<h2>Advice for Moms</h2>
<h3>Use Web Search</h3>
When you open up ChatGPT on a phone or on a com­puter, you’ll be met with the fa­mil­iar chat win­dow.
If you ask it ques­tions it will give you an an­swer.
Some­times that an­swer will be good, some­times not.
You can gen­er­ally get bet­ter in­for­ma­tion if you en­able the web search tool.
<img src="/images/chatgpt_web_search_tool.png" alt="A screenshot of the ChatGPT web search tool.">
This will al­low ChatGPT to do Google searches on your be­half.
It im­proves the qual­ity of in­for­ma­tion it gives you, while only adding a sec­ond or two to their re­sponse.
<h3>It Is Not Your Friend</h3>
When we see a chat win­dow, our ﬁrst thought is that there’s a per­son on the other end.
Some­one with emo­tions and lives all their own.
That is not the case here.
ChatGPT, while an ad­vanced ma­chine learn­ing model, is not a per­son.
It does not re­place real hu­man con­nec­tion.
It can’t watch your kids when you’ve got an emer­gency.
It won’t show up to the school recital.
It does­n’t care about you—de­spite what it says.
There’s a lot that goes into a gen­uine so­cial con­nec­tion, all of which are miss­ing from ChatGPT.
<h3>Use Your Brain</h3>
ChatGPT is no sub­sti­tute for crit­i­cal thought.
It can­not do most things, even if it claims it can.
You are a ca­pa­ble hu­man be­ing—able to ac­com­plish any­thing you put your mind to.
While ChatGPT can be a help­ful as­sis­tant or brain­storm­ing part­ner, don’t let it steer the ship.
<h2>What to Remember</h2>
While ChatGPT can be a pow­er­ful tool in the right hands, it is im­por­tant to re­mem­ber it is just that: a tool.
It can be en­hanced with the right set­tings, it is not real hu­man con­nec­tion, and it can’t re­place your brain.
Use it well and use it wisely.

Advice you can give your mom (or other nontechnical person) for how to use ChatGPT wisely and effectively.

Advice you can give your mom (or other non­tech­ni­cal per­son) for how to use ChatGPT wisely and ef­fec­tively.

Elijah Potter

ChatGPT for the Moms

Advice for Moms

Use Web Search

It Is Not Your Friend

Use Your Brain

What to Remember

Other Stuff

3 Awesome Ways Computers Generate Randomness

A Harper Record

How to Write a Discord Bot in Rust