protomikron

For Python, you can get most packages as non-root via `pip install --user $package` - but you are right, you might need root if these packages depend on system libraries (that they often wrap).

However, it maybe should not be a requirement. AFAIK nix allows you to install stuff as a normal user (and so does dnf on Fedora, but it depends on the package).

There is something seriously wrong with your number (struggling to serve 20 people).

I do not have experience with Ruby, but I think it's similar to Python (in performance) and even if it's let's say 5 times slower (which I don't think it is), a webservice on a simple machine (workstation) in Ruby can easily serve north to 1k (or more) requests per seconds (behind nginx or apache or whatever), and in no way would 20 users be a problem.

It doesn't matter if that's async or not (note, not being async does not rule out concurrency or parallelism), but there was something seriously wrong with your application (if you have to serve long-running tasks, you have to make a msg queue anyway and shouldn't do that in your HTTP response directly). You may gain from async if you are IO bound, but with 20 users you are not IO bound, believe me.

Does anybody know something about the main differences to the first edition? Is it the same HACK computer (and stack, with assembler, high-level language, etc.), or did they change that?

The original architecture had some caveats - e.g. no external interrupt capability, so IO was implemented using busy polling and inspection specific IO-mapped memory regions (I don't blame them, as it made the book more concise and you can not cover everything) and there has been discussion about a HACK-2 from the community, so it would be interesting if somebody knows more.

You are doing that a lot recently, so a disclaimer would be nice (that you built it and also run a dev business around it).

Not that IHP is bad (the batteries included approach for sure is a good idea), it just feels a little bit disingenuous otherwise.

You underestimate how hard it is in large companies to actually speak to the people in charge that can help you concerning your problem.

Did users pay a not unsignificant amount (let's say > 25) for restricted monthly API usage?

Because because if they were on a free plan, why did they get API access anyway - that does not sound sustainable.

Thanks for mentioning that, I think do this date it's one of the very view 3D games with destructible terrain. I remember in particular one testing level (maybe it was just in the demo), where you were put in a hall with some explosives to experiment with (probably to showcase the engine). When I was a kid I remember that I wanted to create a U-formed tunnel around the hall and was pretty impressed when this was indeed possible (and had respect for tunnel engineers as it's hard to get the direction right).

      #####################
     #                     #
    #   +---------------+   #
     #  |               |  #
      # |               | #
       #|               |#
        #               #
        +---------------+

    +|- ... original hall/room
    #   ... tunnel

I was really impressed at that time and frankly I still am. Good times.

EDIT: The level was called glasshouse. This video might be useful: https://www.youtube.com/watch?v=o8KeFgzqsPQ

Congratulations to the release.

I am a little bit skeptic about your running example, the "ML Editor". A model that helps you asking "good" questions, e.g. on StackOverflow.

Isn't that like an extremely complicated problem, I would even say AI hard? How do you want to evaluate if a question is "good" (and sure thing, it's not the number of upvotes it gets)? Is there a working example of such an editor in action, because I highly doubt that this is currently possible.

> The original game was written in Flash, and this version was apparently written by Simon Roth

Thanks, I did not know that at all - I know VVVVVV (Linux version) and Roth rang a bell - it's the same guy that wrote (writes? the game has a very long development story) Maia - a space colony simulation/game.

Unreal is not really open-source and has a restrictive license.

Reminds me of the following quote:

> If you wish to make an apple pie from scratch, you must first invent the universe.

- Carl Sagan

> Libraries, tools, snippets, SO questions, etc. And many of those are still in 2.7 or at least need to specify different solutions for 2.7... It is still a pain.

Admittedly there were some libraries that took a long time to switch, but at this point there is no serious library left, that did not make the switch.

> I think that's a great set of choices. I wish more webware were organized like that

Agreed. This is the way forward for most software monetization (in case of web applications): Have a FOSS licensed application, where you can pay for a hosted version. I think this is a fair model where you pretty much outsource devops for the software to the company who builds it.

If you want to self-host it (maybe legal or security reasons), you can do that without cost or hire their consultants in helping you doing that.

How does that compare to https://bellard.org/tinyemu/ ?

Nice, thanks! :)

