nimih

Maybe it's different in your neck of the woods, but all the government portals I use tend to have access to rather sensitive PII, and I would really prefer their ops teams be up to snuff as a result.

I'm not sure I really agree with your main point (I think it's probably still important for LLM-generated code to be generally human-understandable, at least if you care about long-term maintainability), but setting that aside to answer this question:

> I guess you would code manually every now and then for your own enjoyment but at that point do you care about style guides written for scale?

I think they're still quite valuable in that case, for a couple reasons:

- When learning a new language (which happens much more frequently when writing code "for pleasure," as it were), "written for scale" guidelines still translate pretty well to "written for oneself" IME. At the very least, they tell you what to expect in code you read, and give you a reasonable starting point as you develop your own taste and stylistic preferences.

- I've noticed some open source projects beginning to institute anti-AI contribution guidelines, and such projects still benefit from codified style guides. Google obviously doesn't fall under this category themselves, but in other language ecosystems, their style guides tend to find use in OSS projects.

Idk, it also has a nicely expressive typesystem outside of lifetimes, a lot of modern syntactic features like pattern matching and monadic error handling, well-written compiler error messages, a well-designed standard library, and substantially less accrued cruft when compared to its largest competitor. Safety might be the cudgel its evangelists like to beat everyone over the head with, but there are certainly things to recommend it outside of that.

