wmitty's comments

One of the most memorable cycle touring blogs I have read is of Bill St Onge's tour down this road.

In addition to the natural difficulty of cycling this extremely remote road (both ways), he was dousing himself in so much bug repellent that his heart was constantly racing (he thought he was going to have a heart attack) and he was hallucinating (IIRC) a giant bear that was stalking him.

He has taken the blog down, so I can't link it - presumably because he has published a book - https://www.amazon.com/Cycling-Quebecs-Trans-Taiga-Road-Wild...

OP says the US portion of eastern divide trail, which is on bikepacking.com :

https://bikepacking.com/eastern-divide-trail/

A major factor was that early Java in the browser did not support.jar (really .zip) files. This meant every class (and every inner class) required a separate http request (on the much slower http of the day).

You used to have to put everything in one giant class to work around this.

(This situation was so frustrating)

Brave has written their own (open source) adblock engine (in rust) that is directly integrated into the browser (ie. not an extension, so is not affected by Manifest V3).

https://github.com/brave/adblock-rust

Here is a (somewhat dated) article describing it by the authors:

https://brave.com/improved-ad-blocker-performance/

The article wasn't entirely condescending - sometimes it was patronizing instead.

As long as you have access to a phillips screwdriver, you aren't stuck in the little ring - you can tighten the high limit screw to pick your one gear (at least from the higher ones).

Laplink had a really neat feature for when you didn't have your laplink install disk with you (or had the wrong size laplink install disk).

You could connect the two computers with a RS232 null modem cable, then type something like the following on the target computer:

mode COM1:2400,n,8,1,p

ctty COM1

This redirected the input/output for the terminal to the serial port.

Laplink on the source computer would then 'type' a series of console commands to create a simple transfer program on the target computer. It would use this simple transfer program to transfer the full laplink.

IIRC it used the msdos DEBUG.COM to build the transfer program on the target computer (but this is an old memory, so could easily be a reconstruction).

Composing this message is bringing back lots of weird memories about how we used to compute before the internet.

My (crude) version of the same thing requires that I go 1000 meters from my house to press the button to enable the DNS for another 30 min of browsing (button is on a custom phone app, distance measured using phone GPS).

One feature that I want to implement is to have the system randomly enable for 10 minutes - and to signal this by changing the color of light from a desk lamp (Phillips Hue). The idea is that when this happens, I would drop what I was doing and leap for my phone to get some bonus browsing in. Me being controlled by the system like this might be fun?, or at least illustrate something?

The website says that he uses:

"Xitami web server, because it's the only one that does no caching at all, so the website is always served fresh from the floppy."

Source: https://web.archive.org/web/20220120092324/https://old.bigca...