> HN's app server runs on a single core, so we don't have a lot of performance to spare!

That's interesting. Is there any more information about HN's tech stack? I know it's built on top of the Lisp dialect Arc, but I wonder about the server specs and would be happy to be pointed at some resource.

Although I experienced HN being down, I guess the overall uptime and availability is pretty decent. Keep up the good work!

> The major DEs like KDE and Gnome3 are full of exploits and memory leaks.

Sry, but that is just not true.

> [...], interprocessor communications system called the "conveyor belt"

Is that where the Mill architecture has the belt concept from? I think i heard some belt concept in the Mill's architecture's context.

> Also, why does Euler's constant appear all over the place?

That is just a natural consequence.

> Eh, you're technically correct [...]

The best kind of correct. Calling it O(n) then is the best way to express the performance improvement - I think that's the whole point of Big-O notation.

However I agree that for smaller n one should not underestimate the constant factor impact.

It is indeed a cool project. However I am interested how they make money? Their apps seem to have IAPs, or how does their business-model work?

Ok, I admit that 99% was exaggerating, but you sure should make availability of gitlab.com your main focus - and you promise that for years to the users (linking at issues etc.).

Btw.: Your links are http, and the https version has `SSL_ERROR_BAD_CERT_DOMAIN` - you should check with pingdom.com maybe?

GitHub's uptime is way better than GitLab. I am not really sure gitlab.com even reaches 99% availability (not to mention 99.9%).

GitLab may well be focused on providing full-stack dev-services (VCS, build-server, CI and stuff), but in the end they are a hosting company - and for hosting, uptime is one of the most important metrics.

EDIT: 99% was exaggerating, but I got so many 50Xs the last days that it was from time to time unusable.

> Nah at least in chess all the grandmasters lean heavily on the chess engines, including studying top games between the best AI

They may use it for training and analysis, but they don't play their style - they play an inferior style (not to dismiss their achievements).

How does that differ from

    $ ssh -R2345:localhost:80 user@example.com

And then going to example.com:2345 (if you want to e.g. forward HTTP)? I mean you need a remote node anyway for that to work?

Wow, that post blew up.

Like most engineers I respect JC for his incredible work, but I really think AGI is far off and at the moment would be very surprised if there is significant progress in the next years to come.

I also want you to read this extremely well written (old) blog post about the topic and I don't think much has improved since: https://karpathy.github.io/2012/10/22/state-of-computer-visi...

> [...] but the core concepts, that actually work, things like batch normalization, gradient descent, dropout, etc are all relatively simple.

They may be simple, but it's controversial why they work. For example dropout is not really used much in recent CNN architectures, and it's just - I don't know - ~5 years old? So people don't even agree what the core concepts are ...

Yes - it's probably the case, because there is nice theory behind it (DFAs for lexing and grammars for parsing).

What I can really recommend (and me and others have recommended it already countless times) is TECS: The elements of computing systems (also know as "Nand2Tetris"). Although it also covers other parts like the hardware stuff it lets you implement

    - an assembler
    - a VM
    - a compiler that compiles a simplified Java-like language to this VM

It takes a bottom-up approach, but if you go through all projects you get a really good view about the big picture. However as it does code generation via an intermediate VM language it doesn't really touch register architectures as a compilation target. Anyway I highly recommend that book.

My humble opinion: do not get the Dragon book - it puts too much focus on parser theory and implementation which is in my opinion not the hard part of compiler construction.

Most modern languages use a handwritten recursive descent parser anyway and the interesting part starts after you have the AST (code generation and register allocation).

Fun fact for all of you:

Some time ago (around ~10 years) this guy (the presenter) was internet famous for being a Rubik cube speed solver and making tutorials and videos about that: https://www.youtube.com/watch?v=609nhVzg-5Q