
# Recently

Welcome to my monthly update! I'm going to try to do these once a month. 
I've got one down and this one too - so far, so good.


# Productivity

This was a pretty quiet month productivity wise. Just a chiller one at
work, and some super wack google nonsense. Their AI filter randomly decided
to shut down the onepodshop ads _again_. I'm getting pretty fed up with
their silly monopoly. Also, [llamalife](https://llamalife.co/) lost it's
free tier, which is too bad but I understand they have a business to run.

# Books

This was more of a middling month of reading. I got a lot of bits and 
pieces here and there but only finished one book. I once this month found myself stranded without
internet or device and had to read to pass the time, and I kind of
liked the vibe.


**Five Lectures On Psychoanalysis** by Sigmond Freud

In an English class (Intro to Expository Prose) at SFU, I remember my professor saying that of all
the essays he's read, he ranked Freud very highly - claiming that Freud, regardless of whether
his theories are sound or not, had written his favorite essay. 
This came as a bit of surprise to me as
I hadn't ever really heard of Freud as some great essayist, in fact I
even took an "intro to psychology" class and not once did they mention
Freud's skill with the quill. I made a mental note of this at the time
to check out some of his works from his own mouth.

Anyways I finally got around to reading a book about him, called Five Lecture on Psychoanalysis,
whose first chapter you can freely read on the [internet archive](https://ia902907.us.archive.org/17/items/SigmundFreud/Sigmund%20Freud%20%5B1909%5D%20Five%20Lectures%20on%20Psych-Aanalysis%20%28James%20Strachey%20translation%2C%201955%29.pdf)

To be one hundred percent honest, I don't think it's the _best_ essay I've ever read
or anything, but it's surprisingly coherent. It's easy to follow, has some
funny jokes, and kind of goes against the idea that Freud was some stuck up
academic or some woo-woo dream interpreter. 

Note also that these lectures are from a Freud prior to the Oedipal complex,
and instead offer a very first glimpse into the idea of psychology. It's
really quite amusing how excited Freud is at the notion that you can cure
illness simply by speaking about it. Also as the "father of psychology" he
outright claims that he is absolutely not the father of psychology, that he
learned these methods from other doctors while he was working in the hospital
himself.

The five lectures of the book are supposed to introduce the layman to the (then new)  
field of psychoanalysis. In it he lays out the problem: people are suffering from
a disease only described as "hysteria" - a disease with no known medicine or medical
procedure to cure it. Then he presents some experimental data about various
hysteria cases he observed while working with another doctor, Josef Breuer. These
studies were published in a paper called "Studies on Hysteria". Encouraged by
these findings Freud came up with a theory about hysteria: that it is caused by repression
and if we bring that repression to light we can begin to cure it.

Since repressions are, well _repressed_, you cannot simply ask the patient to surface
their deepest repressions. The next sections are Freud's various attempts to unearth these repressions.
They span from hypnosis, repetition, making them tired, and finally to free-association and dream analysis.
You get the impression that Freud really was shooting in the dark so to speak, and seeing him describe
his attempts, both failed and successful, are really quite amusing. Also he draws some
funny and vivid analogies about his theory of mind, like describing the repression as
a rude interrupting student at a lecture who needs to be kicked out of the room, but who keeps
trying to come back in even though we locked the doors.

In the final lecture, Freud describes how he believes all repressions are erotic in nature,
and this is about the time my attention really started to trail off. For as good of a writer
Freud is, I think just binging 100 pages of a subject I only have a passing interest in
kind of dry. 

# Other

- Tried [foundry](https://github.com/foundry-rs/foundry) for Ethereum Smart Contract development for the first time. It's great!
- Found some good deals on vps hosting over at [low end box](https://lowendbox.com/blog/silicom-network-has-another-amazing-cheap-shared-hosting-offer-starting-at-12-lifetime/#:~:text=Home-,Silicom%20Network%20has%20Another%20Amazing%20Cheap%20Shared,%3A%20Starting%20at%20%2412%2FLIFETIME!&text=If%20the%20name%20Silicom%20Network,community%20for%20a%20long%20time.)
- Discovered a cool math [youtube channel](https://www.youtube.com/@ChrisStaecker) specifically loved weird math tools like the [Steinhaus Longimeter](https://www.youtube.com/watch?v=-ZE2Iv-8tsA)
- TRPC continues to enthrall me. Maybe I should port the crossword stuff to it.

# Addendum

I feel like to actually update my "books" section, I need some sort of an admin
panel. Doing through the source code just feels like a hassle. 


August Recently


# Recently

I'm thinking of doing monthly updates
of what I've been up to. I think it's a good to keep myself
posting on the blog. Also, I stole the idea from [macwright.org](https://macwright.org).


# Productivity

I recently started [onepodshop](https://onepodshop.com) with no knowledge of 
Wordpress, Woocommerce, Php, nginx, or basically anything
related to the stack. It's always nice to shock the system. The first day feels like
you're drowning, but then you start to tread water, and then you start to swim. 

Write a few automation scripts and you're aquaman. It's crazy how much you improve
if you just start doing it every day.

You really can get so much done if you start getting the hang of something.

I'm also always shocked at how, instead of getting more done, I just
do nothing with my extra time! Sometimes I fall back on pretending like I worked as
much as possible by pointing to my work hours. The sneaky part is that you need to keep yourself
dedicated to excellence because nobody is going to hold you to that standard. Realistically, I think
I have ~3x worth of output in me unused. I just need to figure out how to get it out.

# Books

This was a great month for reading. I finished three books, all of which
I thouroughly enjoyed.

**The Pheonix Project** by Gene Kim, Kevin Behr, and George Spafford

Wow, I was caught off guard by how much I enjoyed this book. At it's
core it's a book about development and operations. But the way
it's delivered is through a story. A fictional setting for some
company "Parts Unlimited" that has a struggling IT department.
The story is told through the eyes of the new VP of IT Operations
who is tasked with turning the department around. 

The story is enjoyable as a story, and it instills some good
lessons about how to run a company. I can truly say it's my favorite
business book I've ever read. I think I might be an operations person
at heart! I'm excited to read the sequel.

**Candide: Or Optimism** by Voltaire

What can one say that hasn't already been said?
This book is a real classic - but don't let that fool you.
It doesn't read like a classic at all. It's super short, hilarious,
and full of adventure. I feel like it could have been written
yesterday on fanfiction.net or something. It's also still
geniuinely funny. I laughed out loud a few times. It's full
of sex & violence, a real page turner.

Highly recommended, espcially if you're the type of person
who doesn't like to read classics.

**No Longer Human** by Osamu Dazai, as interpreted by Junji Ito

This is a manga adaptation of a classic Japanese novel.
The novel follows a protagonist who is deeply disturbed
and alienated from society. He inadvertedly hurts everyone
around him, and is unable to connect with anyone. It's a
very dark story, and the manga adaptation has the trademark
Ito macabre style. Not for the faint of heart, but watching
two masters of the craft work together is a real treat.



July Recently


import { PopCitation } from '@/components/PopCitation'

# Run and return sql in supabase with plv8 - a cheesy hack

**Warning: Probably a bad idea**

So you want to run an arbitrary sql statement in supabase and return
json? And you don't want to learn that weird plpgsql language? because
chatGPT can't write decent plpgsql to save it's aritficial life?

TLDR, just put the SQL you want in this template:
```sql
CREATE OR REPLACE FUNCTION public.foo_bar()
 RETURNS json
 LANGUAGE plv8
AS $function$


  var num_affected = plv8.execute(`

-- BEGIN SQL

-- SQL GOES HERE

-- END SQL

`);

  // Convert BigInt values to integers
  num_affected.forEach(row => {
    row.user_count = parseInt(row.user_count);
  });

  return JSON.stringify(num_affected);


$function$
;
```

We simply have to use the `plv8` extension and
then we can use javascript in our stored procedures.


We can also run `sql` in the javascript!
To do this we can use the `plv8.execute` method.

So let's say you have a table for storing you and your friends
crossword scores. There's a table with a puzzle_id, a user_id, and a
score. You whisper this request into the LLM and it spits out:

```sql
WITH ranked_solves AS (
  SELECT user_id, puzzle_id, seconds_spent_solving,
    ROW_NUMBER() OVER (PARTITION BY puzzle_id ORDER BY seconds_spent_solving ASC) AS rank
  FROM crosswordsolves
  WHERE is_solved = true
)
SELECT crosswordusers.id,
  COUNT(CASE WHEN rank = 1 THEN 1 END)::INTEGER AS first_place_finishes,
  COUNT(CASE WHEN rank = 2 THEN 1 END)::INTEGER AS second_place_finishes,
  COUNT(*)::INTEGER AS total_solves_attempted
FROM ranked_solves
JOIN crosswordusers ON ranked_solves.user_id = crosswordusers.id
GROUP BY crosswordusers.id;
```

Of course, we are normal humans so we can't read SQL. But you
run the query and it seems to work. Now, just to convert this
query to plpgsql and you're done.

Oh wait! You can't write plpgsql! And you don't want to learn
it! 

That's where our friend plv8 comes in. We can write a function
that runs this query and returns the results as json. Then we
can call that function from our sql statement.

```javascript
  var num_affected = plv8.execute(`
WITH ranked_solves AS (
  SELECT user_id, puzzle_id, seconds_spent_solving,
    ROW_NUMBER() OVER (PARTITION BY puzzle_id ORDER BY seconds_spent_solving ASC) AS rank
  FROM crosswordsolves
  WHERE is_solved = true
)
SELECT crosswordusers.id,
  COUNT(CASE WHEN rank = 1 THEN 1 END)::INTEGER AS first_place_finishes,
  COUNT(CASE WHEN rank = 2 THEN 1 END)::INTEGER AS second_place_finishes,
  COUNT(*)::INTEGER AS total_solves_attempted
FROM ranked_solves
JOIN crosswordusers ON ranked_solves.user_id = crosswordusers.id
GROUP BY crosswordusers.id;
  `);

  // Convert BigInt values to integers
  num_affected.forEach(row => {
    row.id = parseInt(row.id);
    row.first_place_finishes = parseInt(row.first_place_finishes);
    row.second_place_finishes = parseInt(row.second_place_finishes);
  });

  return JSON.stringify(num_affected);
```

And then we just wrap this in the function definition and we're
done (my syntax highlighting is broken here of course)

```javascript
create extension plv8;
set check_function_bodies = off;

CREATE OR REPLACE FUNCTION public.get_stats()
 RETURNS json
 LANGUAGE plv8
AS $function$
  var num_affected = plv8.execute(`
WITH ranked_solves AS (
  SELECT user_id, puzzle_id, seconds_spent_solving,
    ROW_NUMBER() OVER (PARTITION BY puzzle_id ORDER BY seconds_spent_solving ASC) AS rank
  FROM crosswordsolves
  WHERE is_solved = true
)
SELECT crosswordusers.id,
  COUNT(CASE WHEN rank = 1 THEN 1 END)::INTEGER AS first_place_finishes,
  COUNT(CASE WHEN rank = 2 THEN 1 END)::INTEGER AS second_place_finishes,
  COUNT(*)::INTEGER AS total_solves_attempted
FROM ranked_solves
JOIN crosswordusers ON ranked_solves.user_id = crosswordusers.id
GROUP BY crosswordusers.id;
  `);

  // Convert BigInt values to integers
  num_affected.forEach(row => {
    row.id = parseInt(row.id);
    row.first_place_finishes = parseInt(row.first_place_finishes);
    row.second_place_finishes = parseInt(row.second_place_finishes);
  });

  return JSON.stringify(num_affected);
$function$
;
```

To call it on the client or server, you just use the `rpc` method
on the supabase client.

```javascript
const { data, error } = await supabaseAdmin.rpc("get_stats");
```

And that's it! You can now run arbitrary sql and return json.

If you want to add arguments, you can add them as an array as a
second argument to the `plv8.execute` call, and just use the `$1`
style argument passing like so:

```javascript
CREATE OR REPLACE FUNCTION public.get_leaderboard_for_month(leaderboard_id integer, day text)
 RETURNS json
 LANGUAGE plv8
AS $function$
{
  var num_affected = plv8.execute(`
    SELECT
      cu.username,
      cs.seconds_spent_solving,
      RANK() OVER (PARTITION BY cp.date ORDER BY cs.seconds_spent_solving ASC) AS rank,
      cp.date AS solve_date
    FROM
      crosswordleaderboards cl
      JOIN crosswordleaderboards_users clu ON cl.id = clu.leaderboard_id
      JOIN crosswordusers cu ON clu.user_id = cu.id
      JOIN crosswordsolves cs ON cu.id = cs.user_id
      JOIN crosswordpuzzles cp ON cs.puzzle_id = cp.id
    WHERE
      cl.id = $1
      AND cp.date BETWEEN DATE($2) - INTERVAL '30 days' AND DATE($2)
    ORDER BY
      cp.date DESC, cs.seconds_spent_solving ASC;
  `, [leaderboard_id, day]);
  
  // Serialize JSON with custom replacer function to handle BigInt values
  return JSON.stringify(num_affected, (_, value) => {
    if (typeof value === 'bigint') {
      return value.toString();
    }
    return value;
  });
}
$function$
;

```

Note that in this case, we opted to use the `toString` instead
of `parseInt` because we want to preserve the BigInt values.

Run and return sql in supabase with plv8 - a cheesy hack


# You can get a lot less done than you think

It is remarkably easy to overestimate what you can accomplish in a given span of time.
Our intuitions about productivity are often little more than wishful thinking.
I used to think of myself of something of a "fast" coder. Able to whip something
sort-kinda working in a small amount of time.

Quintessential to this self-image was that coding was easy. You just kick back,
relax, and let the code flow. And flow. And flow. And wow, woodyalookatthat, you
accomplished something... pretty minor.

Recently I've tried using the [llama life](https://llamalife.co/) timer to
measure some of my tasks. I think measuring time out like that clarifies
time, much in the same mathematics clarifies thought.

Coding fast isn't "easy".

It is simple to say “today I will design a landing page.”
But that statement belies the multitude of components involved: header,
footer, content sections, visual styling, responsiveness, SEO, analytics,
hosting, and domain configuration - each comprising numerous tasks of its own. 
Only by meticulously breaking down the work into discrete steps, and realistically
estimating the time required for each, do we come to recognize the scale of what we
have undertaken.  


I recently tried mapping out precisely what I was going to work on.
It's easy to think "Oh I'll do that in a few hours" but when I actually sat down
to do it - well a 26 minutes here, 26 minutes there, and wow that's your whole workday.
I was focused! I was flowing! And yet, I didn't get much done. Why?

Each task has substasks. Each subtask has a potential landmine of misunderstanding you have to read into
(oh no! I never setup a job queue from scratch before! I always joined the team after!)

## Sober up

First, you give everything an estimate:
1. Header - 40 minutes
    1. Logo - 15 minutes
    2. Nav - 25 minutes
    3. Links - 15 minutes

And you do it for the whole day's task:

1. Header - 40 minutes
2. Footer - 40 minutes
3. Body - 40 minutes
4. Content - 40 minutes
5. Styling - 40 minutes
6. Responsive - 40 minutes
7. SEO - 40 minutes
8. Analytics - 40 minutes
9. Hosting - 40 minutes
10. Domain - 40 minutes


And then you realize that's 400 minutes, or 6 hours and 40 minutes. 
And you only have 8 hours in a workday. This is what you can get done in one day.

That is, if you were some sort of superhuman who could work 8 hours straight without
a break, without a distraction, without a single moment of confusion or misunderstanding.

Then you multiply everything by 4. Because you're not a superhuman who can work
8 hours straight without a break, without a distraction, without a single moment
of confusion or misunderstanding.

This 6 hour and 40 minute task is realistically going to take you 2-3 days.

And that's just the first task. You have 10 tasks. That's 20-30 days of work.
I think it __it__ possible to be fast, crazy fast like how you think you'll code
in your head. But it's not going to be __easy__. That's the main point I want
to make.

People aren't breezing through code because it's easy. Sprinters aren't running "easy" they're
running "fast". It's hard. It's hard to run fast. It's hard to code fast. It's
hard to do anything fast. So if you want to code __fast__ you can't take a casual
approach to it.

You have to really push yourself.

You might get a lot less done than you think


# how to code easily

How do you code easily, well?

By coding bad. Take a statement. `print('hello')`. 
We can see something. Good. Run it again with more code. Use a ton of if statements. 
Write the same line at the end of each of them. Make a huge switch case. 
Copy paste the same four lines over and over. Use flag variables. 
Don't be bogged down by good coding. Usually bad coding feels good.

> Ah, it feels nice to see some output!

Then eventually it feels bad, so take it out. Pull the common statement out of the loop. 
Extract out that switch case to dispatch out to mini cases. Then mini parsers. 
Put the nine copy pasted lines into it's own function. Usually this also feels good.

> Ah, it feels nice to see the code get smaller!

Things that feel bad are usually doing these out of order. 
Being organized to start: too much friction. 
Being messy in the endgame: impossible to reason.

To code well, go towards the direction of maximal pleasure. 
This advice, I feel, can apply to any field you have achieved a certain level of literacy in.

how to code easily

Book review: CLOSURE by why the lucky stiff


# Hello, bit sizes?

I remember one of the assignments (in fact,
literally the _first_ assignment at my university ever - we skipped
"hello world" for some reason)
was to print the bit sizes of various types. So, after much pain, we went ahead and
wrote

```C
#include<stdio.h>
int main() {
  printf("An int is %d bits long \n", sizeof(int));
  printf("And float is %d bits long \n", sizeof(float));
  printf("And char is %d bits long \n", sizeof(char));
}
```

and after learning the secret incantation of `gcc`, we got out

```
An int is 4 bits long
And float is 4 bits long
And  char is 1 bits long
```

Which, despite obviously not knowing the difference between bits and bytes,
I think is a pretty impressive first program.

Afterwards, we learnt about functions. And I even wrote my
**own** function! Of course, since I am a prodigy of programming
it took my no time to create this absolute beauty:

```C
#include<stdio.h>
int coolFunction(int number) {
  return number + 3;
}
int main(){
  printf("%d\n", coolFunction(3));
}
```

```
6
```

Ah so that's pretty easy. I guess `printf` and `sizeof` are two
other functions that some old guys with beards wrote.

Something with that `main`
function was also important. Well, here I am, totally
on their level since I've also written _my_ function.

It wasn't until an embarassingly long time later that I realized that **none** of those
functions are like each other. After learning what they meant I almost felt like
I had finally understood a koan, unveiling immediately a bunch of facts about
programming in C which I never thought of.


# Breaking it down 

Let's start with the abomination which was my function.
This is a standard function. Strict return type, strict input, strict computer science professors.
If I wrote `coolFunction(4, "please");`, my compiler would throw error,
my lower palm would make an impact with my forehead, and I'd start again.
And, like, of course it would, there's an extra argument there.


# stdARG matey! 

Next, let's look at the `printf`. This is just some function defined in
`stdio.h`, right? I guess the format string with it's %d's and %x and stuff must
serve some purpose with memory allocation?

Well actually, and I'm not sure how I didn't notice this
despite using `printf` every single time I used C, that it can take a **variable** amount
of arguments (i.e. it's a [Variadic function - Wikipedia](https://en.wikipedia.org/wiki/Variadic%5Ffunction))

I mean, duh, of course it can. I've been putting a random amount of floats, ints,
and chars all the time. Yet, for some reason, I decided "yep that's normal, and I
will never try to create a function with variable parameters myself, because that
is impossible and has never been done before. Now I will `printf` debug this code."

So, despite nearly a full computer science degree, we never even heard of variadic arguments
in C - even though we used them every time. Well, they're defined in the `stdarg.h`, and
has a bit of syntax for declaring variadic functions, the dottybois (also known as the ellipse)

```C
#include<stdio.h>
#include<stdarg.h>

int coolFunction(int number,...) {
  return number + 3;
}
int main(){
  printf("%d\n", coolFunction(3, "please", "oh", "yeah", "wassup", 1337));
}
```

```
6
```

Thank you C, very cool! But what if we actually wanted to _access_ the variadic arguments?

We call this macro called `va_start` provided in `stdarg` to begin iterating over the
arguments. It takes a `va_list` type so we'll have to declare that as well. Finally we need
to use the `va_arg` macro which expands the type that we give it. They're all
polluting the namespace already from `stdarg` already so no skin off our back

```C
#include<stdio.h>
#include<stdarg.h>

int coolFunction(int number,...) {
  int count = 3;
  va_list args;
  va_start(args, count);

  for (int i = 0; i < count; ++i) {
    printf("%d\n", va_arg(args, int));
  }

  return number + 3;
}
int main(){
  printf("%d\n", coolFunction(3, 1, 2, 3));
}
```

```
1
2
3
6
```

Alright! We could create simple `sum`, `min`, and `max` functions like this, but there
are a few things bothering me right here. First: the `count` variable. I just arbitrarily
decided it would be 3. But if I have that information then why would I need variadic functions?
The answer is I won't. It's only useful if I **don't** know the `count` value from within the function.

So how do we know how many arguments we're going to have to iterate through?
Well, and you're going to think this is pretty lame, but we have to pass that as a variable.
For example, `int coolFunction(int count, int number, ...)`.

But wait `printf` doesn't do that, right?

Actually, it just iterates through the format string and counts the amount of %'s (that are not escaped)
and uses that as a count.

Here's another problem: type information is lost. Say I wanted the same code but used `coolFunction(3, "hello", 1, 3);`
on the last line. I would need to have that type in my `va_arg` macro call.

Is there any way I could check the type of my variadic argument and do something like

```C
if(type(arg) == int) {
  /* do this */
}
else {
  /* do that */
}
```

Answer: no. Type information is lost. We're just playing with pointers. That's why the format string
uses the %d and %x and %\{whatever\}. That's the workaround - _you_ put the types in.

Actually `printf` is kind of genius in the way it makes _you_ do a lot of the computer's work:

-   You tell the function how many arguments you expect
-   You give the types of those arguments

And you didn't even realize! You poor fool!

Compare this to Pascal, where you can write `println("hello", 52, "this", 1337, 1337, "is valid");`
and the system does the work _for you_. There's nothing particularly special about the `%` sign either,
we could just as easily write a `int cool_printf(const char* format, ...);` that uses the `$` character
as its escape character and `$i` could be equivalent to `%d`.

For more on this, check out [stdarg.h - Wikipedia](https://en.wikipedia.org/wiki/Stdarg.h)


# sizeof 

Alright, now for the tricky one. First of all, `sizeof` is a
compiler built-in. That means we _can't_ write our own version.

It's also a macro, so it doesn't need to abide by the simple
mortal rules of the C syntax.

This makes sense since the compiler is responsible for knowing things about
my register sizes, architecture, and other low level goodness, and
since `sizeof` tells me those things, I knew there would be something fundamental
about it.

But in fact `sizeof` is quite powerful. When doing the blackmagicvoodoo of pointer
arithmetic _it's using sizeof under the hood_. How's that for fundamental?

Not only that, but sizeof can take a regular variable (like "number" above), it can
take a type (like "int") and it can take an expression (like "4 + 42"). Also because
of its /macro/ness you can write

`sizeof 5 + 5` which will be parsed as `sizeof(5) + 5` which means the size of the number
5 (4 bytes on my computer) + 5 which is 9.

But `sizeof(5 + 5)` will be `sizeof(5+5) = sizeof(10)` which is 4 bytes.

In fact, mastery of sizeof is kind of a requirement for high-level C-fu especially for proper
struct packing.

Finally, checkout this [Implement sizeof Operator in C using Macro](https://cs-fundamentals.com/tech-interview/c/implement-sizeof-operator-in-c) - interesting approach.


# Conclusion 

So did I finally learn precisely what was going with that first program of mine, more than
three years later? Actually no. And to be honest, I don't think I ever will unless I somehow
get on the `gcc` core team. For example, I know `main` and `_start:` are linked somehow, but
how?

It's actually stunning the tremendous amount of abstraction that we work under.

Today I sat down and tried to understand
exactly what was going on in the tiniest of tiny C programs and found a fractal amount of
depth containing macros, m4, compilers, and standard libraries.

I can't even begin to imagine what that would look like in a language like python.

Although I've got to say, it's been a fascinating dive. Maybe I'll do another sometime.
But for now, it seems I'm still whispering incantations and watching bits flip.

Blog posts