loqi

Because nuclear plants can replace coal plants. Replacing a bad thing with a less bad thing is a good thing.

ditching capital letters instead of punctuation would get rid of more redundant characters.

Early 1800s: "Then why is slavery still legal in England et al?"

Right now: "Then why is gay marriage illegal in Japan et al?"

Etc. Your point has nothing to do with the drug war itself, it's broad enough to apply to any early-stage progressive proposal.

I am currently facing the grim possibility of a patent with my name on it for a system that's basically a poor imitation of decades-old technology. (But it works great with our other poor in-house imitations of decades-old technology!)

Yahoo's "non" fire sale is a good counterpart to the devil on my shoulder trying to rationalize away my participation. My job is actually pretty great otherwise (especially for the town I live in), so I'm stressed as hell at the prospect of quitting over this. I keep thinking of the Milgram experiment, and how confident I was when I heard about it that I wouldn't have been part of the majority that continued shocking a human being to the point of apparent death. Software patents are an abstract evil by comparison, but now that there's a part of me saying "yeah it seems bad, but it probably won't result in any real harm", I can somewhat empathize with that majority.

I don't really have a point to make, this just seemed like a reasonable place to vent my shame and frustration.

Thanks for the clarification. I'm certainly not claiming that people who avoid the project are somehow "less important" as a result of their decision. And I wouldn't doubt that it's personal for them - "mere ideology" also seems like a pretty personal thing!

I think we agree that Urbit would benefit from a larger, more diverse user/contributor base. What wouldn't? We're just ascribing agency in different places. I view the claim that Yarvin is excluding people as a sort of rhetorical sleight of hand. What he's actually done is 1) publish some really unpopular opinions, and 2) build Urbit. It is entirely possible to evaluate 2 on its own merits[1]. So I'm disappointed to see so many people write it off for other IMO less relevant reasons.

It reminds me a bit of a "Christian-friendly" Linux distro I once saw that omitted software written by known homosexuals. Would you also claim that the gay programmers were (perhaps inadvertently) excluding a subset of Christians? I suspect most people would agree in this case that agents of exclusion are the ones actually performing the exclusive act, rather than ones who happened to be "the wrong people" from another group's point of view.

[1]: This is true even in the presence of a strong political influence on the technology. I honestly don't see much of a connection between Urbit and Moldbug's politics, but then the latter never made much sense to me, so maybe I'm missing something. If there are politically objectionable aspects to the software, then by all means object! But plain old guilt by association is a weak argument in any context, doubly so in a technical one.

I'm not sure where you're getting this. The system is explicitly designed such that the author can not ultimately shape the network into whatever he wants. The only real control stars and galaxies have over the rest of the userbase is that if you want to send a packet to someone who you don't already have a direct connection to, you need at least one star willing to route your traffic. The ownership of these pieces of network infrastructure is intentionally fragmented to prevent the kind of control you're talking about.

What you're describing sounds more like the web as it currently exists under the benevolent rule of King Verisign.

How so? Sharing arbitrary objects via memory requires some form of coordinated memory management. So you still need a process-wide GC, meaning you're probably stuck with that 30% hit from thread-safe refcounting.

And all the other locking issues are still in play. How would you share a list with another interpreter such that they don't both have access to the same list items? Any solution that looks like a deep copy isn't going to be much better than just serializing across a process boundary.

Ah. So basically this[1]?

[1]: https://gist.github.com/djspiewak/3a6ff436865d9e5794e4

I mean, I guess you're technically correct: If nothing else, the impact of his views on the project is that it results in the exclusion of people who choose to exclude themselves from projects created by "the wrong people".

But of course that's trivially true of all projects, so why do you think it's such a problem in this particular case? If you answer "because his views are really bad" while acknowledging that they otherwise have no direct bearing on the technology, you're basically saying "because he's really unpopular".

I have no love of Yarvin's politics, but that sort of cure is worse than the disease.

Well, if you define "comfortable tolerating his garbage" as "contributes to Urbit despite it being Yarvin's project", then tautological assertion is tautological.

There is certainly some self-selection for people who don't throw tech babies out with political bathwater. I count myself as one such person. I mean, I continued using Javascript and Firefox even after hearing about Brendan Eich's political contribution! Feel free to draw incorrect inferences regarding my opinion of gay marriage.

