tetraodonpuffer

any time there is a right turn you can still end up in this same situation, whether it's right turn on red or not, if the driver does not look to their right: there have been plenty of times I have been nearly ran over when a car turning right on green did not notice that the same direction pedestrian crossing light was green also and I was about to cross.

Same thing for cars turning right in front of me riding my bike in the bike lane, it's just par for the course, so pedestrians should ALWAYS make eye contact with the driver before crossing, and cyclists should NEVER be side-by-side with a car when approaching an intersection.

Hah not sure about “production”, I am currently in between jobs and am taking advantage of that to work on a docker/k8s/file TUI log viewer.

I am using those techniques respectively for loading backups (I store each container log in a separate file inside a big zip file, which allows concurrent reading without unpacking) and for servicing the various log producing goroutines (which use the docker/k8s apis as well as fsnotify for files) since I allow creating “views” of containers that consequently need to aggregate in order. The TUI itself, using tview, runs in a separate goroutine at configurable fps reading from these buffers.

I have things mostly working, the latest significant refactoring was introducing the btree based reading after noticing the “fix the order” stalls were too bad, and I am planning to do a show hn when I’m finished. It has been a lot of fun going back to solo-dev greenfield stuff after many years of architecture focused work.

I definitely love golang but despite being careful and having access to great tools like rr and dlv in goland, it can get difficult sometimes to debug deadlocks sometimes especially when mixing channels and locks. I have found this library quite useful to chase down deadlocks in some scenarios https://github.com/sasha-s/go-deadlock

Thanks for the write up! In my current application I have a few different scenarios that are a bit different from yours but still require processing aggregated data in order

1. Reading from various files where each file has lines with a unique identifier I can use to process in order: I open all the files and create a min heap reading the first line of each, then process by grabbing the lowest from the min-heap repeatedly, after reading a line from a file, I read another and put it in the min-heap again (the min heap cells contain the opened file descriptor for that file)

2. Aggregating across goroutines that service data generators with different latencies and throughputs. I have a goroutine each that interfaces with them and consider them “producers”. Using a global atomic integer I can quickly assign a unique increasing index to the messages coming in, these can be serviced with a min-heap same as above. There are some considerations about dropping too old messages, so an alternative approach for some cases is to index the min-heap on received time and process only up to time.Now()-some buffering time to allow more time for things to settle before dropping things (trading total latency for this).

3. Similar to the above I have another scenario where throughput ingestion is more important and repeated processing happens in-order but there is no requirement on all messages to have been processed every time, just that they are processed in order (this is the backing for a log viewer). In this case I just slab allocate and dump what I receive without ordering concerns but I also keep a btree with the indexes that I iterate over when it’s time to process. I originally had this buffering like (2) to guarantee mostly ordered insertions in the slabs themselves (which I simply iterated on) but if a stall happened in a goroutine then shifting over the items in the slab when the old items came in became very expensive and could spiral badly.

I think what would help is that any F2P game was mandated to never cost more than $x/year to be listed in the app store, and possibly have different tiers that a game could decide to be in ($10/$100/$1000) based on the maximum yearly spend. The game also should prominently display the total spend per year, and lifetime, every time it is launched.

Although I do not like F2P for all the dark patterns (which have infiltrated non-F2P as well unfortunately) if it was capped to a reasonable maximum amount a year, with no player to player trading at all, and no multiple accounts for the same store account, it might could be made to not be as predatory while still keeping it financially sustainable for the companies that produce the games.

why don't you think this would work? Technically this is basically "the (SP) site trusts another (IDP) site to sign/encrypt a JWT containing some custom assertions". The user would go to the SP, get a signed blob (session nonce / expiry / whatever), take that to the IDP, log in there, IDP creates a JWT with the original blob plus any assertion you allow, you post the JWT back to the SP, SP decrypts the IDP packet, gets its own nonce, ties you to the session, done.

