newacctjhro

Just like the Catholic inquisition was a desperate attempt to exercise control all the while the Church was losing the ideological battle.

> Now this might seem like a hack, but it really is not. Most languages would either ask the programmers to explicitly call free() or implicitly call a magic runtime.deallocate() within a complex garbage collector.

The compiler actually implicitly adds drop glue to all dropped variables!

I mean. He wanted to rebuild a forest. That's pretty ambitious but he needed money. Some evil company gave him money. Why should he refuse?

Do you think that, in order to avoid giving Vale some PR, it would be better to refuse the money? And presumably have trouble rebuilding the forest.

This might work for hard sciences, but not for mathematics.

Or, I dunno, paleontology or sociology or other stuff.

The difference is that web apps are on a tight sandbox.

Go needs to allocate a growing stack on the heap, needs to move it around, etc. It's not as efficient as Rust's async.

This makes sense. Thanks for the insight.

This kind of stuff should be on the stdlib if it's meant to be idiomatic.

> Otherwise it's impossible to answer questions like: "If the Lagrangian formulation put space and time on equal footing, and if the Hamiltonian formulation gives a preferred role to time (generating time evolution), could we give a similarly preferred role to space?" "More generally, why isn't there a third or forth major formulation of mechanics?"

Hey, can you answer those questions? Or point to the right answers. Thanks!

Doesn't Pocket require a sign in too?

This stuff feels like a proof of concept that isn't really integrated to the rest of the language (Kinda like OCaml's OO). For example, it's unfortunate that Type, UniqueType and BorrowedType are different kinds (in Rust, they are the same kind; stuff that isn't "unique" just implement Copy)

Rust's advantage is that its borrow system, with reborrowing rules and such, feels much more ergonomic.

This is called compatibilism and yeah it seems to be a mainstream view in the academic debate

https://en.wikipedia.org/wiki/Compatibilism

https://plato.stanford.edu/entries/compatibilism/

bitcoins introduce an artificial scarcity with its mining algorithm (there's only so much bitcoins out there)

FISA is a rubber stamp court with zero oversight.

In America they spy on dissidents too. It's just a matter of calling them terrorists.

https://www.aclu.org/blog/national-security/privacy-and-surv...

> Ugh if you read the article, you would know that the UB described here is the same in Rust.

Rust doesn't have a formal memory model yet, but it's already known that UB in Rust is quite restricted:

https://doc.rust-lang.org/nomicon/what-unsafe-does.html

Most importantly, UB in Rust should only arise if you're writing unsafe code (barring compiler bugs). Typically, most Rust code is safe. This is a huge win.

> Same is true for DE's I think. Many of the things that differentiates DE's could probably be offered as configuration within one DE, with less workload but no or very little reduction in diversity.

Perhaps if this DE is KDE. Gnome devs aren't interested in a configurable DE.

> If you want the service supervised, there's supervisord or daemontools or while true ; do flakeyserver; done.

Or systemd, which is fine for many use cases.

That's cool! Do you know how RenrakuOS compares to Singularity and Midori? (IIRC they were also managed and ran .NET stuff)

Hey, does MNT Reform run coreboot?

It wasn't an easter egg, it was advertising. Preinstalled in my fucking web browser.

Dude, Wordpress supports RSS, and it powers the web. For those that use it, RSS works just fine.

Resolution isn't really brute force search, in that it doesn't search all possible solutions at random; the search is directed by the programmer's rules.

But yeah, it involves quite a lot of backtracking, that happens when the resolution engine needs to go back and try something different. When this is a problem you can sometimes use the cut rule http://www.cse.unsw.edu.au/~billw/dictionaries/prolog/cut.ht...

You can't take the code as-is and turn it into proprietary code. You need to build a derivative work that contains the permissive code plus some other proprietary stuff.

This confusion/imprecision is only common among non-technical people. When a software project describes themselves as open source, in the overwhelming majority of cases they actually mean this https://opensource.org/osd-annotated

I would add Concepts, Techniques, and Models of Computer Programming. It's about programming paradigms in general, and helps in contextualizing functional programming in a broader context

https://www.info.ucl.ac.be/~pvr/book.html

it's probably better to use capabilities (as in: having a secure handler to some resource means having some kind of access to it), instead of ACLs. As in Sandstorm (see https://docs.sandstorm.io/en/latest/using/security-practices...)

(note that URLs can't be a secure handler, since it's just a string that anyone can create. But a URL plus a cryptographic signature could be)

And it's due to bloat; the same kind of bloat that leads people to add megabytes of javascript and other resources to simple articles.

Unsafe Rust has a little less rope than C because there are less cases that can lead to undefined behavior (see https://doc.rust-lang.org/nomicon/what-unsafe-does.html and https://doc.rust-lang.org/reference/behavior-considered-unde...). However, once you trigger UB, it's the same.

By the way, Rust devs are working on a mathematical formalization of those rules. Here's a blog post about a part of this effort: https://www.ralfj.de/blog/2018/07/24/pointers-and-bytes.html. (There are similar formalization efforts for subsets of C, that led to software like the CompCert verified compiler)

You're building equity with the difference between rent (plus repairs etc) and the mortgage. The renter isn't.