SloopJon

Daniel chose three options: Visual C++, ClangCL, and GCC under WSL (2?). He says that ClangCL "couples the LLVM compiler (commonly used by Apple) with the Visual Studio backend."

I'm unclear on what he means by the backend. Is ClangCL essentially the same as using LLVM for Windows with the Microsoft linker, or is there a difference in code generation?

There was an Ask HN post about that idea a couple of months ago:

https://news.ycombinator.com/item?id=34478503

I have long wished for less linear stories in video games, where branching narrative (a la Choose Your Own Adventure) is one possible way to give the player agency. The problem is, true branches are expensive, because you end up writing a bunch of content the player never experiences.

I see a lot of potential, but it's going to take a different kind of craftsmanship, and likely many iterations, to realize something more than a novelty.

This is why I keep reading these threads, looking for something I can wrap my head around.

I started looking at Kaitai Struct not too long ago. I purposely started with a pretty simple format, but I think I'm not smart enough to figure out the input format. Also, I'm pretty sure I hate YAML.

I tried building Poke just last week, having resolved to try it since 1.0, but hit problems with the Boehm GC on my old Mac, and then what looks like Readline problems on my new Mac. I haven't given up, but I'm off to a slow start.

Hachoir, mentioned in another comment, looks promising, although the input looks suspiciously similar to a program I'd write myself.

If you're asking for a GUI for simple CRUD on an arbitrary table, I think that's pretty common. What database are you using, and what API are you using to access it? (Edit: and on what O/S?)

If one of the obstacles to data entry is normalization, perhaps an updatable view if your database supports it.

I toyed with trying to get it running on a Jeston Nano a couple of years ago. At the time, Raspbian was still 32 bit, JetPack was 64 bit, and running 32-bit Debian software on 64-bit Ubuntu was more of a pain than I wanted to deal with.

If it still ships with 64-bit Raspbian it might be worth another try, but I would not be at all surprised if it's somehow tied to the Pi.

One significant caveat: "Free projects are paused after 1 week of inactivity." I'm not complaining, but I reckon a lot of hobby projects would see sporadic activity. For example, I used to upload a list of my CDs to a VPS, so that when I found something interesting at a music store, I could check to see whether I already own it (#FirstWorldProblems).

Although I personally think type inference is the killer feature that makes static typing accessible (almost always auto), I've seen hostility to it, in particular among C++ and C# programmers. The point of this project, as you say, is to be as explicit as possible in the code, while at the same time presenting a view of the code that is less cluttered.

My initial impression is that if I were to use a system like this, I would want any type annotation that differs from the default inference to be visible. The only choice left, then, is when to display redundant annotations, which is where a lot of the disagreement around type inference is, even without this scheme.

I wonder whether that license is valid, given that it was issued by Caldera, when Novell was in fact determined to be the copyright holder.

I did find a forum in which a user stated: "[Novell's Legal Vice President] said that while Novell retains certain copyrights over UNIX, they also acknowledge and recognize the validity of certain legacy SCO/Caldera licenses regarding UNIX technologies."

https://www.betaarchive.com/forum/viewtopic.php?t=25745

At the risk of derailing the conversation on this fun project, one my first thoughts was that this game for a long-dead computer is probably still under copyright for another few decades. Then it occurred to me that even after all of that SCO nonsense, I don't know what the copyright/license status of ancient Unix is.

The code in this repo does not show any license. The repo from which it's derived claims GPL 3.0, although the README notes: "The code in the original scans are (c) Micro Focus who own the rights to the Unix source code" (Micro Focus International having acquired Attachmate, which acquired Novell, which bought Unix System Laboratories from AT&T).

Oh, wow, thanks for pointing that out. I have to build HashiCorp Vault from source with CGO enabled because of the broken DNS resolver. Otherwise, it's completely unusable with a split-tunnel VPN.

Very promising: supports macOS 10.8 and later, last updated in 2021, and it read my whole CD collection in just a couple of minutes. Thank you for the suggestion.

Years ago, I had most of my music ripped to AAC in iTunes, easily accessible, browsable, and shuffleable.

I now rip each of my CDs to a single FLAC and cue sheet (using XLD on Mac), on the theory that it's the most accurate way to archive a disc. However, I haven't found anything that offers the same accessibility to such a collection as iTunes did. I look through folders, and drag a few cue sheets at a time into Foobar 2000.

Any tips?

I got the solution with a straightforward set of assertions in Z3. It was a lot of typing, and I wonder if there's a more succinct way to do this than the following:

    (declare-const blitzen Int)
    (declare-const comet Int)
    ...
    (assert
      (and
        ; lower bound for readability (1 is front)
        (> blitzen 0)
        (> comet 0)
        ...
        ; upper bound for readability (9 is rear)
        (< blitzen 10)
        (< comet 10)
        ...
        ; clues from the puzzle
        (> vixen rudolph)
        ...
        (< dasher vixen)))

I was curious to see where the author sourced a SID chip, perhaps the most prized component of a C64 these days. It's an ARMSID, an ARM-based emulator.

I keep thinking I'll pull my C64 out of the attic, but the nostalgia is kind of fading for me at this point. That compact flash cartridge looks really cool, though. I would have loved something like that back in the day.