That is, in fact, the page I started on. But the firmware on my paperwhite 2 kindle is so old (and also can't be logged in to my Amazon account) that I couldn't get the provided instructions to work, so I had to go spelunking on the wiki to find an ostensibly obsolete jailbreak that did work for me.

I dunno, I'm a kinda-dumb web developer who's spent the past 9 months deep-frying my brain with LLM model output, and it also took me multiple hours (but, less than a day) to figure out the right jailbreak for my kindle and how to run it. I think that's probably just how long it takes to find what you need on the kindle jailbreaking wiki and carefully follow the instructions, regardless of what other skills and preexisting knowledge you may have.

I'm not sure what the point you're trying to illustrate is, but I think you forgot a `flip` (unless the point is that you always mix up the argument order of the foldr reducing function, in which case fair enough).

Haskell packages in arch are dynamically, rather than statically, linked, which pulls in a large amount of transitive dependencies (reportedly in the neighborhood of a gigabyte). The maintainer has a pretty reasonable (to my eyes) explanation[1] as to why this is the case, but admittedly if I were an arch user I'd probably find it a bit annoying.

[1] https://www.reddit.com/r/linux/comments/9emwtu/comment/e5qss...

you probably shouldn't complain about people "screeching" when this is the tone you respond to calm, measured discussion with.

part of the charm of letterboxd is that its median reviewer is far more woke than every NYT contributor combined, imo.

This paper doesn't seem to have much to do with post-modernism at all; it strikes me as much more in line with modern analytic philosophy.

Nor does it make any claims about the nature of intelligence, for that matter.

Did you even read the abstract?

FWIW, I'm only half-joking with my comment: dealing with software updates is an annoying part of life, and IMO rsync's UI is rather complicated (in that it's easy to use the wrong set of flags and do the wrong thing, sometimes in annoyingly subtle ways) and I basically always need to refer to the man pages (or, these days, an LLM, followed closely by the man pages to sanity-check what I'm doing) whenever I'm writing a new incantation of it rather than copying from an existing script or my shell history. I just chafe a little bit at declarations like "better than," since that's clearly not true (in the same way that rsync is not unequivocally "better than" syq), when more precise and less conceited descriptors like "faster than" are sitting right there on your benchmarks page.

Browsing the repo, I can see a couple of advantages:

- Single contributor. Software bugs are generally caused by developers writing code. By reducing the number of contributors, syq has cleverly reduced the surface area for defects to sneak in.

- Distribution via shell script. rsync is bundled in most linux distributions, which means you have to deal with annoying software updates from time to time. Syq, OTOH, tells you to pipe curl into bash to execute a shell script, which means one-and-done installation and maintenance.

- UI clarity. If you search StackOverflow for rsync, you'll see thousands of questions asking how to accomplish various tasks with rsync, both straightforward and arcane. By contrast, `syq` isn't even a tag on SO. The obvious conclusion here is that rsync's interface is so byzantine, and its documentation so poor, that users must resort to asking strangers for help, a problem obviously not shared by syq.

By "information dense," I meant in contrast to what is typical in modern GUIs: generous borders and margins between interface elements, large buttons, etc. My experience both using and writing TUIs is that, because of the extreme limitations of your tools w/r/t styling and layout, more of the screen real estate tends to be devoted to displaying data, and on whole I prefer that.

YMMV, of course, I'm just sharing my own experience and perspective.

I personally like making (and using) TUIs because:

- They encourage developing simpler, information-dense, and keyboard-driven interfaces, which I tend to prefer in general.

- I find them more fun to write, and less aggravating to maintain and debug, than interfaces built with GUI toolkits.

- Most software I write for personal use is going to be run in both a Linux and Mac OS environment (and a lot of the time on a headless server to boot), and a TUI often has less fuss than other options (at least, IME).

- I think monospaced text in a terminal just looks cool.

One way to get around this in some cases is to subscribe to the feed's associated email newsletter, which, IME, is more likely to have the full text of the article. This, of course, introduces other problems[1], but if your goal is to remove reasons to habitually look at your phone, it's worth investigating.

[1] The feed needs to have a newsletter in the first place, you probably need to clean up the markdown a bit before shoving it into an epub (I've noticed that table-based layouts are much more common, for instance), and your email provider probably doesn't provide an RSS feed of your inbox. The latter two are straightforward to fix but do require a bit of programming elbow grease.

Based on bot traffic to my personal blog over the past year or so, the minimum viable web crawler apparently does not need any of those things (much to my own personal annoyance, to be very clear).

I think you certainly grasp the gist of things if you understand that the point is self-reference. What makes the proof shocking and beautiful (at least, IMO), is how sparse a toolbox Gödel is working with (and, perhaps, how clever the construction is). Contradictory self-reference in, say, plain English or naïve set theory, is not particularly surprising (at least to our modern eyes), because those are rich languages where you can express an extremely wide range of statements, but Gödel manages to smuggle it in using just whole-number arithmetic and first-order logical statements, which provides a recipe for doing so in essentially any formalized system of interest to "normal" mathematicians.

Some comments elsewhere in this topic mention that you can use the halting problem to arrive at the same essential conclusion in a more understandable way (and certainly one less fraught with small technicalities to work through), but (again, IMO) there's a certain mischievous magic to the way the Gödel sentence gets constructed that makes it very fun to work through for the first time.

Honestly, other than the length and tedious presentation, I don't really think the material in the Principia Mathematica is outside the reach of an advanced undergraduate. As a point of reference, MIT's capstone mathematical logic course[1] has a syllabus that requires at least as much mathematical maturity, and it wouldn't really surprise me that much to see it as an ancillary or excerpted text.

That said, even if the OP was assigned the text at some point as an undergraduate, I remain a bit doubtful it was actually read.

[1] https://cfreer.org/18.515/

> if it is weakened, how can you prove the same stuff?

Sometimes, you can't. In particular, so-called "non-constructive" proofs don't work in intuitionistic logic. Some mathematicians like to work in intuitionistic logic: for philosophical reasons, pragmatic technical considerations, or just because they think it's interesting.

Speaking personally, there are essentially two distinct reasons I like having programmable config languages:

- For personal application config (window manager, shell, text editor, etc), I find I often want to have site-specific configuration, but I also want identical configuration files at every workstation. My laptop probably needs slightly different keybindings than my desktop, my $PATH and text editor needs to be configured a bit differently for work than for personal use, etc. When the configuration is done with a real programming language, this is always straightforward, when it's done via a json/yml/toml file, it's usually a huge pain in the ass.

- You want templating for your configuration, to improve readability, reduce typos and configuration drift, &c, but if you give programmers an inch with any sort of templating system, they will eventually take a mile and figure out how to smuggle Turing-completeness (or, at least, for-loops and variable binding and probably closures) into their configs. If you have a real programming language, this is fine, because the programming language was designed to make loops and conditionals and function calls readable, and probably has decent tooling to boot, but if they're doing it with, say, Mustache-templated YAML, you will have an unreadable mess that is extremely unpleasant to work with.

Something I've personally noticed over the years is that when I take the time to hand to write thoughtful commit messages, the overall quality of my technical work tends to increase as well. My theory is that the process, while boring and time-consuming, forces me to think holistically about how my current task fits within the system and find gaps in my own understanding and implementation. I sympathize with the author's impulse to ignore these tedious details (I, too, love slacking off at work), but, at least for myself, my decades of (admittedly unstructured) A/B testing "how good is the software I write if I don't do this" unambiguously points to it being a somewhat load-bearing piece of my effectiveness as a software developer.

Of course, if you're just optimizing for the amount of slop you can shove into github each week to appease your manager/PM, then yeah just let the chatbot write the commit messages too.

> unclear reasons

I think it's pretty obvious, tbh. Traditional roguelikes are turn-based, take place on a square grid, are good vehicles for exploring focused mechanical ideas, and can be fun without much in the way of story or graphic design. All of those features mesh well with the rules of chess, which itself is probably the most widely played game in the world.

I agree. We should legalize drunk driving so that no one can be denied their god-given right to drive a car.

It's in fact the opposite: an intentional design choice to make save scumming (edit: and by extension, sharing specific rng seeds) more effective for people who like doing it. They made a similar design choice with how save/restore works, in that it resets the current encounter, which allows players a limited ability to undo/backtrack if they make a mistake.

Can you describe what you mean by "oracle attack" here? CSPRNG APIs (at least the ones I've used) usually expose ways to set a specific seed and serialize the RNG state. In fact, arguably the simplest possible CSPRNG, where you just run a (suitably strong) block cipher in counter mode, would seem to meet the requirements for game dev in a straightforward manner.

How long was Enron able to fake it, out of curiosity?

> ArXiv doesn't even check the submission closely, so how can they know?

They can be informed by people who read the papers and check the citations. A zero-tolerance policy provides an incentive to report sloppy papers (namely, that you can be confident something will be done about it), and each time a paper is removed or an author is banned, it incrementally increases the value of the arXiv as a whole.

> Being required to publish in a peer reviewed journal will close off arxiv for many researchers for good.

At the end of the day, demanding that people carefully proofread their LLM-generated papers before sharing them on the arXiv seems like a relative low bar to clear, and I sort of question whether it's reasonable to call individuals who find it too onerous "researchers" in the first place.

I think it's possible to be simultaneously: gracious and supportive towards the developers and ops staff who have been struggling to maintain reasonable uptime on the extremely important piece of shared internet infrastructure that everyone commenting probably relies on (either directly or indirectly) on a daily basis; and spiteful and cruel towards the massive (and, historically speaking, ethically fraught) corporation whose cynical acquisition and subsequent mismanagement of that same resource got us here in the first place.

It may be helpful context to understand that The Onion is a satirical publication, and that them taking over InfoWars may itself be part of the joke.