benburwell

Some examples of flights without schedules:

- A private pilot who departs their local airport without filing a flight plan and flies around for a while.

- A charter jet that departs whenever the passengers show up.

- A medevac helicopter departs a hospital to return to its base. While en route, it is rerouted by dispatch to pick up a patient at a different hospital.

This is still very much the case. Although most new code is written in other languages, Tcl still has a substantial presence.

In general, this is actually done: there are defect detectors that are installed along tracks that monitor for several conditions as trains pass over/through them. Once the train has passed, a voice radio message is sent to the train crew.

Here's an example of one working: https://www.youtube.com/watch?v=R7BGg82uQ1U

I'm not sure whether similar equipment was a factor in the East Palestine incident.

I wrote about how I decrypt TLS streams in Wireshark for debugging purposes here: https://www.benburwell.com/posts/intercepting-golang-tls-wit...

It won't apply to every situation, but might provide some building blocks you can adapt to your environment.

The article mentions a takedown notice they received from GitHub instructing them on how to remove certain content from their repo. I'm guessing maybe this PR contains some of that content they were asked to remove, and there's a bug in GitHub when rendering a pull request page that references deleted content?

How useful is this in practice though?

I'd guess that far greater than 99% of the people using (most) products do not have perfectly color calibrated monitors. If it doesn't look good on the developer's "kinda close" monitors, that seems like a decent indication that the design needs to be updated to allow for "rougher tolerances" so to speak.

I really want to like GitHub Actions. But it feels like every time I'm trying to get something done, they are broken.

I also made something similar for Boston: https://mbta.benburwell.com

Mine doesn't show the routes. Originally it did, but it was too visually busy. I like the way you did it where the route shows up when you select a vehicle!

Your "state of the art" Go code is not really a good example of how that functionality would be written.

If you want to check for a specific error condition, then just define a value for that error and use `errors.Is` to check for it. This works as you'd expect with wrapping: https://go.dev/play/p/rJIlKKSYn9Q

> With the current go error handling, you need to add the informations yourself in the string, not as a real data structure.

This is completely false! If you want to provide a structured error, then you just need to define a type for it. In your example, a Go programmer might use errors.Is(err, fs.ErrNotExist) and errors.As if they wanted to retrieve the specific file path that does not exist in a strongly-typed way, something like https://go.dev/play/p/hdHPLAVbQuW.

> Delegating error handling to a try/catch block with a typed data structure allows the caller to care for certain type of errors and delegate the others to its own caller. With the current error type in Go, what would you do? parse the error message?

Certainly not! I think there is a misconception that "an error is a string" -- in Go, an error is actually any type that satisfies the error interface, i.e. has an `Error() string` method. It can be any type at all, and have as many other methods as you like in order to provide the functionality you need.

> what if the function is defined in a dependency you have no control over?

There's nothing stopping you from writing `throw new Exception(String.format("file not found: %s", filename))` in languages with exceptions either. In both cases, it would be recognized as poor API design.

Regarding stack traces, Go makes a strong distinction between errors (generally a deviation from the happy path) and panics (a true programming error, e.g. nil pointer dereference, where the program must exit). Errors do not provide stack traces since there is no need for them in a flow control context, panics do provide stack traces for useful debugging information.

Cool! I was expecting to see this implemented with the go/ast package, but I guess gofmt makes this easy enough to parse out by just matching lines.

Thanks! Hmm, that is odd. I'm currently seeing a few RL trains, but not as many as I'd expect... perhaps I've got a bug in processing the data somewhere.

Edit: Actually, it's probably due to the derailment: https://www.reddit.com/r/boston/comments/px7zii/heads_up_t_i...

Hi HN! I wanted a way to visualize the MBTA system as a whole, so I hacked this together over the weekend.

It shows the current position of each bus, train, and subway, including a little tail behind each vehicle to show where it's been.

There are plenty of rider-focused experiences built around this data but I'm more interested in the visual aspect of being able to look at the whole thing at once. It's probably not a very practical tool for riders!

Wouldn't clients then only become aware that they need to replace their certs after they've been revoked?

I think the desire here would be for a mechanism to alert clients to obtain a new certificate before their current certificate is revoked and becomes invalid.

edit: formatting

As a Go programmer, it doesn't really seem that notable or surprising to me that Go isn't considered the best language to use for implementing an operating system.

Of course it is their responsibility to take it back.

Suppose I order a watering can from the garden supply store. When I get home from work, I discover that instead of a watering can, they've delivered 2 tons of mulch in a giant pile in my driveway.

I'm not sure how you could make the argument that it's now my responsibility to get rid of the mulch that I didn't want or ask for?

This is how it works in most areas. Mobile calls to 911 will go to the PSAP for a relatively large region, who will triage the call and if your address is in an area served by a more local PSAP, they will add a calltaker from the local PSAP to the line and transfer the call to them.

It's probably best to just stick with 911. That's what calltakers are used to, and trying to route around 911 means you won't get the advantages built into that system (like priority handling, mapping, etc).

This is the MOTD when connecting: https://i.imgur.com/A8XP0eK.png

Larry Lessig agrees: https://en.wikipedia.org/wiki/Code_and_Other_Laws_of_Cybersp...