I have also toyed around with Urbit, and have (in a sense) made minor contributions. Feel free to draw incorrect inferences regarding my opinion of Yarvin's political writing.

Rust disallows mutation of multiply-referenced data, which prevents things like iterator invalidation and data races.

Speaking as someone who's been following the project for a few years and once actually bothered to learn Hoon, your first paragraph is probably the best criticism of Urbit I've seen. I do think there is an interesting system buried under all the obfuscation, but the uncritical groupthink within its user base is obnoxious. I kind of doubt "produce a vanguard of true believers" is a primary goal of the project, but Yarvin doesn't really seem to discourage that behavior either.

That said, the old "it's just typical Moldbug" trope isn't much better than the propaganda his followers spout, and the rest is pretty weak too. AFAIK, the Urbit term for "file" is "file". I don't know which funny weird name you're thinking of for "network endpoint", as that's not really a separate concept in the system. Hoon's cores (which I assume you're at least passingly familiar with) are pretty distinct from closures in any language I know... I mean, do you also complain that Java uses the word "object"? (Forgive me if I omit the part where I ascribe sinister motives to the creators of Java due to their choice of vocabulary.)

As for "implementations of well-known computer science concepts", cue Rich Hickey[1]:

> It's interesting, because Clojure provides almost nothing you can’t find somewhere else. But I do think it occupies an otherwise empty spot in the multidimensional space of language features and capabilities.

In other words, even if your claim is true, it describes almost every project in computing in the last 15 years. We might as well say "oh it's just event sourcing" and call it a day.

[1]: http://codequarterly.com/2011/rich-hickey/

I don't think Hoon's type system actually has a typeclass analogue. As far as I could tell, what it has is something like generics, but in a world where everything is ultimately a noun. IIRC, a previous iteration of the docs explained that "wet gates" (generic functions) are actually required to compile down to the same Nock when "instantiated" at a particular argument, modulo dead code elimination. Didn't look much like ad-hoc polymorphism to me.

A good example is Hoon's maps[1]. They're parameterized on type, but I'm pretty sure those types can't affect the runtime behavior by, say, specifying their own hash or comparison function. Instead, the map implementation[2] hardwires a couple of specific comparison functions[3] that effectively toss the type information and work in terms of the raw underlying nouns.

