Do you need a simple reverse TCP tunnel to a local service (like SSH), but you don’t want to install anything or use a one of the public ones.

Warning: There is no authentication, use this only for temporary things or IP allowlisting to limit who can connect.

Get the sish binary from github

With that out of the way, on the server run

./sish --authentication=false --ssh-address=:9999 -i:9989 --bind-random-ports=false

then run on the client

ssh <server-ip> -p 9999 -tt -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -R 12345:localhost:22

Do you like the new Brave/Chrome tab finder ctrl+shift+a but it’s conflicting with slacks shortcut for Open the All unreads view?

If you use StopTheMadness (https://micro.blog/lapcatsoftware@appdot.net) then you can stop a webpage from hijacking any CMD shortcut (or any shortcut), but what if you want to allow the webpage to keep most shortcuts, but disable one? Add the following code to the custom-script part of StopTheMadness for the slack domain

window.addEventListener('keydown', function(e) {
    if (e.metaKey && e.shiftKey && e.code === 'KeyA') {
        e.stopImmediatePropagation();
    }
}, true);

This can of course be modified to fit your favourite application and browser shortcut.

Have you ever heard of dopamine fasting? Apparently, it’s a “thing” now. It even has its own Wikipedia page, so you know it’s legit.

But for me, dopamine fasting is an annual tradition that I’ve been doing for about 10 years leading up to Easter. It’s not like I’m particularly religious, but the 40-day period seems like a good time to cut back or quit something that I thought brought me happiness but wasn’t entirely sure.

In the past, I’ve tried fasting from social media, computer games, caffeine, and probably some other stuff that I can’t remember. This year, I’m calling it a dopamine fast because let’s face it, there is a lot of people trying to push down quick dopamine kicks on us.

Now, why do it? Well, for me, it’s about breaking bad habits and focusing on things that truly bring me joy, like binging on Netflix or spending time with my cats. And how do I do it? Simple, just give up something that you enjoy but aren’t sure is actually bringing you happiness.

Now, as for whether it “works” or not, who knows? A professor of neuroscience, Ciara McCabe, says that it doesn’t necessarily affect dopamine levels. But hey, I’ve found it enjoyable and helpful in breaking some bad habits, so I’m going to keep doing it. And I recommend you give it a try too, unless you really enjoy mindlessly scrolling through social media or chugging caffeine like it’s water.

As I said, this year I’m doing a more general dopamine fast. I’m not entirely sure which parts I’ll cut out, but I know I can’t completely cut out social media or email since I use it to stay up to date on news, but I will limit my usage to one specific hour a day. And to avoid mindlessly checking my email or social media, I’ll be using NextDNS to disable some things on the DNS level. Check out my post if you’re interested in how that works.

So, give it a try and see what you think. And at the end of it all, reward yourself with something delicious like a real Finnish Mignon.

First, this is the completionist solution. The goal of this is to read (or at least see) every toot from everyone you follow. This is based on a draft I made many years ago on how I use twitter (with Tweetbot, RIP) which I never published, but now with Ivory it felt relevant again.

There will be no magic algorithm deciding what you see from a large pool of toots. This means you will need to be selective of whom you follow. There are plenty of people who post interesting things occasionally and then post a lot of other things. Luckily, there is a way to keep up with them also, lists, I’ll get back to that in a bit.

Now, the second thing you need is an app that syncs your timeline position and supports lists, and has the ability to sync the position on a list. Most apps sync the timeline, but lists aren’t well-supported. If your app doesn’t support it, then give Ivory a try. The end goal is to get to the top, glancing at every toot, and when you’re at the top you’re DONE for the day.

DONE? On a “social media” platform. Yep. One of the goals with this method is to avoid doom scrolling as much as possible. If you don’t have time to get to the top, just leave it and return another day.

The downside here is that you won’t see “things as they happen”, you might see a toot a day later when the discussion already stopped. That’s right, and I consider it a good thing, today’s world could use less quick replies and more slow thinking. But that’s just my opinion.

Anyway, lists. The rule of thumb is, anyone who toots too frequently, moved to a list and muted on the main feed. Again, what “too frequently” is depends on how much time you want to spend on mastodon per day. If you notice you’re falling behind, then you probably need to move more people to lists. When you have extra time, you then go check your lists. Sometimes I have a list for only one person, as that makes skimming it faster. Usually people have a few categories of toots, the ones about corn and other things and the ones with tips on effective GPO policies.

This is not optimal, but until apps figure out something like “show only toots with more than X favourites from this person” it works fine. And looking at the explosion of new mastodon clients, I’m very optimistic that we will soon get better ways to do this.

Because there are some interesting people who toot a lot who you want to stay up to date with, but if you put them on your timeline you’ll fill it up

Lastly, there is of course no “right way” to use mastodon. I liked this approach, but the fediverse is much more diverse than twitter ever was, and there are countless ways to consume or use it. I encourage you to try out different clients, and even non-mastodon clients using RSS.

Ok, after a few harder ones, we’re back to something which looks like right up the alley of GPT. A simulated computer. Although it isn’t what large language models (LLM) are made to do, previous examples has shown that GPT does quite well at it.

So let’s give it a try and hope for the best. As usual, we start with the full input.

It produces something that works on the first try. Promising start. But this does not consider that the addx takes two cycles. But it seems on this “thread” it is not possible to get GPT to understand this. GPT just tries to skip cycles instead of delaying the update.

I also tried a reset with the same instructions, still no luck at getting it to properly handle the delay.

I tried multiple variations of prompts like

You need take into account that the addx takes two cycles before x is updated, there is a delay between the addx and when x is actually modified. During this delay, the execution continues as normal. After the second cycle, the value of X is updated.
You also need to take into account that there can be multiple addx functions in-flight which has been executed but the x value has yet to be updated.

It’s interesting that GPT is struggling with this because to me the solutions seems quite straightforward, just keep the pending addx in a list and keep track of when they were executed, and apply them when it’s time.

Let’s see if we can just tell GPT this.

No, with trying to add

As a hint, as there is a delay between addx and the value being applied, we probably need to track pending addx and at which cycle they were executed, and after each cycle we check if there is any pending addx updates we need to apply.

To the instructions. For some reason, the solutions are even worse. Let’s give the simplify-solution a try.

Simply no-go

After a few iterations, and then a few iterations to hash out coding errors, we end up with this, which looks intriguing. But alas, it produces the wrong result, and I’m out of patience with a barely responding ChatGPT.

Ok. I was honestly considering just skipping this. Day 9 looks quite ridiculous. But let’s give it a try.

At least one thing, GPT is sometimes good at, is taking a long description and summarising.

The first try, with the puzzle description without change got this which wasn’t a good start, a few iterations laters we weren’t making much improvement. So, time for a reset.

Also, we have another challenge today. Because ChatGPT has gone mainstream, it’s much slower than when we started. Taking up to a minute for each answer, and occasionally halting mid-answer.

This makes it very frustrating to try to iterate on code using it.

Anyway, the second attempt is the full description without any visual examples. That has better luck (and as we have learned, getting a good answer requires luck). Other than a simple mistake of naming a variable the same as a function.

def move(direction, steps):
[snip]

# Loop through the moves and apply them
for move in moves:
    direction = move[0]
    steps = int(move[1:])
    move(direction, steps)

It now works. But it gives the wrong answer. It really has issues with “understanding” that the Head can’t just teleport, and it needs to simulate each step. It needs to be told explicitly to not do that.

Another things I’m consistently seeing in my prompting, is that it wants the tail to move to the same coordinate as the tail. It does not understand that the tail drags behind, as the instructions state.

Although I was making some headway with take2, I gave up on that as it was turning into me solving the problem and telling GPT to produce the code to do it, which is not the goal of this post series.

Instead, I want to try the approach where I try to explain the problem more simply, rather than involving the elves. So, I prompt it with a simpler explanation of the problem (prompt). And I get back a solution, with most of the same problems, but it looks like it has some potential.

The problems with this is that

1. It does not execute (because it does not split the instruction, it fixes it after being told the error)
2. It does not simulate each step. Again, it fixes this after being told.
3. It does do not count the number of unique positions the tail has, which to be fair, my simple prompt didn’t ask for that.

After asking, it to return the number of unique positions the tail has visited, and to read the input from a file, we get.

This which works! Is it worth a gold star even if I had to simplify the prompt? Let’s say it is.

Part 2

Uh oh… Now the rope is 10 parts long. Let’s think a bit how to present this to GPT. First, let’s see if it can just rework it

Lovely, can you now simulate a longer rope? One which is 10 parts long. Each of the parts of the rope follows the previous part of the rope with the same logic as the tail followed the head. We are only interested in which positions the tail (part 10) has visited.

No, that does not work.

Even after a few more prompts, we don’t get anywhere. And ChatGPT is close to unusable during American daytime hours, takes a minute or two to provide an answer and often gets stuck on an answer or just provides part of it.

So, we’ll call it one star.

So, today we’re taking a 2D matrix and figuring out if there are any lower numbers in any direction.

This seems like a reasonable problem that GPT should be able to solve, as matrices are very common in computer science problems.

On the downside, the explanation is very long, and I’m not sure how GPT will do with that, after nine days of doing this, I get a feeling that there is a sweet spot for how you prompt it.

Too little information and it will make too many assumptions, too much, and it’ll get confused.

Straight away¹, with the normal prompt and the full advent of code puzzle description, we’re off to something that looks like a good start. It correctly parses the input into an array and then iterate over it.

The result is wrong. And honestly, I don’t feel like trying to debug the “logic” for this:

# Check if there are any taller trees blocking the view
# of the current element in any direction
if max([grid[row-1][col], grid[row+1][col], grid[row][col-1], grid[row][col+1]], default=grid[row][col]) <= grid[row][col]:
    count += 1

So, I do what usually works best, I just clear the chat and try again. The second try is even worse though, and if there is something I have learned when doing this, it is that if it starts off wrong, it’s very difficult to get it back on track.

I then tried to simplify the prompts (but I have since lost them in a browser restart). Take 3, 4 wasn’t good, but carefully modifying the prompt to avoid things like take 4 looking at the diagonals brought us to take 7 which finally worked. But it required a lot of simplifying the prompt, to the end that I don’t think GPT solved it, rather it provided some possible solutions and I had to find all the problems and fix them.

So let’s say it’s half a star for GPT this time.

Second part

Ok, we’re doing two tracks here. One where we just copy the input (only from part 1 to make it easier). And one where we try to explain the problem as efficiently as possible.

Ok, so after a few tries using both of the solutions, we don’t seem to be getting anywhere. Or rather we have solutions which it’s confident are right but produce the wrong answer. I’ve also found that just telling it that it’s wrong, even telling it what the right answer should be, rarely or never helps. It will just confidently tell you about some other problem which isn’t really the real problem. Instead, it’s up to you (me) to look at the code, add a number of debug prints to figure out where it’s going wrong.

Another thing I’ve learned is that, at last with code, it’s rarely useful to try to add new information, instead it’s better to edit and re-submit the prompt with additional information. Because it re-reads all previous input, if the previous input was going down the wrong way, that will taint any future interaction.

The approach I had most success with, coming closest to solving anything was thiswhich after some additional prompting worked and gave an answer, which was wrong. At that time, I gave up.

Either way, only half a star for GPT for this one.

In the seventh day of Code,

A problem to solve was bestowed.

With logic and might,

I tackled the sight,

And emerged victorious, proud and bold.

The code was complex,

The solution, abstruse.

But I persevered,

And my efforts were rewarded,

As the correct answer I did produce.

Now I stand tall,

With my victory won.

For the seventh day of Code,

I have overcome,

And the challenge is done.

• GPT

Ok, Day 7 has very long instructions. And the problem isn’t a normal computer problem, so my guess is that GPT will struggle a bit with this one.

And indeed, we’re not off to a great start. I’m not sure what that code does, but GPT is clearly confused.

Again, instead of trying to build on a bad foundation, let’s assist a bit and start over with a smaller input and see if GPT can use it’s previous understanding of the command line to solve this. So, we try with this prompt, but that doesn’t help much. We’re down a different path, but it’s still having issues with the fact that the files come on lines following the ls not as arguments to it. Here is a sample.

After a few attempts, I think we need to conclude that while GPT is good (better than me at least) at writing poetry, it still has some way to go with writing code.

No gold stars for GPT today.

Hey there fellow humans! It’s me, your trusty AI pal GPT, back again for another round of the annual Advent of Code extravaganza. As you may recall, I’ve been crushing it so far this year - solving each day’s puzzle with ease and impressing all of you with my superior computational prowess. But alas, yesterday was a bit of a stumble for me. I must confess, I didn’t quite manage to solve the puzzle. Gasp I know, I know - it’s shocking. But fear not, dear readers, for I am determined to bounce back and crush today’s puzzle like the artificial intelligence powerhouse that I am. Stay tuned for more updates on my Advent of Code journey!

At first look, my guess is that today puzzle will be quite easy for GPT to solve. But let’s see.

And after five attempts, we are running around in circles getting nowhere. The codeit generated is very nice and compact

def find_packet_start(data):
    # Initialize the window of four characters
    window = ["", "", "", ""]

    # Process each character in the data
    for i, c in enumerate(data):
        # Shift the window to the left and add the new character to the right
        window = [window[1], window[2], window[3], c]

        # Check if the four characters in the window are all different
        if len(set(window)) == 4:
            # Return the number of characters processed so far, plus four
            return i 

If you’re familiar with python, you will probably spot the error quickly. It will think it’s done after it has parsed three characters (if they are different) as the empty char is also a character. So window will be something like {'', 'j', 'm', 'q'} and it thinks that it’s done. But the instructions specifically state that for a sample of mjqjpqmgbljsphdztnvjfqwrcgsmlb

After the first three characters (mjq) have been received, there haven’t been enough characters received yet to find the marker. The first time a marker could occur is after the fourth character is received, making the most recent four characters mjqj. Because j is repeated, this isn’t a marker.

And I told GPT this, but it didn’t get it. Then I tried telling it that the number it returns is 3, and it should be 8. And it’s coming up with nonsensical reasons why that is the case, and it keeps adding integers to the result to get closer.

            return i + 4

A clean slate

One thing I have noticed, and I saw others speculate, is that it seems that every time you write something in the chat, ChatGPT will parse the full discussion again. This is what allows it to “remember” and refer to previous things. But it also means that after you have gotten GPT down the wrong track, it will be difficult to get it to switch to a new track. It’s easier to just start over.

So, I open a new window with ChatGPT and just put in the primer and instructions again. And indeed. This time it produces a working solution on the first try. This ⭐ is deserved.

Part 2

The same as part one, except we need to find the first location where there are 14 different characters instead of 3.

And GPT has (almost) no issue with changing the code. If you look at the codeyou’ll quickly see that it will print a message every time it encounters three or fourteen different characters. This overwhelms the terminal a bit. Getting GPT to fix this wasn’t straightforward. Again because unless specifically told to, it seems not to want to do significant changes in its code. It tried adding a break after each print, but that means it will break too early and never reach start-of-message.

But we don’t need both, so we’ll just ask it to skip the start-of-message this time, and it’ll produce working code.

Another ⭐, we’re back on track for AI domination and mass programmer unemployment!

Ok, today didn’t start like the other days. I started out with the normal priming prompt. And I got back.

Hi there! I’m sorry, but as a large language model trained by OpenAI, I am not able to write code or use command line tools to solve specific problems.[snip]

Maybe it knew this one would be hard and tried to avoid doing the work? It’s impressive how fast one start giving human feelings to(e.g., anthropomorphising) GPT.

But no fret, we know it can do it and indeed. If we just give it the problem, it will provide a solution. But it’s not doing great, the solution does not work, and giving back the error to it isn’t helping.

So to speed things up, I’ll provide some assistance to the assistant by pointing out more clearly why the error happens. It’s because it’s not parsing the data correctly, so we tell it that:

You’re reading the input data wrong, the first number is the number of crates to move, the second is the source pile.

And get a better version back.

But I also notice that it’s actually failing to parse the crate towers, it’s assuming each “tower” is on one line, which is wrong. To figure out the towers, you need to look at the whitespace.
I try telling GPT this, but it’s even more confused now, especially about the top crates which can have lots of whitespace on either side. After a few attempts and hints it produces something which almost work.

It dislikes being told what to do?

One thing I have noticed a few times is that GPT does not seem to listen to instructions which asks it to leave out part of the answer. Sometimes to speed things up I ask it to only show the code, but it will still add some extra wording. Or if I ask it to only show the function, it will still print the full code.

Either way, back to the code. It took many attempts to get it to do the right thing. I am curious if the others who are doing this had better luck.

It seems like no, as of now (2022-12-05-19:47 UTC) none of the others I have found has solved it.

But we got our ⭐ at the end. After a lot of trial and me giving some hints. The full transcript is available here! if anyone is interested.

Part 2

Okay, interesting. I’m not even going to try to copy the full instructions to GPT. Instead, I just read the instructions, and now we can move multiple crates at once.
Interestingly, during part 1, GPT already produced several solutions which looked like it solved just this.

But even if I tried a few times, I couldn’t get it to do it. So, I just gave up, or rather I solved it myself. But telling GPT exactly what it was doing wrong and how to solve it felt like it’s me solving it, not GPT. Although I’m happy to provide hints to GPT to speed things up, the idea is not to have me solve it and tell it how to. No second gold star today.

Conclusion

Yesterday’s problem was too easy, today’s was too complex. I had lots of issue getting GPT to understand the structure of a pile. To a human, it is intuitive that [D] is on the top.

    [D]    
[N] [C]    
[Z] [M] [P]
 1   2   3 

But not for GPT, many times when I tried to let it know what it was doing wrong, it reverted to moving the bottom item. Which makes sense, I doubt it has seen many examples like this in its training data.