1. 25

Feel free to tell what you plan on doing this weekend and even ask for help or feedback.

Please keep in mind it’s more than OK to do nothing at all too!

  1.  

  2. 24

    Driving then hours to attend funeral services for a friend I recently lost and to support the family (I basically grew up with all of them) for the week. :’(

    Life is short folks. Make the most of it.

    1. 8

      My condolences.

      1. 2

        Thanks.

    2. 17

      Gonna physically visit my 1U server in my buddy’s basement, reboot it, edit the kernel command line to include init=/bin/sh, remount / as rw, and update my user account’s password. I should remember to tote a monitor and keyboard over. Might as well have a beer while I’m there.

      1. 2

        Maybe install a serial-over-LAN box?

        1. 4

          How would you drink beer over LAN?

          1. 2

            I would not choose drinking beer over LAN. Not even the best brewery would make me switch.

            1. 3

              UPDATE: wow, such fail. :) First off, I just sat there and watched him play minecraft (connected to the server in his basement) for a few hours. When I finally got around to kicking him off and doing the init=/bin/sh thing, I discovered that the only USB keyboard we had doesn’t work in that mode… Despite it having worked perfectly in GRUB just moments before. Ok, the D-I CD was still sitting there from when we set the machine up. I booted into that, selected Rescue Mode, and started a shell–keyboard worked (of course), but the raid device wasn’t listed in /dev (also network configuration was failing). Then I remembered that we’d used firmware.tar.gz to set up this machine… So I say ‘You still got that USB stick?’ and he replies ‘Hold on, we’ve been trying this for longer than I tried to remember my password–get me back to a login prompt!’ … We get there and I see him try to log in with his username in all caps. …His username is actually lowercase! “Aaannnd we’re back!”. I use his sudo powers to change my password. Done. Beers were consumed (not necessarily in the same order that was originally implied).

              1. 1

                Glad to hear you’ve enjoyed this. Friends Windows PC died. GPU fried, Windows unrecoverable. No idea why. Well, lack of ventilation was the death of the GPU, but no clue on Windows. Would have preferred init=/bin/sh. I don’t enjoy supporting this platform.

      2. 17

        I just got my invitation for my citizenship test! The one that more than 80% of all Canadians flunk!

        So, I guess I’ll be studying for that.

        Progress this week on Tilerswift has been slow. I’ve started looking into some basic exception handling and it’s a bit of a complicated problem! PyQt doesn’t bubble into the main thread exceptions triggered from signals. There’s a couple of SO questions about this, and I also looked at how TortoiseHg handles the problem, and it looks complicated.

        Eh, my users might have to just deal with mysterious crashes whenever I mess up.

        Also, I really need to stop stalling and actually implement saving/loading the workspace and being able to edit tiles.

        1. 2

          Good luck on the test!

        2. 9

          Reading papers! Going to present one from Usenix Security this year at my graduate seminar class which is quite good, on how to do contact discovery for messaging without losing privacy using techniques that are only recently feasible on mobile phones: https://www.usenix.org/conference/usenixsecurity19/presentation/kales

          1. 9

            Getting out the chainsaws, inviting some younger members of the family over for a cookout, then downing a few trees in our backyard before feting them with burgers and beer. Should be fun.

            1. 9

              I’m glad you’re giving the trees burgers and beer after cutting them down 😉

              1. 7

                Fortunately they never eat a lot. I think something about the charcoal they find upsetting.

            2. 7

              Playing 2 shows in DC, running a 5K and going to a birthday. 1 show tonight livecoding with tidalcycles+modular synth in DC at spacycloud for a 90s hip hop thing, the other tomorrow playing a bass at a benefit for keep immigrant families together called ‘room for more’ at boundary stone. Then Sunday… probably picking things up and planning for the coming week.

              1. 7

                I hit a milestone on the side project I was hacking on all week, but now I want more. I want to self host the whole compiler from a single file, so I may spend some time working through some of that.

                Otherwise, yard work!

                1. 7

                  Writing up a blogpost on a conlang project I’ve been working on

                  1. 2

                    I’m also working on a conlang! What type of conlang it’s going to to be?

                    1. 2

                      This is part of a group effort on the conlang critic discord, but essentially we all worked together making a proto-language and then we’re gonna each evolve it to different things. I ended up doing a lot of the vocabulary building and fleshing it out into a (slightly) usable language. The vocabulary is very minimal at the moment (contains a superset of some common word lists we got from the duolingo forums), but it’s workable.

                      I’ve also been working on morphology checking tools and (eventually) an auto-glosser at https://github.com/Xe/mapatei.

                      My post is really gonna combine a lot of the notes together and make something close to a formal language description document.

                      My plans to evolve the language are to create a more latin-like grammar where the root words are modified for case and allowing for free word order (instead of the VSO (verb/subject/object) word order we’re playing with for the proto-langauge).

                  2. 6

                    Watching the Formula 1 Grand Prix in Singapore and having a great time with a friend.

                    1. 6

                      I’m implementing an applicative validation library. I know there are many others but lately I’ve been enjoying implementing stuff that already exists just to understand it. Wish I had more original ideas but this is fun too.

                      1. 6

                        Maybe going to write importer from my bank’s .csvs to hledger format.

                        1. 6

                          My company is switching to Kotlin for new code and services, so I might take a look at it.

                          1. 2

                            What were you using before?

                            1. 1

                              I would bet Java.

                          2. 6

                            I found the perfect meme about lobsters. https://i.imgur.com/j3kfYa2.png (source https://twitter.com/skeleton_claw)

                            This weekend I might try to remove the 21 frame rule limitation from Super Mario Brothers 1: https://www.youtube.com/watch?v=JCRKUuhGC1A

                            You can only gain or lose times in increments of 21 frames. This makes it much harder to speedrun the game. It’s like a bus arrives every 21 frames at the end of each level to take you to the next level.

                            The code is here: https://github.com/shawwn/super-mario-bros-build/blob/9d2e2d3e36e95c560860ecde4bafd0530a5ba8c1/SMBDIS.ASM

                            and you can build it by running make after cloning https://github.com/shawwn/super-mario-bros-build

                            I modded the game to let you only shoot 1 fireball at a time, but at 2x speed, just for fun. There are a lot of other things you can do, like change the logic so that every level plays like a water level, or turn on real physics in water levels.

                            But the 21 frame rule – that’s a huge mystery. There’s no obvious reason in the code for it. And there are endless things that seem like the reason, but aren’t.

                            My current hypothesis is that the 21 framerule is emergent behavior due to the structure of the code. There’s no constant like “check X every 20 frames”. It’s moreso like “here’s a list of tasks with 20 things in it, and one task runs each frame.” But finding out where it is happening and why is proving much harder than expected.

                            It’s like catnip for programmers if you want to try. Good luck.

                            1. 2

                              Be sure to write it up if you figure it out, I’d love to read about what’s going on there.

                            2. 5

                              Pub! - been away with work all week and am seriously missing sitting down and just talking to friends then rolling home to bed.

                              Sailing! - kids have youth squad, and then there’s the junior regatta happening. (End-ish of season races for juniors specifically.) Also whilst I’m at the club, trying to get my spinnaker setup correct on the FF - currently there’s a big mess of lines and it never sets properly. Going to put my boat alongside someone else’s with the same setup and see what I’ve rigged wrongly.

                              1. 5

                                Watching Scrubs for 6th time and drive 150km to my wife’s granny to congratulate her with her 80. Finally finish pragmatic programmer anniversary edition.

                                1. 4

                                  Writing a FreeBSD TPM driver for the Cr50 (Google Security Chip). Which is mostly just hooking up i2c transport (ugh, why is this cursed bus from 1982 gaining popularity these days?!) and handling quirks of the chip, the TPM core driver already exists. Simple commands (those that don’t read more data than one burst) already work.

                                  Maybe also writing blog post about the computers I’ve acquired and put FreeBSD on over the summer :)

                                  1. 4

                                    I broke my right clavicle in a motorcycle crash about 4 weeks ago so I’m going to try to shoot clay pigeons left-handed. I expect to make a lot of noise with very little result, but it should be fun!

                                    1. 4

                                      Working on building my startup (a messaging app/alternative to the panopticon social media giants). Trying to figure out how to get the messaging right, get people to sign up and try it out, while also making the product work flawlessly.

                                      1. 4

                                        If you want to really differentiate, implement what’s discussed in the paper linked in my comment on this thread for contact discovery. It’s a new level of privacy that not even the folks at Signal and similar are achieving right now

                                        1. 3

                                          That’s really interesting, thanks for pointing it out. Contact discovery is definitely something tricky and we haven’t even tried to do it yet because of the obvious privacy/security issues.

                                          If you’re interested in chatting more about this, I’d love to talk to you. brenden@umpyre.com

                                          1. 2

                                            The on-line phase of our fastest protocol takes only 2.92s

                                            I’m not knocking your protocol; keep up the good work!

                                            But… I’ll happily knock your presentation style. [UPDATE: If I were the author, I’d like to think I’d do some things differently:] It’s fine to differentiate the setup-phase from the online-phase, etc, down in the meat of the paper, but it seems a bit disingenuous to bury the durations of the other phases (one of which is a different order of magnitude) and not present the total-end-to-end time at all. Also, I don’t have 1gb free except on SD card, and writing to that is slower than wifi…

                                            1. 2

                                              Not my paper! I wish it was :)

                                              These are absolutely valid criticisms. I appreciate that the authors show a table of how they fall short of requirements for real messaging applications.

                                        2. 4

                                          Going to Republic of Artsakh to participate at wine festival, maybe dance Armenian folks a bit. will take my laptop with me to blog a bit about Internet Politics in the country and smoke a cigar. Perfect timing to do some photography using my Nikon N2000 (given as gift by my mentor @norayr).

                                          1. 2

                                            Republic of Artsakh

                                            I had to google this one. Who do I piss off if I keep calling it Nagorno-Karabakh?

                                            1. 2

                                              haha! good one! most people here call it Karabakh unofficially. So technically just official people :)

                                          2. 4

                                            Gonna code new WordPress theme for one of my clients to supply my budget before vacations. As I like go learn something new on every job this time I’ll try some more back to basics approach to make site modern but as lightweight and as simple as it can be.

                                            1. 4

                                              I’m working on an astrophysics simulation! My friend is a postdoc doing theoretical astrophysics, and he recruited me to help him with a simulation. We experimented with a version that used multiprocessing to do some of the computation in parallel, but abandoned that idea for the “production” version. I’m still tinkering on that as an exercise in learning how to profile, optimize algorithms, etc.

                                              The tricky part about this simulation is that some of it needs to run sequentially and some of it can be done in parallel. I currently have a main process and a bunch of worker processes that use Events to communicate when the parallel part should start and when the sequential part (which happens in the main process) should resume. It’s not very efficient because the execution time of each time step is limited by the slowest worker process (each worker is modeling a different physical process), so there’s a lot of CPU time spent doing absolutely nothing.

                                              1. 4

                                                Tomorrow I plan to finish my first real CUDA GPU application. I’m 95% there, just need to clean up some indexing and benchmark it. I’d be done by now if not for a 6 hour power outage yesterday. I’ll be watching some college football starting around noon tomorrow, so that will be a good time to launch some test processes.

                                                On Sunday morning, I have my last half marathon of the year. Only one more race in my series after that, and its a 10 miler.

                                                Also, I’m continuing to cat-sit and house-sit for my girlfriend while she’s travelling for work.

                                                1. 4

                                                  Planning to spend some time thinking more about a PL concept I have been toying around with in my head for the last couple of weeks. I’ve been very inspired by Terra to build a multistage PL environment which allows you to define new languages in an embedded fashion. I really like Terra, but I feel like it doesn’t go nearly far enough with it’s metaprogramming concepts, and while you can do a lot of amazing things with it, there are a number of languages which are impossible to define in an efficient way. For instance, you can do things like extend Lua with pattern matching, but you can’t add new statement types to Lua without an extreme computational overhead (and great deal of pain in the implementation). Thinking down this road has brought me back full circle to a paper I read a couple of years ago and loved but didn’t have an immediate use for, the FunTAL paper (https://arxiv.org/abs/1711.03871). Current line of thinking is that one could extend something like TAL with multistage metaprogramming in the style of Terra (TAL being to this PL what Lua is to Terra), and if the design is right, that could enable defining Fun from inside of this TAL extension. Hoping this line of thinking will lead me to a design that allows many interesting kinds of languages to be defined in this PL besides just Fun. More info than this in my head right now, but I want to take some time this weekend to do some more research and formalize my thoughts some more to see if what I’m thinking about is even remotely possible (in the sense that a system like this can be designed to be decidable).

                                                  1. 4

                                                    Working through “Practical TLA+”.

                                                    1. 4

                                                      I will donate 22 grocery bags of books to Goodwill.

                                                      1. 1

                                                        Cleaning out the shelves, eh?

                                                        1. 2

                                                          Yes, every book that is available on Kindle is a candidate for donation. It’s a simple rule that avoids most decisions.

                                                      2. 4

                                                        gonna do some raids in final fantasy xiv with some pals, and recover from jetlag (hopefully)

                                                        1. 3

                                                          Helping my sister move into her new place.

                                                          1. 3

                                                            Reading Reinforcement Learning: an introduction! :)

                                                            1. 3

                                                              Absolutely nothing that will stress me out this weekend (except for the gym, where I hope to stress out various muscles, lol). Maybe some chores I’ve had pending, but nothing major. Definitely grilling tonight, weather permitting.

                                                              I did meet up with a friend yesterday for a quick Happy Hour Meetup and then headed home, where I decided to work on getting an Airport Extreme card finally working on a Power Mac G5. Now, I just have to clean out the dust inside it.

                                                              1. 1

                                                                OK, so I actually did something else. Used curl and jq to grab a stream from a json file and used sed to edit the playlist entry for Telefe on the Raspberry Pi 2 running OSMC I set up for my dad (he’s in his mid 70s). Automated the script with all of this via a cron job so it updates the stream link daily. This way, there’s little to no interruption to his viewing (and he gets the direct stream from Argentina, not the show programming for USA).

                                                              2. 3

                                                                Flying to Houston, meeting my boss and my teammates. First time in the USA for me

                                                                1. 3

                                                                  IKEA

                                                                  1. 3

                                                                    Labor… clearing the piles of timber the previous owner left behind on the property behind the house (not the only thing the previous owner half-assed). Chainsaw, bow saw, axe, maul, sledge hammer. It’s going to be firewood or compost depending on condition.

                                                                    1. 3

                                                                      Studying Encryption for my CISSP test in November.

                                                                      1. 1

                                                                        Is a corporate sponsor still required for this certification? I studied for this exam 18 years ago but my employer refused to sign a form stating their support, so I couldn’t register for the exam.

                                                                      2. 3

                                                                        Trying to add undo/redo (“xdo”) to my personal information manager, written in Common Lisp. Currently, the tool immediately writes changes to disk, which has the potential for several different kinds of catastrophic data loss.

                                                                        1. 1

                                                                          Are you going to “just” put an abstraction layer between the data and the program? Like maybe one where the “HEAD” concept from git plays a crucial role? …That’s my hot take on the problem you described briefly. :)

                                                                          (Yes, it’s just a pointer and the concept didn’t originate with git/Linus.)

                                                                          1. 1

                                                                            Would you mind elaborating? I’m afraid that I don’t understand git (HEAD) well enough to grasp your idea…

                                                                            1. 1

                                                                              Ok, forget git. Like I said, the concept didn’t originate there.

                                                                              I thought it would be cool if I wrote out a little shell script that implemented the concept–and it should only take ten minutes!

                                                                              Several hours later… :) (granted, most of the day was devoted to real work!)

                                                                              The biggest bug is that you can do the sequence “update, update, update, undo, undo, update, redo” and end up with the third “update” as your current state… Which is non-sense, if you view “xdo” as a type of time-travel. (Solution: wipe out any versions greater than current whenever you do “update”. But I don’t like this solution.)

                                                                              The other biggest bug is that “update” after at least one “undo” destroys history. One solution would be to go the route git (and others) took: make this demo tool store versions in content addressable storage. What’s weird is that for this use case, that’s kinda not too difficult? (See above re: “ten minutes”…)

                                                                              What does CAS mean for this? In the current iteration of the tool, the value of “current version (number)” is used as filename. We could call that ‘version addressable’. If we were to make the “current version” be a hash of the “current word” instead, we could keep every distinct version of “xdo” data around forever (barring hash collisions)–because every distinct “word” (content) would get a distinct filename. With that done, all we’d need to do is make some kind of DAG to store the “undo/redo/update” relationships between each “version” or “revision”. …Maybe that means storing PARENT along with HEAD? I dunno, but any given “how git works” document will explain one way to do it.

                                                                              I switched to ‘we’ at some point during writing the paragraphs above, without noticing myself, because I have stopped thinking of this as my script. I’m done with it; at least done with the shell script version of it?

                                                                              Anyway, here’s the script. It’s supposed to be self-documenting… BUT it will fail to do that if POSIX shell scripts are utterly novel to the reader.

                                                                              #!/bin/sh
                                                                              
                                                                              #set -x
                                                                              
                                                                              function usage {
                                                                                echo Usage: ./demo COMMAND [WORD]
                                                                                echo
                                                                                echo COMMAND must be one of these: update, read, undo, or redo.
                                                                                echo The "'update'" command takes one argument, a "shell word".
                                                                                echo The other three commands do not take any arguments.
                                                                                echo
                                                                                echo All the commands except "'read'" alter state on disk, so,
                                                                                echo "  repeated invocations will return varying results."
                                                                                echo Examples:
                                                                                echo "    ./demo update foo"
                                                                                echo "    ./demo read"
                                                                                echo "    ./demo update bar"
                                                                                echo "    ./demo read"
                                                                                echo "    ./demo undo"
                                                                                echo "    ./demo redo"
                                                                              }
                                                                              
                                                                              function sanity_check {
                                                                                if [[ ! -s HEAD ]]
                                                                                  then
                                                                                    echo "Not initialized.  Invoke 'update' command first, see documentation:"
                                                                                    echo
                                                                                    usage
                                                                                    exit 1
                                                                                fi
                                                                              }
                                                                              
                                                                              function read {
                                                                                sanity_check
                                                                                current_version=$(cat HEAD)
                                                                                echo current_version=$current_version
                                                                                echo current_word=$(cat $current_version)
                                                                              }
                                                                              
                                                                              function update {
                                                                                if [[ $# != 2 ]]; then usage; exit 1; fi
                                                                              
                                                                                # -s means if file exists and is has size greater than 0
                                                                                # fi just marks the end of this "compound command"
                                                                                if [[ -s HEAD ]]
                                                                                then
                                                                                  old_version=$(cat HEAD)
                                                                                  echo old_version=$old_version
                                                                                  echo old_word=$(cat $old_version)
                                                                              
                                                                                  let "new_version = old_version + 1"
                                                                                  echo new_version=$new_version
                                                                              
                                                                                  new_word=$2
                                                                                  echo new_word=$new_word
                                                                              
                                                                                  echo $new_word > $new_version
                                                                                  echo $new_version > HEAD
                                                                                else #this is initialization
                                                                                  echo new_version=1
                                                                                  echo 1 > HEAD
                                                                                  echo new_word=$2
                                                                                  echo $2 > 1
                                                                                fi
                                                                              }
                                                                              
                                                                              function undo {
                                                                                sanity_check
                                                                              
                                                                                old_version=$(cat HEAD)
                                                                                echo old_version=$old_version
                                                                                echo old_word=$(cat $old_version)
                                                                              
                                                                                let "new_version = old_version - 1"
                                                                              
                                                                                if [[ ! -s $new_version ]]
                                                                                then
                                                                                  echo ERROR. No previous version.
                                                                                  exit 1
                                                                                fi
                                                                              
                                                                                echo new_version=$new_version
                                                                                echo new_word=$(cat $new_version)
                                                                              
                                                                                echo $new_version > HEAD
                                                                              }
                                                                              
                                                                              function redo {
                                                                                sanity_check
                                                                              
                                                                                old_version=$(cat HEAD)
                                                                                echo old_version=$old_version
                                                                                echo old_word=$(cat $old_version)
                                                                              
                                                                                let "new_version = old_version + 1"
                                                                              
                                                                                if [[ ! -s $new_version ]]
                                                                                then
                                                                                  echo ERROR. No next version.
                                                                                  exit 1
                                                                                fi
                                                                              
                                                                                echo new_version=$new_version
                                                                                echo new_word=$(cat $new_version)
                                                                              
                                                                                echo $new_version > HEAD
                                                                              }
                                                                              
                                                                              case $1 in
                                                                                update) update $1 $2;;
                                                                                read)   read;;
                                                                                undo)   undo;;
                                                                                redo)   redo;;
                                                                                *)      usage;;
                                                                              esac
                                                                              
                                                                              ## resources I consulted while writing the above:
                                                                              # https://www.ibm.com/support/knowledgecenter/en/ssw_aix_72/osmanagement/korn_shell.html
                                                                              # http://hyperpolyglot.org/shell#if-note
                                                                              # https://stackoverflow.com/questions/7427262/how-to-read-a-file-into-a-variable-in-shell
                                                                              
                                                                              1. 1

                                                                                If I understand this correctly, this is basically just implementing git. Conceptually, yes, xdo and revision control are identical. However, the “master” for data for my tool lives in memory. The disk just persists the master - if there’s a conflict between memory and disk, the data in memory is authoritative. Additionally, implementation strategies for xdo for data on disk and in memory are very different, and it’s the integration of the xdo code with the existing code that’s proving challenging (in addition to my desire to nondestructively integrate changes to data on disk with changes to stuff in memory).

                                                                                1. 1

                                                                                  No, this doesn’t implement git. Not even close. Sorry, I babbled about git a lot, but, that wasn’t meant to suggest that this shell script does what git does. ..my bad. :(

                                                                                  Here’s a demo:

                                                                                  I delete all the files except the script and start over:

                                                                                  sebboh@geeks ~/projects/HEAD$ rm HEAD ?
                                                                                  sebboh@geeks ~/projects/HEAD$ ls -al
                                                                                  total 4
                                                                                  drwxr-xr-x 1 sebboh users    8 Sep 24 18:31 ./
                                                                                  drwxr-xr-x 1 sebboh  1000  220 Sep 24 12:34 ../
                                                                                  -rwxr-xr-x 1 sebboh users 2621 Sep 24 16:40 demo
                                                                                  

                                                                                  Now I invoke some command. The tool complains that it is not initialized…

                                                                                  sebboh@geeks ~/projects/HEAD$ ./demo undo
                                                                                  Not initialized.  Invoke 'update' command first, see documentation:
                                                                                  [...extra lines snipped out...]
                                                                                  

                                                                                  Ok, I follow that advice and call update and I’ll give it some data. This could be the data for your tool, suppose.

                                                                                  sebboh@geeks ~/projects/HEAD$ ./demo update this-is-some-data
                                                                                  new_version=1
                                                                                  new_word=this-is-some-data
                                                                                  

                                                                                  What did that do? It created two new files in this directory.

                                                                                  sebboh@geeks ~/projects/HEAD$ ls -al
                                                                                  total 12
                                                                                  drwxr-xr-x 1 sebboh users   18 Sep 24 18:32 ./
                                                                                  drwxr-xr-x 1 sebboh  1000  220 Sep 24 12:34 ../
                                                                                  -rw-r--r-- 1 sebboh users   18 Sep 24 18:32 1
                                                                                  -rwxr-xr-x 1 sebboh users 2621 Sep 24 16:40 demo
                                                                                  -rw-r--r-- 1 sebboh users    2 Sep 24 18:32 HEAD
                                                                                  

                                                                                  The files have contents:

                                                                                  sebboh@geeks ~/projects/HEAD$ cat 1
                                                                                  this-is-some-data
                                                                                  sebboh@geeks ~/projects/HEAD$ cat HEAD
                                                                                  1
                                                                                  

                                                                                  Ok, suppose I do some work. Now we have new data. Let’s save that, but, also save the old version, in case I want to perform undo.

                                                                                  sebboh@geeks ~/projects/HEAD$ ./demo update new-data
                                                                                  old_version=1
                                                                                  old_word=this-is-some-data
                                                                                  new_version=2
                                                                                  new_word=new-data
                                                                                  

                                                                                  How was this done? In a naive way.. we just have an extra file now. The original file named 1 is still there and still has the old data. The new file is named 2 and it has the new data. The contents of HEAD is just the number 2, so the program knows which data file to look at. For example, if we do a read right now, the program will check HEAD so it knows which data file to load.

                                                                                  sebboh@geeks ~/projects/HEAD$ ls -al
                                                                                  total 16
                                                                                  drwxr-xr-x 1 sebboh users   20 Sep 24 18:33 ./
                                                                                  drwxr-xr-x 1 sebboh  1000  220 Sep 24 12:34 ../
                                                                                  -rw-r--r-- 1 sebboh users   18 Sep 24 18:32 1
                                                                                  -rw-r--r-- 1 sebboh users    9 Sep 24 18:33 2
                                                                                  -rwxr-xr-x 1 sebboh users 2621 Sep 24 16:40 demo
                                                                                  -rw-r--r-- 1 sebboh users    2 Sep 24 18:33 HEAD
                                                                                  sebboh@geeks ~/projects/HEAD$ cat 2
                                                                                  new-data
                                                                                  sebboh@geeks ~/projects/HEAD$ cat HEAD
                                                                                  2
                                                                                  

                                                                                  Ok, I don’t like version 2. I want to undo.

                                                                                  sebboh@geeks ~/projects/HEAD$ ./demo undo
                                                                                  old_version=2
                                                                                  old_word=new-data
                                                                                  new_version=1
                                                                                  new_word=this-is-some-data
                                                                                  

                                                                                  The same files are there..

                                                                                  sebboh@geeks ~/projects/HEAD$ ls -al
                                                                                  total 16
                                                                                  drwxr-xr-x 1 sebboh users   20 Sep 24 18:33 ./
                                                                                  drwxr-xr-x 1 sebboh  1000  220 Sep 24 12:34 ../
                                                                                  -rw-r--r-- 1 sebboh users   18 Sep 24 18:32 1
                                                                                  -rw-r--r-- 1 sebboh users    9 Sep 24 18:33 2
                                                                                  -rwxr-xr-x 1 sebboh users 2621 Sep 24 16:40 demo
                                                                                  -rw-r--r-- 1 sebboh users    2 Sep 24 18:33 HEAD
                                                                                  

                                                                                  But the contents of HEAD changed.

                                                                                  sebboh@geeks ~/projects/HEAD$ cat HEAD
                                                                                  1
                                                                                  

                                                                                  So, when we do a read, we get the old version.

                                                                                  sebboh@geeks ~/projects/HEAD$ ./demo read
                                                                                  current_version=1
                                                                                  current_word=this-is-some-data
                                                                                  sebboh@geeks ~/projects/HEAD$
                                                                                  

                                                                                  redo is also implemented.

                                                                                  sebboh@geeks ~/projects/HEAD$ ./demo redo
                                                                                  old_version=1
                                                                                  old_word=this-is-some-data
                                                                                  new_version=2
                                                                                  new_word=new-data
                                                                                  sebboh@geeks ~/projects/HEAD$ ./demo read
                                                                                  current_version=2
                                                                                  current_word=new-data
                                                                                  sebboh@geeks ~/projects/HEAD$
                                                                                  
                                                                        2. 3

                                                                          I’m going to update my personal website with NextJS, possibly add static blog generator (or a DB).

                                                                          1. 3

                                                                            I got tired of having my notes and drafts spread between all my devices, so I’m building a quick webapp/PWA (for offline capability) this weekend, with the usual note-taking functionality. Also, encryption, if I can manage it.

                                                                            1. 3

                                                                              I haven’t been hiking in a while, so I’m going to go. Not sure where yet, but probably somewhere within 100 miles of Boulder. Now that I think about it, I might find something within biking distance and make a whole weekend out of it

                                                                              Would also like to get some reading in.

                                                                              1. 3

                                                                                I’m going to hack a bit more on my local-first social media prototype.

                                                                                It can currently publish files via SSH (rsync) and WebDAV, but I’d like to have it support writing to S3 buckets as well. I think that will open up the space more for people who have little tech experience and/or money—because it’s a bit easier to offer space on an S3 bucket than to run your own SSH + HTTP or WebDAV server.

                                                                                (Plus, rsync isn’t compatible with incremental publishing, so I might have to drop that protocol entirely for now. :-/)

                                                                                1. 3
                                                                                  • Setting up a PiHole!
                                                                                  • Working on an iOS app for a side project.
                                                                                  • I got a bike with clipless pedals last weekend. I now need to go figure out how to use clipless pedals.
                                                                                  1. 3

                                                                                    Taking my daughter to the aquarium and finding some time for a couple of mountain biking sessions