On my system (Windows 10, i7-10700K, Clang 11 with Visual C++ 2017 linker), frozen::unordered_set takes about 10ns. This is faster than std::unordered_set at 14ns, but slower than direct comparison at 6ns.

Although Google Fi claims to support eSIM, the front-line support was unable to help me connect an iPhone 13 Pro, and the back-line support never responded. The solution was to buy a physical SIM card.

Perhaps Google is uniquely incompetent, but I would be very wary about assuming that an eSIM-only phone will work with a given provider.

There was a story about a pair of twins like that in the Washington Post recently:

https://www.washingtonpost.com/lifestyle/2022/08/24/virginia...

The marriage is known as a quaternary marriage, and the cousins are known as quaternary twins.

> There is no path to a green card or citizenship for anyone who immigrated in the last ~15 years

I'm no expert, but I don't think this is quite right. For an applicant with a bachelor's degree, the cutoff date is February 2012 for India, and April 2018 for China:

https://travel.state.gov/content/travel/en/legal/visa-law0/v...

With an advanced degree, it's December 2014 for India and April 2019 for China.

Please correct me if my understanding is incorrect.

I don't know what Kunal's temporary work authorization was, but note also that the STEM extension for the OPT program has been tweaked in recent years, so that you can typically get three bites at the H-1B apple while you're still on an F-1 visa.

I applied for a QA position at a company that uses time-of-flight cameras with industrial robots. I researched their solution, got a sense for its architecture, and started toying around with building a Flatland-style version of their product. I figured that a demo like that would stand out much better than anything on my resume.

They rejected my application before I got too far with the demo, which would have taken me a lot more than six hours to finish. Although it might have been an interesting addition to my Github repo, it was kind of tailored to this one company.

I'm not disagreeing with the OP, because I probably wouldn't find an interview project nearly as fun. I wonder, though, whether anyone has been successful with a one-off, company-specific project like this, as opposed to a general portfolio of projects that you've made over the years.

Completely different music style, of course, but Dick Dale did the same thing.

This was my preferred approach for several years. The tests were in a repo separate from the code under test, and each declared its prerequisites, either as a feature or a version pattern.

If a test started failing, I could annotate it as an xfail with an open-ended version pattern. If I noticed that an xfail started passing, making it a upass (I think these were blue in our tests results), I put an upper bound on the xfail version pattern.

The nice thing about this was that I could always run the latest and greatest suite against any version, although it made it a little more complicated to run them as they existed when they were first run.

I don't know anything about Tom's situation, and I apologize if this in poor taste: a major preventable cause of brain hemorrhage is hypertension. If you have high blood pressure, it's not a joke. Get treatment.

This has indeed been eye opening. We got bit by a dependency problem in which TensorFlow started pulling in an incompatible version of protobuf. After reading these comments, I don't think that pip freeze is quite what we want, but poetry sounds promising. We have a relatively small set of core dependencies, and a bunch of transitive dependencies that just need to work, and which we sometimes need to update for security fixes.

In my case, I find it hard to query related issues of different types. It's kind of hard to explain unless you see how we use Jira, but I basically want to do joins. You can do some interesting things with the Structure plugin, or issueFunction() from the Adaptavist ScriptRunner plugin. The other thing I've done is to pull a few REST queries into a single-page app., but that takes more work.

I totally tuned out that this is a Cloudflare repo. Some Googling turned up a USENIX slide deck that puts this into context:

https://www.usenix.org/sites/default/files/conference/protec...

Whereas the README uses URLs as the realm string, the slides uses realm strings like "root-password" or "ssh-v2" to derive keys from a seed stored in a UEFI variable.

I think the idea is that you can administer all of your servers with one master password, while each server derives different passwords locally from its own seed. If a given seed is compromised, rederive the passwords from a new seed (or reprovision the server from scratch). If your master password is compromised ... well, try not to let that happen.

> They all end up taking on state

Note that the recommended operation for GoKey requires the use of a seed file. Instead of deriving passwords directly from the master password, it derives them from a file of random data that is decrypted by the master password.

While it's true that this seed file doesn't require the ongoing synchronization that a vault does, it's something that you need to have, and to manage with care.

For those thinking that this is just another version, note that 3.2 is a stable version, with 3.0 having been first released almost nine years ago. In the interim, I'm sure many people have used 3.1, but now you get all of the fun enhancements without an asterisk.

> No solution will be able to cater to requirements that don't exist at the time of developing this pizza-application.

I think I know the title of Gordon's next blog post: "Why YAGNI is the second most over-rated programming principle."

> I just started reading the book a couple of days ago. Sigh... :-)

I wasn't even going to click the link, because I thought this was for the old online book. Because of your comment, I see that Learn TLA+ has been updated, and Hillel says of the Practical TLA+ book I bought a couple of weeks ago: "Don't bother."

I haven't gotten that far yet, but I have modeled the wolf, cabbage, and goat problem, and helped the poor waiter in xkcd 287. Eventually I hope to apply it to a distributed database and our crazy Jira deployment. I'm not sure which will be harder.