m0th87

For me, psychedelics (temporarily [1]) blew away the unfortunate habits that made me feel compelled to size other people up, or to care much for how others were sizing me up. From the outside, this probably looks like laziness or shallowness, because someone who has "peeked behind the curtain" may not be motivated by the same external forces as before.

1: That, to me, has always been the unfortunate aspect of psychedelics - the moment is fleeting. Luckily, meditation and just generally being present has been much more sticky.

> So a GC with bounded pause could be used in a realtime system assuming you could guarantee the explicit bounds.

You can't guarantee explicit bounds on when a given resource will be collected with GC. Bounded times can provide upper bounds on GC pass runtime, but they do that by potentially deferring further collection. Those deferrals make it nondeterministic.

> And most kernels don't need to be realtime unless they are realtime kernels.

That's not true. Most (all?) kernels have internal realtime needs, e.g. responding to interrupts.

There is a way to write a kernel with a GC'd language, as Niklaus Wirth has demonstrated, by circumventing the GC where needed. But the critique I was bringing up was simply that there's no such thing as a realtime GC.

Despite what the Nim documentation says, realtime and garbage collection are mutually exclusive (unless you count non-deferred reference counting and give up on collecting cycles.) Setting maximum pause times doesn't change the fact that the garbage will be collected nondeterministically, which is a problem for kernels.

Would it be possible to use rump kernels with this to get support for the myriad hardware out there from the get-go? Or are QNX-esque microkernels and rump kernels mutually exclusive for some reason?

Here's a script I hacked together that simplifies gource video generation a bit: https://github.com/dailymuse/gg

In practice, Citizens United obviated any US regulations on political advertising. A rich patron can pour as much money as s/he desires into advertising on behalf of a campaign, and we don't have a right to know who that person is.

If apple had the same market dominance as Microsoft did in the 90s, they likely would be pegged for antitrust violations.

It gave me a spectacular job (CTO of a 150-person YC company) and several job offers. I also hired quite a few engineers through HN. HN jobs (both the YC job postings and the monthly threads) really work! It's no exaggeration to say the site has shaped my life.

> The advantage of rusts error handling is that it is explicit. The compiler knows that a function might result in an error and forces the programmer to deal with it, or pass it along.

Checked exceptions are explicit as well, though I'm not aware of a language that _only_ has checked exceptions.

> I also suspect that there might be a performance benefit but I could be completely wrong about that

Yes, this is a big advantage. Stack unwinding is very expensive.

Here’s a talk of someone who’s reverse engineered CAN buses and made a python library to help: https://www.youtube.com/watch?v=3bZNhMcv4Y8&app=desktop

Ah, that makes sense!

> For example, register allocation is a tedious process that bedeviled assembly programmers, whereas higher-level languages like C++ handle it automatically and get it right every single time.

Ideal register allocation is NP-complete, so a compiler can't get it right every single time.

I'm not sure how good in practice modern compilers are at this, but would be curious to know if there's some asm writers who can actually consistently outperform them.

Somewhere on the sourceforge ether is an open source parallel of BonziBuddy that I made in middle school, because I thought virtual assistants would be the wave of the future...

Steam was released before HL2. I remember playing HL1-based games on it.

Coincidentally, I just tried this out earlier today. `pageRank` yielded a stack overflow, and `pageRank.stream` yielded an OOM error. The graph it was run on was large, but not unreasonably so. Haven't dug into the cause of the errors yet.

This makes sense, and I know it's why Rust abandoned green threading. But I can't help but worry that the focus on async I/O in Rust as a way of avoiding this issue is going to bring the language down a path that isn't as ergonomically pleasant as Go or Erlang's M:N threading for things like highly concurrent web services. Do you share this concern, or do you think Rust can achieve the same level of ergonomics without the impedance mismatch?

Game servers don't do hard real time. That would be overkill, and requires specialized operating systems typically used for niche applications like robotics; e.g. https://en.m.wikipedia.org/wiki/RTLinux

Looks like it can even handle garden path sentences [1] like "the complex houses married and single soldiers and their families."

1: https://en.wikipedia.org/wiki/Garden_path_sentence

My company has seen major discrepancies between what this tool gives back vs how the page ultimately ends up getting indexed.

See also Raganwald's Why Why Functional Programming Matters Matters: http://weblog.raganwald.com/2007/03/why-why-functional-progr...

I don't really get how that's a critique of the ability to represent complexity on a computer well. After all, isn't a human mind constrained by P ?= NP in the same way as a computer architecture?

You know, I would've agreed on November 7th, but our president-elect has called for this.

Microsoft's statement says "it will remain important for those in government and the tech sector to continue to work together to strike a balance that protects privacy and public safety in what remains a dangerous time." That to me comes off as quite chilling. Why couldn't they just say no, they wouldn't help? Why the double-speak?

Yeah, Julia and lisps demand more nuance than static or dynamic labels. This goes into the details for Julia: http://stackoverflow.com/a/28096079

Compilation strategy and code hotswapping are independent of static vs dynamic types. Java is statically typed, however its implementations support interpreted execution and code hotswapping.

> It's whatever a drug dealer decides to sell you and/or call it

That's the point. Ecstacy does not have a precise definition. MDMA does. Given this is a trial, it should be labeled what it is.

fwiw, nightmare is just a thin layer above electron's browser.

Sure, but on an evolutionary scale, humans and other dependent species have time to catch up to the changes. That's not true for changes wrought from GM.

In the US, an FTC commission concluded the same thing a few years ago: http://www.wsj.com/articles/inside-the-u-s-antitrust-probe-o...

Our company had a horrible experience with Elastic Cloud:

1. We were provisioned hardware that was less performant than promised (HDD rather than SSD-backed.)

2. The dashboard suggests significantly lower memory utilization than reality. We spent days going down the wrong rabbit holes, when we were getting timeouts simply related to out of memory errors.

3. When there's a shard failure, your only option is to reach out to support. You can't upgrade the database or anything.

We switched to Bonsai and it's been much more stable.

There's also Nightmare, which is built off Atom. We ported all of our PhantomJS-backed headless tests to Nightmare recently, and it's paid in dividends: http://www.nightmarejs.org

I've had a great time with Tokamak: https://vertexclique.github.io/tokamak/