deltaknight

There are suspicions that German energy policy was effectively controlled/influenced by Russia in the early 2000s.

E.g the ex chancellor is now paid handsomely https://www.nytimes.com/2022/04/23/world/europe/schroder-ger...

I believe more recently there was an expose about some other politicians at that time having links to Russia, although don’t have them to hand right now.

This information comes from the card issuer directly, after the transaction has completed. It usually requires the mobile banking app to be installed.

The wallet app has a way to get the information, but it’s not from the tap itself. The tap interaction is not able to provide this information back to the phone (because the transaction auth happens long after the tap interaction completes).

Taps are designed to work with fully offline devices (which is why you can tap a plastic card, it is powered by the card terminal for the duration of the tap only, and requires no online interaction)

Honestly I wouldn’t take that too seriously, I think the whole triplet “not A, not B, not C” has been extremely common when talking about problems people are passionate about, and it’s a shame that crappy AI prose has trained people to treat it as a marker of AI. But it’s a exactly because that was effective in popular texts that AI has picked it up.

As long as the post isn’t this repeated 15 times like an AI would, just write how you want to write and most people will like it just fine. It’s a shame that we have to tone ourselves down nowadays.

This looks super cool, I’ve played around with making custom API clients/executers in multiple teams now and am glad to see something that I might actually use instead of re-rolling my own each time.

One thing I’ve previously found very useful is the ability to select multiple ‘environments’ at once (I’ve previously split this in to e.g. environment+session or environment+user before). The ability to merge a set of variables together lets you define variables for _where_ I’m calling (local, staging, etc), but also who/what I’m calling (specific users, types of profiles/packages (how does this api behave if I switch between a free vs paid licence), etc).

Also echoing another comment, the blog linked gives me a 404 page now. Additionally, the GitHub for this projects seems have a ton of blank issues saying “help yapi made me too productive”? Rather odd, I probably won’t be running this project directly anytime soon…

The EV cert system is truly terrible on Windows. Worst of all, getting an EV cert isn’t even enough to remove the scary warnings popping up for users! For that you still need to convince windows defender that you’re not a bad actor by getting installs on a large number of devices, which of course is a chicken-and-egg problem for software with a small number of users.

At least paying your dues to Apple guarantees a smooth user experience.

Honestly whilst the docs make the review process sound complicated, I went through it a few months ago and it ended up being super simple. Just follow the instructions to create the new formulae PR (and look at other recent ones) and then you’re all done. Updates are handled by a bot they run automatically when you make a new GitHub release, so you don’t even need to interact with the homebrew repo after setup.

You do have a naming conflict though unfortunately so I’m not sure how you would deal with that.

I think these are just the package managers that it supports parsing dependencies for. The actual script seems to just be a single python file.

It does seem like the repo is missing some files though; make is mentioned in the README but no makefile and no list of python dependencies for the script that I can see.

Got around to implementing this, docker images are now published. See the README https://github.com/JustAman62/undercut-f1/tree/v3.0.22?tab=r... for updated instructions.

True single file static executables should now be working in the latest release.

