computation
August 21 2023
Instabrams are back baby! Thanks to Alfred, Obsidian, Ghost, and GPT that is!
I found out today that, oddly enough, my dislike for food—and smells, as an offshoot—liberates my ears. I can fill them with all kinds of sounds, just like I fill my mind with all sorts of books. And who knows, this might make my understanding richer, deeper. After all, tastes and sounds, they both bring in similar complexities, don't they? What's the science behind this, I wonder?
Planning with time blocks using the Time Block Planner is something else, I tell you. Just staring at how my hours roll out in reality, versus where I believe in my mind that they're going.
It really makes me treasure those fresh hours each morning when I draft the plan. But, damn it, they do race by like comets while I'm knee-deep in living them. Sure makes one thing clear though - there's still quite a road ahead of me to align my time better with the stuff that sits front-row in my priorities.
Today, I cranked out a couple scripts that just might fan the flame back into my inconsistent habit of creating Instabrams. Knocked up one heck of a pipeline for DALL-E, taking chunky texts, wringing them dry into neat, crisp summaries, and morphing them into fetching cover art.
Then there's the second script. What does it do? Well, simple: it chews up shorthand blurb, like the one you're picking through now, and spits it back out in the flavor of a certain author close to my heart, our man Murakami himself. Now, you can sneak a peek at both these scripts down below and take in the art piece a notch above.
Both scripts neatly tuck away the outputs onto my clipboard. Handy for the lazybones that like me, can use ‘em just about anywhere across the machine. Embrace sloth!
i wrote two scripts today that should hopefully harken the return of instabrams. i created a dall-e pipeline that takes text, summarizes it and turns into a cover art.
in addition i wrote a script that rewrites shorthand like you are reading now into the style of one of my favorite authors, haurki muarkami. you can see both of the scripts below, and the art for this peice in the image above.
importantly, both copy results to clipboard for usage anywhere across my machine. let's go laziness!
Really would be nowhere without these amazing tools that devs have built (Ghost, Obsidian, GPT). I merely build the ligaments that connect the very solid bones.
GitHub rang the bell for the 700th star on chat gpt md today. It's been awhile since any updates were added, and I can't help but feel a twinge of regret. But the open source world - well, it can be a free ride for some folks, especially amongst the Obsidian folks. It's like being a chef with everyone sampling your soup, but no one foots the bill.
there was an enormous disconnect between how we think open source works and what is actually happening on the ground today. There is a long, and growing, tail of projects that don’t fit the typical model of collaboration. Such projects include Bootstrap, a popular design framework used by an estimated 20% of all websites, where three developers have authored over 73% of commits. Another example is Godot, a software framework for making games, where two developers respond to more than 120 issues opened on their project per week.† -- Working in Public: The Making and Maintenance of Open Source Software
Create a Ghost Cover Image with DallE
import dotenv from "dotenv";
dotenv.config();
import OpenAI from "openai";
import clipboard from "clipboardy";
import fs from "fs";
import fetch from "node-fetch";
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
async function summarizeClipboard() {
const text = clipboard.readSync();
// console.log(`Summarizing: ${text}`);
const completion = await openai.chat.completions.create({
messages: [
{
role: "system",
content:
"Summarize the following into a theme and create an art prompt from the feel of the text aesthetically along the lines of: 'an abstract of [some unique lesser known art style from history] version of {x}' where x is the feel of the text aesthetically. Just return the art prompt, say nothing else." +
text,
},
],
model: "gpt-4",
});
// console.log(`Summary: ${completion.choices[0].message.content}`);
return completion.choices[0].message.content;
}
async function saveImgFromUrl(url) {
const response = await fetch(url);
const buffer = await response.buffer();
const filename = `./dalle-images/${Date.now()}.jpg`;
fs.writeFile(filename, buffer, () => console.log("finished downloading!"));
return filename;
}
async function appendToLog(logItem) {
const log = JSON.parse(fs.readFileSync("./log.json"));
log.push(logItem);
fs.writeFileSync("./log.json", JSON.stringify(log, null, 2));
}
async function main() {
let prompt = await summarizeClipboard();
prompt = prompt.replace("Art Prompt: ", "").trim();
const image = await openai.images.generate({ prompt: prompt });
const imageUrl = image.data[0].url;
const imgFilename = await saveImgFromUrl(imageUrl);
const log = {
query: clipboard.readSync(),
prompt: prompt,
imageUrl: imageUrl,
imgFilename: imgFilename,
};
await appendToLog(log);
// save prompt to clipboard
clipboard.writeSync(prompt);
console.log("./dalle-images/" + imgFilename.replace("./dalle-images/", ""));
}
main();
Rewrite Chicken Scratch as Murakami
import dotenv from "dotenv";
dotenv.config();
import OpenAI from "openai";
import clipboard from "clipboardy";
import fs from "fs";
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
async function rewriteClipboard() {
const text = clipboard.readSync();
// console.log(`Rewriting: ${text}`);
const completion = await openai.chat.completions.create({
messages: [
{
role: "system",
content:
"Rewrite the following in the style of Haruki Murakami, using short, punchy, easy to read, simple words that flow. Almost as if spoken cadence. Text:\n" +
text,
},
],
model: "gpt-4",
});
// console.log(`Rewrite: ${completion.choices[0].message.content}`);
return completion.choices[0].message.content;
}
async function appendToLog(logItem) {
const log = JSON.parse(fs.readFileSync("./log.json"));
log.push(logItem);
fs.writeFileSync("./log.json", JSON.stringify(log, null, 2));
}
async function main() {
let prompt = await rewriteClipboard();
prompt = prompt.replace("Rewrite: ", "").trim();
const log = {
query: clipboard.readSync(),
prompt: prompt,
};
await appendToLog(log);
// save prompt to clipboard
clipboard.writeSync(prompt);
console.log("Prompt saved to clipboard");
}
main();
Images From the Script
These have wriggled under my skin, becoming my favorites of the day. You can make buckets of them without breaking much of a sweat. Keep your eyes on the blog – there's more visual feast on the way!
Half a decade past, this is where I lived.
I snapped this photo, and soon after found myself in a nearby bar, nursing a drink and ruminating on the past five years. I had some predictions right - walking away from full-time software engineering to chase dreams of startups and artistry. But there were surprises too - who could've predicted a pandemic, or AI taking great leaps ahead?
I pondered over the goals I set for myself in 2018 - many still unmet, many still echoing around my head. Is that a good thing or a bad thing? Not sure. But one thing I've learnt is this: success is a recipe. It calls for dogged effort, an accreting outlet for said effort (think: investment returns), a dash of lady luck, and being at the right place just when it's the right time. Voila, dreams come true and they'll call it fate.
Like Ging said to Gon, "I can't get there quite yet, but I'm relishing the ride."
"Five years ahead?" I reckon I'll be there, right at the threshold of that old, worn out door of mine.
Oddly enough, it seems as if my eyes on the photo on the right been brushed with a dash of guyliner. Can't make heads or tails of that, honestly.
bramadams.dev is a reader-supported published Zettelkasten. Both free and paid subscriptions are available. If you want to support my work, the best way is by taking out a paid subscription.
Some Hard Af Phone Backgrounds Ive Been Using
gotta love duotone!
ft hxh, blue lock, naruto, demon slayer, kh
note: you can customize your ios homepage to use multiple photos in a slideshow! mine change on lock
this one goes hardest (202301051926)
bramadams.dev is a reader-supported published Zettelkasten. Both free and paid subscriptions are available. If you want to support my work, the best way is by taking out a paid subscription.
Bridging the Distance in Problem Space
How CPUs actually move through the problem and solution space
The capacity to read, write, decode, and execute one clock cycle at a time allows a CPU to effectively bridge the gap between state transitions in the problem space (202306222324). The CPU's ability to jump enables it to move to different states conditionally, without having to pass through each one individually. This results in a tree-like leap from one section of the potential solution space to another (this is all within the set of repeatable problems, R). By looping, CPUs are able to pass data back and forth between two states until we accumulate enough information for a transition.
Reading, Decoding, Writing, Executing
Challenges in the set of reading, decoding, writing, and executing include: substituting old data with new, comprehending a massive amount of data, responding upon encountering a specific type of data, and modifying data to your heart's content.
Coffee Shop Example
Consider a situation at a coffee shop. You read the menu and decode the prices in your head. You mentally calculate the balance in your bank account (or, if it's on credit, you skip this step), and then you execute your decision by selecting the coffee you want and asking the barista to place your order. The barista decodes your order, enters it into the point of sale machine, and begins preparing the order once the credit card company reads the request, checks your account balance, compares the two numbers (decode + execute), and finally returns a positive or negative response. All these steps occur almost instantly and are partially carried out in the human brain and databases at the store and at the bank.
Jumping And Looping
Challenges in the set of jumping and looping include: making significant decisions that drastically alter the resultant execution based on decoded input, and repeating the same action multiple times to achieve an accumulation result.
Consider the example of exercising to get in shape. You go to the gym. You don't want to overwork your muscle groups, so you perform enough repetitions on one machine to gain strength, and then you jump to the cardio section to exercise there while resting your recently worked muscle group.
Breathing provides an even simpler example of looping. If you stop breathing, that's a critical problem. Recall that a problem represents a desire and a state. Not breathing is an undesirable state to be in. If you're still alive, your body will do everything in its power to restart the breathing loop and restore homeostasis, up to and including: gasping, wheezing, seizing the lungs, etc.
These universal tools are not only shared among specific use cases; they are universal because they can be applied to any conceivable problem <> solution situation.
Our brains and bodies also engage in reading raw input, decoding it, then conditionally jumping or looping, executing the resulting thought process, and finally recording the outcome in memory for future feedback loops.
Just like us, CPUs also perform these tasks, one clock cycle at a time!
bramadams.dev is a reader-supported published Zettelkasten. Both free and paid subscriptions are available. If you want to support my work, the best way is by taking out a paid subscription.
The Simplest CPU
what do we need to make the simplest computer?
Let’s imagine the simplest version of something that has the ability to calculate. If we break down a calculation into its simplest components, we will need: inputs, operations, and outputs.
We want input data to compute against, some raw material to convert into something else, some kind of operation or operations to do said converting, and finally some way to decipher and store the outputs, and convert those into inputs to continue the process.
The simplest tool-less version of this is to use our own dextrous human hands. Feel free to try this experiment, or skip it!
Put both of your hands into a fists, showing zero fingers. Lay your right hand down on a table or your lap. Next, stick out your index finger on your right hand, and place your thumb finger of your left hand over it. Your thumb will serve as the “counter”. Next, count the finger (1) and raise one finger one your left hand. The four fingers on your left hand will serve as storage. Now close your right hand again and raise any number of fingers from 1-3. Remember, as you count one with your left thumb, raise a finger on your left hand. Now, use your right thumb to “read” from storage and count how many fingers you have up on your left hand. Amazing! We’ve created a simple adder without talking about adding, just counting one at a time and storing what we’ve counted. We can do the same with subtraction, if we want, the only change will be to put a finger away on our left hand for every finger we count on our right.
Now there are some clearly obvious limitations to this method. Despite obviously being very physically uncomfortable, we have some serious mathematical barriers that cannot be overcome. For one, if we reserve our thumbs as counters, we can only store four numbers total, since our right hand is busy introducing new numbers to be stored on the left. Secondly, the only operations we can conduct are based around simple counting, we cannot even access the other elementary math operations of multiplication and division (well technically, we could do division on our fingers, but trust me, we do not want to do that).
Even as we introduce more complex technologies to the table the general principle of what we did on our fingers: reading the fingers up on our right hand, executing a count using our thumb counter, and writing them to the left hand every time we counted one is the basis for all computation. Modern day computers do this loop we just did in our heads really, really, really fast.
Let’s imagine one more simple technology (this one will only be a thought experiment, no need to worry about contorting your hands). In addition to the operations of reading, writing and executing above, what other simple operations might prove helpful?
Perhaps we realize that we can repeat certain parts of the counting process over and over while in the “write” step instead of stopping to read every time. To multiply is to add something over and over (2 x 3 = 2 + 2 + 2) so a looping operation would help us unlock multiplication from addition. Division is the same as repeated subtraction into groups, so we can use the looping function here as well.
What happens when we decide to stop the adding operation count the number of fingers on our left hand? Or what happens when our four left fingers “overflow” from counting on the right hand? We need some way of being able to stop the count, or more accurately modify our decision making based on what we see on our fingers. We can call this a conditional operation. With our conditional operation, we open up an infinite list of sub operations. Let’s say that if two fingers are up on your left hand are up, you do ten jumping jacks or five burpees, or if three fingers are up you do ten pushups and dance in place for 30 seconds. The options are limitless! We see our trigger, validate it, and then do something else.
So loops and conditionals have been added to our list of operations. We can now read and write to storage, execute on what we read, loop to repeat some helpful block of logic, and jump conditionally to some other process if some condition is met.
bramadams.dev is a reader-supported published Zettelkasten. Both free and paid subscriptions are available. If you want to support my work, the best way is by taking out a paid subscription.
Why a Computer is a Universal Tool
why is a computer a universal tool?
From The List (202306232002), we discussed a series of increasing layers of complex problems that could be solved by imaginary an imaginary simple computer without any other technologies being added in a vacuum. But of course in the real world, that is not the case. In the 2020’s computers are in everything.
We defined a universal tool in The Universal Tool (202306202156) as being able to:
- recruit raw materials to its cause, generating single purpose tools inside of itself
- reshape its current architecture to perform new roles with the same building blocks (improving the same tools); attuning to problems better over time as we learn more about the problem
- bend the world around it to create more instances of itself
- solve new problems leveraging creativity and imagination
Recruit Raw Materials
There was a brief time in the early digital computation era (the 1950s) when everyone thought special chips would be placed into different items, but it turned out to be much more plausible and efficient to let a general purpose computer control any number of remote specific client computers — client computers as small as thermostats to giant cloud clusters of servers. The boundary between client and server began to fade over time. Computers can now decide with onboard logic to vacuum a room, to stop a car while parallel parking, or turn on sprinklers in the middle of a drought. Computers as a tool command raw materials at their discretion, and in addition can recruit inert raw materials and combine them based on context. This conditional “creativity” is a foundation of early work in AI, though researches realized early on that there is not nearly enough time or space in the world to implement everything in expert systems leveraging rule based mechanisms (but we’ll discuss this later).
Attuning to Problems
As time marches onward, problems tend to change shape. For example — some problems are inherently seasonal. We only worry about blizzards in winter, not July. This entails that some tools are only useful when the correct context is available, e.g. a snow plow in December.
Computers, and specifically programs, thanks to their abstraction, can re attune to a problem at any time. You probably know these as feature updates and bug fixes. This inherent flexibility means that the same program can evolve to match the problem as it evolves and grows. Interestingly enough, because it is so cheap to create new features and append them to the same code base, we actually get a new problem of feature creep where some vestigial features of programs are no longer useful but stick around because of the Chesterton’s fence parable, which states that changes should not be made until the current state of affairs is understood.
Create More Instances of Itself
A universal tool, being a universal tool, should have no issue in creating more copies of itself. This process need not to create a direct clone, but the successor should have the same core universal abilities of its parent at a minimum.
A human parent is well aware that their child, while being a product of their DNA, is not them. In addition, the parent raises their child leveraging a combination of genetics and environment to hopefully one day create a functioning member of society that then themselves can create a new child at the pace of one or two generations and so on.
Computers (the physical objects) have no direct way of replication (This statement isn’t even entirely true on the face of it as modern computer hardware fabrication centers are more run by computers than people! Especially since modern CPU chips are tuned on the nanometer level so there is no room for human error).
However, this does not mean that computers can not be heavily leveraged to make better computers, and in fact, this must be the case as every next generation computer was built on predecessor software and hardware and improved upon by using state of the art tech.
Speaking of software: software is a different story. To understand why this is the case, we need to understand the concept of Turing completeness. Simply put, for an imperative language to be considered Turing complete it must:
- have conditional repetition and jumping (for loop and if/else statements)
- be able to write and read to some form of storage
Later, we will be examining the proliferation of programming languages from the root of machine language. But for now, all we need to understand is that a Turing complete language can encapsulate a smaller also Turing Complete language, which can encapsulate another Turing complete language, and so on. Most modern programming languages (the ones you’ve heard of!) are Turing complete. An interesting side tool component from Turing completeness is Turing equivalence, meaning if you have computers P and Q, if they are Turing equivalent you can simulate them interchangeably.
This is not a copy. A copy implies that one is functionally the other, or more accurately, the copy is able to do all the things the original can do and nothing more or nothing less. A Turing equivalence between computers mean that in addition to being functionally equivalent, either Turing machine could have created each other and have Turing machines the same size, greater or smaller, with the same functionalities.
Solve New Problems
The thesis and purpose of this book is to explore the expanding space of problem solving through the tool of computation so there wouldn’t be much of a book to speak of without this being the case, but let’s dive into this claim.
A universal tool, as specified in The Universal Tool should be able to modify its physical attributes to address new problems with the same architecture. In other words, there should be no prevention of the universal tool to adapting to a new problem.
When we needed our hammer to also be a flashlight, we are not leveraging the same architecture from the hammer itself. We are adding an external LED bulb, battery and button. A computer can modify it’s same architecture in unique and novel ways to fit to brand new problem territories. Within the total space of computation is both all solved problems with computers and unsolved problems.
In fact, there is only two (or maybe three if you’re generous) other object in the known universe that can also fit the four requirements above. Care to guess what they are?
The Other Universal Tools
The brain is the other universal tool. The brain is able to do all of the items listed above (and more!). A brain can easily recruit raw materials to its cause, and then leverage those raw tools to create more advanced tools that then themselves go on to create more advanced tools. Thanks to the scientific method, the human brain is able to use science to get closer and closer to the reality of a thing. Sexual reproduction is the brains means (well DNA’s really) way of creating new copies of itself. Finally, the human brain is able to leverage creative leaps to jump from one solution space to another, and is not limited to the visible problem space, as a counterfactual engine (though that is a topic for another day).
DNA is the second universal tool. Language is the third universal tool. I’ll let you deduce why these are the case given the requirements of a universal tool.
You may have noticed that universal tools can create brand new universal tools on top of them. The reasons for this are discussed in depth in David Deutch’s amazing The Beginning of Infinity but for the purposes of this book, realize that within universes are smaller universes that in and of themselves can create universes and so on.
bramadams.dev is a reader-supported published Zettelkasten. Both free and paid subscriptions are available. If you want to support my work, the best way is by taking out a paid subscription.
The List
can we imagine an exhaustive list of tasks computers can do?
If you set out to make a list of tasks computers are possible of doing, you’d be hard pressed to come up with an exhaustive list, at least using the naive approach of listing each and every individual program that might be able to exist in the right context (a music streaming app + tinder + visual studio code is technically a new app, despite there not being much of a market for that kind of thing).
But that shouldn’t stop us from trying in a creative way!
Start Out Small, and Layer
Let’s assume we have an extremely simple model computer that only has a screen (or something else a human can perceive values out of), two buttons with labels 0 and 1, a CPU, and a memory card. (If we use Turing equivalence as an axiom, we can have computers Q and P can simulate one another’s abilities exactly, given enough memory space. This means that we can abstract away the sub problems computers can solve into massive umbrellas of pattern matching.)
Listing some of the simplest, non complex uses this modern computer has as a tool, we might start with: perform simple operations to the number buttons.
Like Street Fighter, we can use our memory card to save number combos to operations like add, subtract, multiply, etc. Ok hmm, that was pretty easy. We now have the ability to sum, multiply, divide and subtract numbers. From here we can stop all work and create: accounting apps and simple calculators.
Next, let’s say that we’ve come up with a particularly interesting order of operations. We find ourselves doing a lot of the same series of operations over and over, so in addition to storing a number map to simple operations, you save multiple operations to a spot in your memory card to be retrieved whenever. We now need to build in logic that will allow us to store and process complex operations built out of simple operations. At this layer and create functions, these functions can be any combination of our simple operations, and perhaps we can even try some really complex math equations like calculus or algebra that require a lot of moving parts. Even better yet we can nest these operations inside of other operations, creating trees of recursive functionality. From here we can stop all work, and in addition to all we have above we now have: physics, chemistry and biology simulators, stock analysis tools, and any other calculations that require multiple numbers to be managed through complex equations.
Let’s move up another layer. We realize that these functions so far have only been relevant to the numeral space like a calculator, but one day we realize that we are able to map binary numbers to letters, and also pixels on a screen! So we map these modified numbers to colors and store them in our memory card. Perhaps we can assign 01 to red and 00 to blue and 11 to green and so on.
Now we can modify numbers and render them on the screen as colors. If we do enough of this, we can probably paint pictures, perhaps any picture! Let’s take advantage of our storage and save number strings to storage for later. We can stop here and in addition to all we’ve made above we can make photoshop, video applications (minus the sound since we don’t have any speakers in our simple computer), e-books, word processors, note taking apps, city and topographical maps, and if were willing to map sounds to data or vibrations to data, we unlock music, speech, and haptic programs at this layer.
This is great, but what if we want to use all these techniques we’ve learned on another machine. We need some sort of way to broadcast our numbers, so that other machines can see the math as well. For now, let’s just leave messages on our memory card, and run it over physically to another computer that has the same specs as our first simple computer. Amazing, we’ve just created messaging! From here we can stop and in addition to everything above we can create: the Internet, e-mail and social media.
By modifying, storing, and attaching symbols to numbers we have unlocked every tool in its warpath. Now that’s what I call an investment!
The Things We Didn't List
The list above is not at all exhaustive. All data (light and audio being most versatile) can be converted back and forth freely to numerical data. As long as we can store these numbers, and better yet if we can get machines to agree on these numbers, we have created a universal tool that can communicate with other universal tools (and also fits other universal tools (202306202156) inside of it (a program running a program)).
Remember, computers can create other computers as well. Humans very well could step out of every step in the process of computing and then computers could fabricate parts, seed the OS, etc. Software does this already every time you hit a “download” button on a website and uses settings from your computer to seed the app.
bramadams.dev is a reader-supported published Zettelkasten. Both free and paid subscriptions are available. If you want to support my work, the best way is by taking out a paid subscription.