They tell all the Canadian banks and financial institutions that they have to ask all customers whether they are US citizens (and you lose account access if you won't answer).

The Canadian banks then have to report all the accounts of US citizens to the US gov. The banks comply with all this because otherwise they get super nasty fines against their us operations.

Also: they tell you that if you come in under the amnesty program (like I did) that their will be no big penalties - but if you wait until the amnesty program expires - and they then find you - they will treat you like a criminal.

I was born in the US to Canadian parents who promptly moved back to Canada where I have lived for the subsequent 55 years. Other than a US birth certificate I had no interaction with the US gov - we politely ignored eachother like a huge number of Canadians in the same situation. The informal status quo was that we both acted as if the "US citizenship by birth in the US" thing had not happened.

Until a few years ago when the US gov declared that I would be a criminal unless I became a full fledged US citizen. They also made this as difficult, expensive, confusing and time consuming as possible. For example having to find some paper documentation that is was living in Canada in 1967 etc. Huge costs - all of it going to specialist accountants - none to the IRS. And a huge complicated ongoing burden.

I am not even allowed to renounce until I have gone through this charade for a few years.

What has the US got out of this? They have processed lots of paperwork on my behalf and they have sent me some (unsolicited) stimulus checks which paid a tiny portion for the (Canadian) accountant fees they have saddled me with.

I mean the postgres parser (and semantic changes) for ZetaSQL. The zetasql parser is in a file called zetasql/parser/bison_parser.y, I strongly suspect they now have a file called something like zetasql/pgparser/bison_parser.y as well (and much more pervasive changes to support the deeper differences in the dialects).

This is the lexical structure and syntax docs for the new postgres inteface to cloud spanner:

https://cloud.google.com/spanner/docs/postgresql/lexical

And this is the zetasql lexical structure and syntax docs:

https://github.com/google/zetasql/blob/master/docs/lexical.m...

Notice that the new PG docs are an edit of the Zeta ones - evidence that my hypothesis is correct.

The Cloud Spanner SQL frontend/analyzer has been open sourced by google as ZetaSQL. https://github.com/google/zetasql

It is amazingly good.

You give it textual SQL (+ schema + all your function definitions) and it returns a really clean logical query plan. It is also happy to do this via a protobufs so you can use it from languages other than C++. It is also tested and documented up the wazoo. It has been such a pleasure to work with.

Anyway, the big problem with ZetaSQL is that it is not a common SQL dialect.

It seems that the only reasonable way to do this PostgreSQL interface for Cloud Spanner is to add a second parser (and other extensions) to ZetaSQL. If I am correct, I really really hope they open source that part of ZetaSQL as well - it would be a massive step forward for open source SQL tooling.

> Their adblocker is just a fork of uBlock Origin,

This does not appear to be true. Here is the github repo for their open source adblock engine written in rust:

https://github.com/brave/adblock-rust

Here is a (somewhat dated) article describing it by the authors:

https://brave.com/improved-ad-blocker-performance/

> Google will take decisions that benefit their advertisement business, like making impossible to use adblockers on any Chromium based browser.

Because the brave adblocker is integrated directly into the browser (ie. not an extension) the Manifest V3 limitations don't apply.

I made a (much less fancy) rowing machine program in 1984 (for the original Concept II).

It was written in 6502 assembly language for the Apple II.

It had a really nice display:

- 2 boats, with oars moving timed to your pulls - scrolling scenery - stroke power graphs - odometers that rolled over like mechanical odometers.

I had a piece of tinfoil taped to the wheel on the concept II. There was an aluminum box divided in two with a flashlight bulb on one side and a photocell on the other. When the tinfoil passed under the alumium box the photocell resistance would change, which would be available to the program via a wirewrapped expansion board (that also gave the Apple II 60hz interrupts - a native Apple II has no timer or interrupt controller). I later saw a Cateye magnetic bicyle wheel sensor and felt like such an idiot.

It also had an integrated breakout game that was controlled by the difference in power between the two rowers. Because of how one wrote games in that day (often directly using screen memory as data), if the ball ever escaped the brickout playfield it would start colliding with (and corrupting) other things on the screen, and if it ever left the screen, with random bits of executable code.

When you got a high score on a 20 min row, I had an army surplus air raid siren that would spin up. The idea was that after you completely killed youself on the erg, you would then have to run like crazy to avoid getting deafened by an air raid siren in a small room (thankfully this last part never worked well). A very high school idea.

Details from sciencemag.org (A magazine from the American academy for the advancement of science):

https://www.sciencemag.org/news/2020/02/united-states-badly-...

The link to the paper in the article requires an ACM subscription. Here is a link to the version hosted by the authors:

https://www.pdl.cmu.edu/PDL-FTP/Storage/ceph-exp-sosp19.pdf

Another crazy excellent (and free) ES6 reference is http://exploringjs.com/es6/ by Dr. Axel Rauschmayer - one of the ES6 committee members.

JS is a very complicated language - and the language spec in written in a way - that while I am sure is excellent for implementors and compatibility - is pretty much unreadable by language users.

Axel's book is quite authoritative and very readable. You may still go to the spec for finer points - but it sure is 10,000 times easier if you mostly understand the mechanism (and motivations) first.

Datahand palm rests detach really easily and come out of the dishwasher super clean.

A network effect applies to revision control systems.

Mercurial is a much better fit for how my mind works than Git (I feel that Git is from the school that thrives despite complexity, where I prefer the school that puts lots of effort into a really clean model to minimize complexity).

But I am now giving up on Mercurial: every open source project I play with is on github, so I absolutely need to master Git - and I don't want to keep using two systems.

The network effect wins.