Got in front of my Windows machine and figured out the issue. I believe Windows support should be fixed in v3.0.10 now (https://github.com/JustAman62/undercut-f1/releases/tag/v3.0....). Let me know if you are still facing issues!

Windows support should be fixed now in 3.0.10 (https://github.com/JustAman62/undercut-f1/releases/tag/v3.0....). Hopefully this works for you!

Yes correct, sorry forgot to reply to this chain. I've confirmed it works correctly on MacOS, Linux, and Windows under WSL (with the artefacts from the latest release). However, running directly under Windows has this issue where the terminal becomes unresponsive, and also only outputs a single line. I'm tracking the issue here: https://github.com/JustAman62/undercut-f1/issues/14 if anyone wants to know when Windows support is working.

Unfortunately I think this is because I haven't signed the executable. I've signed the Mac executable (as I already have an Apple dev account), but the Microsoft process seems to be a bit more involved and requires an expensive EV certificate. I'll look in to this further, but I can't promise anything.

Usually downloading the app as a dotnet tool doesn't get flagged as a virus, but it seems this isn't always the case.

Ah, so unfortunately the delay is only applied to new data coming in. When you start a live session, we only get the current state and new data coming from the F1 feed, so we can't delay back to a point before you started listening to the feed. You also can't "rewind" the session, so any data that has been shown won't be removed, only new data will be added (after the delay you've set).

Currently the delay is designed for a minute or two's worth of delay for a live TV feed, or for replaying old sessions. I don't currently have a good way to support a long delay during a live session, without you starting the app before the session starts, and applying the 25 minute delay immediately so that all the data is queued up to be displayed in 25 minutes time.

I have compiled as self-contained, however I missed some configs to make sure that all native binaries were included in the final executable. I've made a new release recently (https://github.com/JustAman62/undercut-f1/releases/tag/v3.0....) which should resolve this issue.

As noted in https://github.com/JustAman62/undercut-f1/issues/3#issuecomm..., I think there's still more work to do to make the single-file executable work properly on Linux, due to the intricacies of the native Skia libs.

I'm not personally aware of a method of doing so via a TUI, but I'd be very happy to be corrected. I was under the impression that sending images was the best way to handle non-character based output.

Thanks for the heads up. I think there might be some intricacies with different terminals and OS's which I hasn't fully appreciated (I've only been testing this on a arm64 Mac unfortunately). I have made a new release (https://github.com/JustAman62/undercut-f1/releases/tag/v3.0....) which might help fix the issue - but I'll need to get my hands on a windows machine again to validate, which I should be able to do in the next couple of days.

Thank you! The data comes from a SignalR data stream that F1 provides. It's not exactly public, but also not protected. There are some other projects (like FastF1) which have done a lot of working understanding this data, so all kudos go to them.

There's also static API endpoints which contain .json and .jsonStream files after a session ends, so you can process all the data and run some analytics on it.

I assume they don't mind too much about the usage - on the basis that some of these projects have existed for quite a while. I'm pretty sure everything who performs F1 analysis (like journalists, YouTubers etc) with charts and the like and getting their data via these feeds (either directly or via packages like FastF1.

If you want to learn more about the implementation itself, I'd recommend checking out the DataImporter.cs and LiveTimingClient.cs files in the UndercutF1.Data project of the repo. Although fair warning, my codes not that beautiful :).

I have to admit, the transcription quality isn't all that great, it depends heavily on the driver and the audio quality on that particular weekend. I think it's better than nothing though.

As it happens, I started to make this back when McLaren weren't doing quite as well as they are now... for exactly the reason you describe. Being able to see pit windows easily for drivers all the way down the field, and observe lap times and relative gaps for drivers makes following the midfield much easier.

Unfortunately I don't handle lapped drivers very well, once they're lapped much of the gap related stuff stops working for them. Thankfully the last year or so the field has been close enough where that's not too much of an issue.

Oh that's fantastic, way better than searching for results on modern sports news sites. Definitely bookmarking this, maybe I'll accidentally learn a bit of Finnish.

Thank you! Yes, learning about the kitty and iterm graphics protocols was surprisingly fun, and opened my eyes to the potential power of modern TUIs (even if I'm not making best use of all the power).

Sixel on the other hand seems like an alien protocol whose implementation daunts me - think it'll be a while before I tackle that one.

There is https://openf1.org which has an API, although I don't believe it's real-time. My projects uses the SignalR stream directly from F1, but it's not very API friendly and you have to learn and do a decent amount of processing to make it in to useful display data. Check out the UndercutF1.Data project to see how this is done. FastF1 also has a live timing client, although I don't think its their preferred method of analysis.

After a session is finished, F1 do upload json and jsonStream static files which you can download - checkout the DataImporter class to see how this is done (this is what powers the undercutf1 import` command)

Yeah that's a fair point. Although I've been a bit iffy about the ethics of monetising somebody else's data - and I feel that line would be definitely crossed if I made a direct competitor to F1s own products. So monetisation is very much off the table :)

Thank you! I'm very proud of the track map and lap charts. I mulled over for months about rewriting the app into a native app or website so that I could do proper graphics etc, but then one day earlier this year I suddenly realised I could use Terminal Graphics protocols to achieve inline graphics in the TUI itself, giving me the best of both worlds!

Wow I'd love to go to a US race at some point, the vibe in those weekends feels so unique compared to the classic European race. Hope you have a great time! Happy to take any feedback/suggestions after the Jeddah sessions if you have any

It’s definitely a fairly trivial implementation, here’s one of a few dozen lines of (not very clean) Swift: https://github.com/JustAman62/ovault/blob/7ee38b7e5c2666cd34...

The simplicity of the implementation makes a test suite even more valuable, as it’s really quite hard to figure out if your implementation is correct.

Structured logging is very common in many languages. Off the top of my head, in C#/.NET Serilog has been doing structured logging for a long time. Modern .NET has structured logging in its standard lib. Rust’s tracing lib also supports proper structured logging.

See my comment as a sibling to yours for a link, but Matt Levine made a post about how the pooling seems to work at Spotify. All the subscription money is pooled together, and all listening hours are pooled together. Artists are paid out at the ratios of everybody’s listening hours pool, not just each individual subscriber.

This means what individuals pay doesn’t matter at all to the artists they listen to. All you need to do is rack up a lot of listening hours, to have an outsized impact on the resultant listening hours pool. Then if enough other subscribers barely listen to any music, you can earn more than the $10 you put in.

Matt Levine actually wrote a post about somebody who did this and got caught a while ago. https://www.bloomberg.com/opinion/articles/2024-09-09/fake-s...

The gist is that your listening hours for your subscription are pooled with everybody else’s, then artist payments are made out of ratios from that pool. That means if you subscribe and listen to music 24hrs a day, and somebody else subscribes and listens to 1hr a day, you essentially have more influence over the pool of money and so can pay out to the artist you are listening to more than you pay Spotify.