There are also obviously better ways (https://blog.cloudflare.com/privacy-pass-standard/ possibly some variation of zero knowledge proofs) but technically this seems like a solvable problem. Money wise the IDP or in general verifier can charge users for an account and/or generated assertions.

according to https://en.wikipedia.org/wiki/Ispell ispell (1971) already used Levenshtein Distance (although from the article it is not stated if this already existed in the original version, or if it was added in later years).

I think the fact that, as far as I understand, it takes 40GB of VRAM to run, is probably dampening some of the enthusiasm.

As an aside, I am not sure why for LLM models the technology to spread among multiple cards is quite mature, while for image models, despite also using GGUFs, this has not been the case. Maybe as image models become bigger there will be more of a push to implement it.

having the keyboard the way it is also allows you to more easily orient yourself, you can feel with the sides of your fingers if you are next to E/F or B/C and with the corner of your eye it's also straightforward to figure it out. I don't think it'd be possible (or anyways even more difficult than it is now) to play large jumps accurately if the whole keyboard looked the same

this is why if I was a sprinter a the TDF I'd 100% be on a mechanical groupset (assuming the sponsors allowed me to) a missed shift on a sprint means losing 100%

it still depends what component it is, when I was a teenager I was riding a bike with rim brakes, the bolt holding the front rim brake to the frame broke all of a sudden during very light braking, the caliper rotated and got caught between the spokes and the front fork leading to the front wheel immediately stopping leading to me performing a superman dismount (since then I've ALWAYS worn bike gloves when riding). There had been no signs at all that the bolt was about to fail.

In my experience (many years of riding, quite a few years of bike commuting full time included) most mechanicals on the front wheel mean a fall/crash, but everything else just leads to having to walk home if you don't have the right tools (carrying a couple spare chain links in addition to the typical flat repair stuff and a full set of hex keys lowers the chance you'll have to do so).

there will always be a market for exceptional artists, but what about the other 80-90% of people that used to be able to make a living and now can't anymore? What are they going to do? And without the possibility of a particular profession leading to gainful employment, very few people will even start it, making the funnel smaller and smaller until even exceptional artists won't be able to emerge at all.

it only takes popular distributions making it default, then all sorts of things will start depending on it, and it will be difficult to not switch eventually. As somebody that has written a lot of xlib/xt/motif code years back, and that still has the full O'Reilly X series set on my bookshelves, I would prefer X11 to continue; but just like sysv->systemd it seems things are moving against that being the case.

that works in a lot of cases, but unfortunately it seems sometimes you get these popups about nsurlsessiond (for example) where you know where the connection goes, but no idea where it comes from (especially if it's trying to connect to to some generic AWS hostname)

And as much as you can use little snitch for programs you install, these days it seems an endless whack-a-mole to block Apple's stuff as there's so many requests all the time. The more time goes by, the more it seems that the concept of "personal" computer is gone: there's nothing "personal" about it anymore, it's the computer plus an amorphous blob of online services one has no control over.

Any plans to use it for the managed azure istio so that can be used in FEDRAMP environments?

As somebody that gives systems design interviews most weeks, you’d be surprised how many candidates don’t put the api gateway but magically go from the TCP load balancer to the services inside the cluster, or how basically nobody is ever able to explain how a CDN works (as in, put the CDN behind the API gateway, note I have seen this in a company in production too). Or how some candidates will have redis and Postgres and do magical cross storage transactions.

And these are all candidates with 5+ years experience, sometimes 10+. I hate the leetcode gauntlet, but I also am really surprised how much worse candidates are now on average that they used to be (I’ve been around for about 25 years now), and how the minute you try to dig a little deeper to see if they know how things really work, the more it seems that they have no understanding whatsoever of the basics and somehow treat computers as magical black boxes.

I do understand I am privileged by having grown with the technology, starting in the 8-bit era, through an electronic engineering degree, and now in k8s etc. but with so much educational material available for free you’d think that even people in their 20s/30s now should be able to have a better idea of how things work.

Have you had issues with image retention? I also like the 43” 4K setup for some things, but these days it seems IPS screens in that size are not as easy to find, I’ve always been wary of OLED due to burn-in

Huh? One screen for email/slack/.. main screen for the ide, other screen for logs etc. a lot less context switch to glance left/right than to go to another virtual desktop

I don’t understand some of my colleagues that feel this way either, I’ve been around a long time but having a way to set up a ”local” environment with a local automated build to me seems priority one for any piece of software cloud or otherwise.

By “local” I mean self contained, my “local” environment is right now a single cloud Linux VM with kind for kubernetes, all sorts of k8s local monitoring / cert issuing / stubbed things, metallb and openvpn to access (with a local to my computer dhcpcd for DNS resolution) and so on, all building from local and orchestrated by a python set of scripts. All of this works great and has saved me so many times and made development so much faster compared to teams that rely on ci/cd even for basic development (where every commit takes an hour+ to deploy due to tests builds and so on)

The only issue with this approach can be services / software that has hard dependencies on specific cloud products you can’t run “locally” but even in that case you can always spin up / tear down super small versions of them to use for the setup. Python has been great to glue orchestrating everything with easy to use kubernetes and docker libraries, and aws/azure cli commands as needed.

If you have a product that you can’t easily build or deploy in an automated manner you’re going to have a bad time at disaster recovery time or when the one person that knew how that one piece gets installed is laid off.

The actual title is: Inside Out 2 Was the Hit Pixar Needed, but the Laid-Off Employees Who Crunched on It Are Still Hurting

The neck is also surprisingly fairly involved in the balance system, I unfortunately have a lifelong inner ear deficit (deafness and vestibular) on one side and there have been times where neck tightness caused significant issues with my eye tracking (nystagmus). It’s really all connected, also salt intake, caffeine etc. can impact your balance / dizziness due to the pressure in your inner ear canals where the otoliths are swimming.

Easy way around this, when you create the error message always put in there the local epoch time of when you are writing it (copy from date, plug-in in your editor, whatever) making grepping for it trivial later on.

It is a pretty decent name since you can easily search for information about it, unlike say “kind” (which I typically use for development) which is absolutely un-googleable

Thanks for writing some code! I will try to spend some time to grok it: so is the idea basically that you are guaranteed there is only ever one copy of these unique IPs and there is absolutely no way for any more than one function to hold one? I have to say maybe HashSet was throwing me for a loop and if the important bit is having an object that can not be copied, then it shouldn’t matter what data structure you keep them in does it…

I don’t find a strong case for using Rust just to guarantee each thread gets its own IP (a mutex protected getter seems like it would do just fine for just that) but I guess it would guarantee that as long as you use this “uncopiable” object you could not, even if you wanted to, have two identical IPs in your program if I understand things correctly, which if your mutex getter had a bug would not protect you against.

I might be dense, but I still don’t get how it works: I put the 10 addresses in a HashSet, and I have some function that I want to be able to exclusively use one of them, how do I write the constraints to make the borrow checker be able to enforce this at compile time?

I understand the two statements above in the article, just not how they can be made to work in this case. Apologies again if this is an obvious question, as I was saying I am definitely just starting out in rust.

I would have been interested if the author had expanded on how they planned to use the borrow checker to avoid multiple listeners using the same IP address. I haven’t used rust much outside of some self learning but in other language I’d simply mutex/lock, how can the borrow checker at compile time validate that each listener cannot get the same value of a hash set?

Trading quality for price has been happening everywhere for long enough that it is easy to see how unfortunately it will now play out in the arts as well. I mean, not that long ago all clothes you wore were custom made by a tailor, all the music you listened to was played live by musicians, all stories were brought to life in front of you by theatre actors: now all of those while still available are significantly more expensive and niche than the mechanized (production or reproduction) equivalents.

ChatGPT, stable diffusion and I am sure upcoming music models will enable this mechanization in the arts, where great artists will be unaffected but making it nearly impossible for “good enough” artists to compete while also pushing up the floor of what is an acceptable competency level that merits being paid for making it more difficult for people to support themselves while improving their skills.

My wife swears by https://darebee.com/ they have workouts/programs for all levels, all body weight based

I just have a couple powerlinks in my bag when riding, which take very little space. It is also unlikely to have a chain break while riding, however having a chain breaker tool and spare links comes in handy if your rear derailleur gives up the ghost (due to a fall etc), as in that case you can bypass it entirely with a shortened chain.

The most environmentally friendly computer is the one you already own, it’s sad that Apple forcefully obsolesces still working computers by dropping support for them from new releases of MacOS. Unfortunately the whole ecosystem is geared towards users being on the latest OS version, so third party software also becomes quickly unsupported.

Realistically most computers made in the last 5-7 years have enough processing power to last until broken for the most typical office / web browsing / editing vacation pictures tasks, so as much as everybody likes new shiny things, it would be great if it was possible for the more environmentally conscious consumers to be able to keep using their computers without being exposed to security issues.

I’d rather pay Apple $200/year for new versions of MacOS than be in the current “your hardware is a time limited dongle for MacOS” situation.

Agree on the GUI however opensnitch does seem to assume a single user with a single X server, I have not been able to figure out a way last time I tried to get it to work with say 2 X servers and a VNC session or two running concurrently (meaning I couldn’t figure out a way to get connection alerts anywhere but in one of them, as also described here https://github.com/evilsocket/opensnitch/issues/388 )

Little snitch does not have this issues and you can have multiple users logged in with fast user switching and all can operate their notifications no problem.