That's exactly what I do, don't mind hanging out once a week if you're up for it

Here is a review: https://www.eurogamer.net/articles/2018-02-05-sleep-is-death...

Why not share the seed of the map? This in combination with the coordinates visible on screen would make it possible to check if there is cheating involved. It would be even better if the seed was generated and handed out by a trusted party. Do all the speed runs live and it would be quite hard to cheat.

Loot rates are not related to the world seed. The problem here was that he modified loot rate tables. The world seed only matters for the world generation.

No, it wouldn't. He is accused of cheated by messing the probabilities of Blaze drops and Piglin trading.

The map seed is not related to either.

Although the color of the card is black the official name is Centurion

You're disappointed with the Silicon Valley bubble, not technology perse

A variation on Brownian Motion: https://en.wikipedia.org/wiki/Brownian_motion

The Go network stack already makes use of epoll and kqueue: https://golang.org/src/runtime/netpoll_epoll.go So I'm not quiet sure why this would be faster since almost all I/O in Go is event driven, including the networking stack.

The benchmarks at the bottom of the readme show quite an improvement (with a single thread it seems).

I would speculate the performance win is because there is no stack switching and less channels.

I've done lots of event loops in the past (eg hellepoll in c++) and think that the cost of that is on the programmer - keeping track of things, callbacks, state machines and things and avoiding using the stack for state etc is all hard work and easy to mess up.

I am reminded of this post I saw on HN a while ago https://www.mappingthejourney.com/single-post/2017/08/31/epi... Ryan Dahl, creator of node.js, would just use Go today ;)

> I've done lots of event loops in the past (eg hellepoll in c++) and think that the cost of that is on the programmer - keeping track of things, callbacks, state machines and things and avoiding using the stack for state etc is all hard work and easy to mess up.

I very much agree. In the past, I have had quite some fun developing a few streaming parsers using Node.js, which also uses an event loop. And while these parser worked relatively good and efficient, debugging them was not an easy task. In addition, understanding the code is also a though challenge, especially for people other than the original authors.

When I started using Go more and more, I really enjoyed the different I/O-model using goroutines and blocking function calls. It also has a few drawbacks but the mental model is a lot easier to reason about.

> I've done lots of event loops in the past (eg hellepoll in c++) and think that the cost of that is on the programmer - keeping track of things, callbacks, state machines and things and avoiding using the stack for state etc is all hard work and easy to mess up.

This is improving, even in C++. This is what the core loop of a line-based echo server could look like in C++17 (and something very similar compiles today on my machine)

    void echo_loop (tcp::socket socket) {
        io::streambuf buffer;
        std::string line;
        std::error_code ec;
        do {
            ec = co_await async_read_line (socket, buffer, line);
            if (ec)
                break;
            ec = co_await async_write (socket, line);
        } while (!ec);
    }

Wow. That looks really simple.

Unfortunately it's just exposition, but here[0] is a version that works with Clang 5 + Boost

Echo specific code starts on line 167. Everything above will hopefully be provided by the standard library once both the Networking TS and Coroutine TS merge in to C++20.

One nice thing about lines 1 - 165 though, is that it demonstrates how easy it is to extend the native coroutine capabilities in C++ to support arbitrary async libraries, even if the author of those libraries didn't know anything about coroutines. All this happens without breaking the ability to call these coroutines from C. You can even use async C libraries that only provide a void* argument to your callback.

[0] https://gist.github.com/anonymous/d9a258136431a352516122d1c9...

Yeah, but that's with 1 maximum thread. The whole point of Go is to use green threading to your advantage.

While goroutines are cool, there's not the whole point of Go for me.

Well, I guess because the runtime has to do a bunch of work to dispatch the events to the appropriate goroutine that is blocked waiting for that event. Switching and synchronization between goroutines is cheap, not free.

And this solution does somehow not switch between goroutines?

No, the event loop is just one big goroutine that calls all the handlers directly.

Which...is the same as “not switch between goroutines” no?

Correct. I'm fairly certain he was agreeing with you.

(I think there was an edit)

I think a new Half Life game would be the perfect opportunity for Valve to showcase their virtual reality kit. So far there are no blockbuster VR games and the Half Life franchise (Portal included) has a history of being very innovative (e.g. HL2 using a physics engine for the narrative, HL1&2: story told through level design). There is a lot of potential to use immersive virtual reality to enhance the story telling.

They said years ago that HL3 would not be a VR focused game but I suspect that has changed by this point. There are still issues with normal locomotion in VR and nausea so I suspect either there will be some new idea in that realm or HL3 will take on Portal technology to explain teleportation based movement.

Look another product they will retire in about a years time.

And don't forget simplicity as a core design feature of the language. That alone is worth sacrificing generics for ;-)

Who gets to decide what is simple or not though ?

Coroutines seem like something that is more complex to me than generics.