cobbal

Microsoft itself recommends developers use a "dev drive" where defender is partially disabled because of how bad it is.

I'm not completely sure what this example is trying to illustrate. Most languages with proper sum types would have `Map<K, V>.get` return an `Optional<V>`. If V happens to be `Optional<Integer>`, then the result will be an `Optional<Optional<Integer>>`, which is a perfectly good type that represents the two ways a value may be missing from the map.

Am I missing something?

It is an interesting question of definitions. Is control flow only at runtime? Is `#if` control flow in C?

If I had to define it, I would go with runtime-only, but I could see the other way too.

That's where low-profile memory comes in. If the space is only two blocks tall, then corruption is prevented.

It's a similar problem to swatting. It relies on authorities taking severe action against an unverified source of problems.

I suppose a difference is that they use unaffiliated parties to send the complaint, instead of contacting the authority directly.

It's even worse. Civil engineers are allowed to create structures that have 0 engines in them! We should restrict the title to its original meaning.

An important distinction that often gets lost is that entropy is a property of a probability distribution. A system to generate passwords has entropy, one specific password does not.

It's possible to read "hunter2" from /dev/random.

To infer entropy from a single password, the best you can do is to see if it falls within the domain of some known, low-entropy systems. This works ok in practice, but is very far from perfect.

Possible, but likely slow. There's nothing in the "C abstract machine" that mandates specific hardware. But, the bitshift is only a fast operation when you have bits. Similarly with bitwise boolean operations.

Mathematica also has some fairly advanced typographic syntax. Matrices, subscripts, integral signs, with a decent input system to match. Type <ESC>dint<ESC> to get a definite integral with placeholders.

One particularly nice thing about it is that it's completely optional sugar over a lispy "FullForm" syntax, and it's easy to convert between the two.

I'd encourage everyone to play with it, but it's sadly non-free.

Without watching the video, this seems to be about https://openjdk.org/jeps/8305968

Great news. I look forward to Microsoft installing this on my computer for me.

I would love to try reading the lossy version.

More specifically, tail recursion is usually easy to turn into a loop. Tail calls can be difficult to turn into loops when they call a different function, or worse a function passed in as a variable.

You get 256 colors per frame. Want more colors? Use more frames! There's some really impressive software/gifs at https://gif.ski/ if you want to see just how far it's possible to push this terrible format.

It's interesting that cert pinning cuts both ways though. It can also be a tool to give users power against the IT department (typically indistinguishable from malware)

Given that proofs must be finite (or it's easy to prove falsehoods), maybe the title is appropriate then.

strncpy is fine as long as it's not used in isolation. My preferred pattern (when I want the truncation) is to use it, and then unconditionally set the last byte of the buffer to null. This will always result in a valid C string.

Probably the widest accepted definition of the term open source is https://opensource.org/osd

Ah, but what if it writes so far off the array that it messes with the contents of another variable on the stack that is currently cached in a register? Should the compiler reload that register because the out of bounds write might have updated it? Probably not, let's just assume they didn't mean to do that and use the in-register version. That's taking advantage of undefined behavior to optimize a program.

Calling a piracy app "malicious" seems like a huge stretch. Am I missing something, or was this written by the copyright holders?

They have ways to deal with that too. https://www.cnet.com/tech/computing/man-put-cell-phone-jamme...

previous discussion: https://news.ycombinator.com/item?id=40815130

small note: "JSON in its pure form anarchic" is missing a verb

Maybe choice was stronger than I needed. Thinking about it more, I think the problem is that BB isn't even definable (that I can see) without LEM. There's an "either the machine halts or it doesn't" baked in to the computation of the integer.

Is there a variant of "there exists a program that prints BB(8000)" that doesn't rely on some sort of axiom of choice? Maybe the intuitionists have a more useful definition of computibility if it doesn't posit that such strange machines exist.

How deep in a gravity well are you planning to keep this cesium stopwatch?

Racket has a sophisticated system for dealing with phases in its macro system: https://docs.racket-lang.org/guide/phases.html I don't know if other schemes use a similar system.

That's exactly what iframes are designed to do. Though they do have... downsides

Not pointless to a compiler writer.

If a compiler is certain there's UB should it format the developer's hard drive immediately, or does it have to wait until the program is run before formatting to be standards compliant?

On a more serious level, should it emit a warning? If it knows UB is reached, a warning sounds reasonable, but it's pretty rare that a compiler is 100% certain something is reached, and that analysis is probably not worth the cost.

With this you can even roll a QR code into a game of minesweeper: https://sdk.scroll.pub/treeComponentFramework/sweepercraft/#...