It is kind of weird that every type carves out a subset of nouns, even function types (or function "molds" or "spans" or whatever... I'll stop calling them types when the Urbit people stop calling it a type system). Hoon's C-flavor really shows when it makes the likes of strlen((char*)strlen) expressible in a purely functional way.

[1]: https://github.com/urbit/urbit/blob/7186219/urb/zod/arvo/hoo...

[2]: https://github.com/urbit/urbit/blob/7186219/urb/zod/arvo/hoo...

[3]: https://github.com/urbit/urbit/blob/7186219/urb/zod/arvo/hoo...

Library gap aside, Lisp has an FFI. If you want to use libpng from Lisp, you just make some C calls. If you want to use libpng from Hoon, you first have to re-implement the functionality of interest in Hoon just to have a sound basis for using the C library (as a drop-in optimization, or "jet").

This obviously makes for slower going, especially near the beginning.

Greg Egan's Permutation City plays some novel games with reality.

Same here. It's why I prefer to line-split conditionals in C-like languages like this:

    if (condition0
    &&  condition1
    &&  condition2)

rather than the usual "trailing operator" style. You can immediately parse the left column as a sort of vertical operator that tells you how the individual conditions are being combined.

But then, I also like Lisp. Prefix notation for "and" gives the same benefit directly, no tricky formatting required.

I quite consciously use "I feel like" to mark lowish confidence statements based primarily on fuzzy intuition or perception ("I feel like it's less work to move my eyes from side to side than up and down").

Contrast with "I think", which I think is more appropriate for statements with at least some deliberate thought behind them, or involve more concrete propositions ("I think Brand X hardware is unreliable", "I think it was last Wednesday").

So the author's example of "I feel like that would look better in blue" looks like a perfectly cromulent use of the phrase to me. If it's mostly a gut feeling about a subjective perception, why not use language that disclaims it as such? Apparently he feels that the disclaimer serves to shield the speaker from disagreement, but I'd have to disagree with him on that.

Looks like it is (was?) targeting roughly the same space as Julia.

I haven't read the book, but from what I gather[1], the explanations were not all good. Getting to and from Miller's world should have required absurd amounts of energy. But as extreme luck would have it, there were "intermediate-mass black holes" positioned ever-so-conveniently to make those trips possible (along with some other stuff). Cherry-picking the physics you like and papering over the rest with a series of extremely implausible coincidences isn't good science or good storytelling.

[1]: http://www.scottaaronson.com/blog/?p=2040

> Unlike many other languages, Ela doesn't make any trade-offs, trying to combine distinct programming paradigms that don't fit well together.

The author may want to tone down that claim - combining Haskell-style FP with dynamic typing certainly entails some trade-offs, regardless of whether or not they think it's a good idea.

DTDs mercifully aside, there's this: http://okmij.org/ftp/Scheme/SXML.html

I'm not sure what example in this thread you consider to be throwing information away - in a case like

    <Term term="slick">

where the attribute name is clearly redundant and exists only to satisfy the syntax, nothing is lost in the transformation to

    (term "slick"

Intuitively, the reason why it balances out is that while earlier items are more likely to be picked, they're also more likely to get kicked out after being picked.

> Have you never had a sporting debate with a friend who's opinion you knew full well going in?

Huh? You mean have I argued with a friend about a belief of theirs I was aware of ahead of time? Yes? If you're asking if I was disagreeing with them just for fun, while pretending to be serious, then no, because I try not to be a jerk to my friends.

I'm well aware of debate tactics and devil's advocacy, and for the most part I think they're epistemic poison. It's great to examine your own arguments for flaws, because you might actually be wrong! But the idea that you would do so merely for the sake of patching up any holes you find is revolting.

I suggest you google "arguments as soldiers" if you're not familiar with the phrase. Not for the sake of learning or gaining perspective or anything, it'll just help you understand where I'm coming from so you'll be better-equipped to take me down.

> The point of good argument isn't to convince the other party they are woefully wrong and everyone should just eventually come to the same conclusion.

Applied to both parties in the argument, yes it is. Argument is digging for truth. The most productive outcome is for some or all of the parties involved shift their beliefs to more accurately reflect reality.

Just to clarify - when you argue, are you attempting to present the actual reasons you believe your point to be true? If not, then you are arguing in bad faith, and contributing heat to the discussion rather than light. If you really are arguing in good faith, then it's just plain crazy to strengthen your position upon being confronted with flaws in your reasoning.

> Some debate for sport/fun

In the context of a serious discussion, I believe the term for this is "trolling".

Good point, how about

    grep -f - 10-million-combos.txt
    <password>
    ^D^D

> C is great for systems and some application programming, C++ is rubbish

This is a bizarre claim. C++ has its problems, but the fact that it allows zero-overhead abstractions over common low-level boilerplate is a seriously non-trivial advantage over C in most areas where C is otherwise a good fit. What compelling advantage does C retain over C++? Faster compiles and being easier to learn are nice and all, but hardly slam-dunks.

C++98 (maybe earlier) has a similar feature:

    if (mytype* p = find_or_null(blah))
        foo(*p);

Still have to dereference p, but at least it's only in scope when doing so is safe. Also goes well with auto and std::optional:

    if (auto opt = find_or_none(blah))
        foo(*opt);

I'm sure that point is not lost on researchers, but yeah, factoring in the effect of existing conditions is easier said than done correctly.

Didn't hang onto any links, sorry. The stuff I saw will probably turn up in a search for "alcohol" and "total mortality", though.

Speaking of recommendations that lead to heart disease, three sarcastic cheers for massively understating the risks associated with abstinence from alcohol. Mostly I just hear "moderate consumption is associated with some health benefits", which isn't anywhere close to conveying the findings (questionable, as always!) that not drinking is almost as risky as "heavy" drinking. Especially considering that you practically have to be a raging alcoholic to fall into the "heavy" category.

I've gotten in the habit of adding trailing whitespace when I comment out code or do any printf debugging. It's still quick, but then git yells at me if I try and commit it.