<h1>Always Think of the Hook First</h1>
<img src="/images/log.webp" alt="A log I found in the Indian Peaks Wilderness">
In his pop­u­lar book, Outliers, Malcolm Gladwell made the case that there was one num­ber that pre­dicted your skill level in a ﬁeld: the num­ber of hours of ded­i­cated prac­tice.
In pop­u­lar cul­ture, this idea has been sim­pli­ﬁed.
Some think that if you just do some­thing for 10,000 hours, then you’ll be­come a world-class ex­pert.
This is false.
What does the word “dedicated” mean in the phrase “dedicated” prac­tice?
It means ap­ply­ing fo­cused, de­lib­er­ate thought to it.
It means re­ﬂect­ing on your own per­for­mance.
It means seek­ing help from mas­ters in the ﬁeld.
Above all, it means achiev­ing mas­tery is not easy.
I aim to mas­ter the skill of writ­ing.
In my free time this week, I’ve been work­ing on my de­lib­er­ate prac­tice of writ­ing.
In do­ing so, I’ve come to some con­clu­sions.
If you’d like to join me in pur­su­ing mas­tery of the writ­ten word, here’s what I think you should do.
<h2>Proof it Yourself</h2>
Two-time Pulitzer prize-win­ner David McCullough says “Writing is think­ing. To write well is to think clearly. That’s why it’s so hard.”
Because the act of writ­ing is also the act of think­ing, the process of re­vis­ing text clar­i­ﬁes thought.
I per­son­ally ﬁnd that my ar­gu­ment when I ﬁrst touch my key­board usu­ally stands in stark con­trast to when I hit “publish.”
Heavy-handed re­vi­sion tools like ChatGPT ac­tively dis­rupt this great ben­e­ﬁt of the re­vi­sion process.
Sure, they can rewrite tone to be more at­trac­tive on­line, but they also rob you of the op­por­tu­nity to de­velop your con­cept.
That’s why I turn every­thing else off and only use Harper: be­cause it gets out of the way of what I am try­ing to say.
You can’t re­ﬂect on what you’ve writ­ten if you are not the one re­ﬂect­ing.
<h2>Read The Work of Great Writers</h2>
When I sit down to write af­ter spend­ing time on­line, I feel de­ﬂated.
The com­pe­ti­tion of so­cial me­dia and the churn of the news cy­cle both lead to poor prose.
When I sit to write af­ter read­ing Bonnie Garmus or Cal Newport, I feel in­vig­o­rated.
I can imag­ine a shape for the words on the page which pre­cisely cap­tures the ideas I’m try­ing to com­mu­ni­cate.
Read­ing great lit­er­a­ture gives you an in­tu­ition for what your own work should look like.
<h2>Think of the Hook First</h2>
In rap­per cir­cles, it’s a com­mon point of de­bate whether to think of the verse ﬁrst or the hook.
One one hand, the verse is the sub­stance of the song.
It con­tains the mes­sage, the de­tail, and the per­sonal mean­ing.
Mu­sic de­rives much of its com­plex­ity from the verse.
On the other hand, the hook is what gets peo­ple to lis­ten.
It is what makes them stop ﬂick­ing through Spotify and fall into the beat.
If you’re writ­ing for an au­di­ence, you have a lot of com­pe­ti­tion for their at­ten­tion.
Spend more time on the in­tro­duc­tion than any­thing else.
It should cap­ture your read­ers, de­light their imag­i­na­tions, and put them in your shoes.
<h2>Don’t Get Attached</h2>
I spent a long time on a post sim­i­lar to this one.
I was quite proud of it, for I had spent hours adding lay­ers of de­tail and quite a few case stud­ies from my own work.
Alas, Gutenberg de­cided it was not meant to be and chucked it into obliv­ion.
Although I was ini­tially crest­fallen from the loss, I now be­lieve the sec­ond round ended up even bet­ter.
To truly re­vise your work, you’ll in­evitably have to delete parts of it.
Get com­fort­able with that.

Spend more time on the introduction than anything else.

Spend more time on the in­tro­duc­tion than any­thing else.

Always Think of the Hook First

<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

An experiment on how to live in a seemingly hopeless world.

An ex­per­i­ment on how to live in a seem­ingly hope­less world.

Quantifying Hope on a Global Scale

prompting_large_language_models_in_bash_scripts

<h1>Prompting Large Language Models In Bash Scripts</h1>
I’ve been ex­per­i­ment­ing with us­ing LLMs lo­cally for gen­er­at­ing datasets to test <a href="https://writewithharper.com">Harper</a> against.
I might write a blog post about the tech­nique (which I am grandiosely call­ing “LLM-assisted fuzzing”), but I’m go­ing to make you wait.
I’ve writ­ten a lit­tle tool called <a href="https://github.com/elijah-potter/ofc"><code>ofc</code> that lets you in­sert Ollama into your bash scripts</a>.
I think it’s pretty neat, since it (very eas­ily) lets you do some pretty cool things.
For ex­am­ple, you can swap out the sys­tem prompt, so if you want to com­pare be­hav­ior across prompts, you can just toss it in a loop:
<pre><code class="hljs language-bash">#!/bin/bash

subreddits=("r/vscode" "r/neovim" "r/wallstreetbets")

# Loop over each item in the list
for subreddit in "${subreddits[@]}"; do
 echo "++++++++ BEGIN $subreddit ++++++++"
 ofc --system-prompt "Assume the persona of a commenter of $subreddit" "What is your opinion on pepperjack cheese?"
 cat
done
</code></pre>
Or, you can in­struct a model to prompt it­self:
<pre><code class="hljs language-bash">ofc --system-prompt "$(ofc "Write a prompt for a large language model that makes it think harder. ")" "What is a while loop?"
</code></pre>
<h1>Installation</h1>
<code>ofc</code> is in­stal­lable from ei­ther crates.io or its repos­i­tory.
<pre><code class="hljs language-bash">cargo install ofc --locked

# Or...
cargo install --git https://github.com/elijah-potter/ofc --locked
</code></pre>

Elijah Potter

Prompting Large Language Models In Bash Scripts

Installation

Other Stuff

Always Think of the Hook First

3 Awesome Ways Computers Generate Randomness

Quantifying Hope on a Global Scale