Chirono

Except it turns out to be "drop millions of allocations by changing an exponential recursive algorithm to a linear scan that does a different (and incorrect) thing". So it seems like the linked list part of it was incidental.

The paper in this post doesn't use neural networks at all. It also includes the time to train the model in the sorting time, which the paper you linked doesn't. NN-sort trains on historic data to sort future data, which requires the distribution to be roughly the same, whearas this algorithm learns online.

Further down the author says it runs at 60fps, without much headroom. So quite some way behind modern GPUs - the latest doom game can run at 200+ FPS and is vastly more complicated.

That, combined with the cost of the hardware in comparison to a digital copy makes me think this is unlikely to be particularly useful to the games industry. It's incredibly impressive though!

From what I understand, Firefox blocks third party cookies by default these days.

https://blog.mozilla.org/blog/2019/09/03/todays-firefox-bloc...

I would hope any good principal engineer spends a decent amount of time considering switching costs and impacts of new technology. Sounds like this isn't your experience though?

One piece of feedback: please don't require unique usernames. You already have a unique email address, and it's a pain to have to remember another unique username for another site when the first thing I try isn't available.

There's a good summary of the paper by the authors here, for people who don't want to digest the pdf: http://gradientscience.org/adv/

Google recently created MorphNet which can take a large network and do the pruning stage automatically. https://ai.googleblog.com/2019/04/morphnet-towards-faster-an...

I suspect you're just trolling, but for anyone else: This is true for any bounded input, yes, but doesn't hold for an infinite domain.

I think that's the point they are trying to make; that doing this with GCP is super boring and easy.

This translates well into advice for startups: Don't obsess over finding the perfect solution, but focus on getting something then making constant improvements to what you have. Don't try to jump to a global optimum straight away. There are always a huge number of options to choose from, and you can always improve.

Just a small correction: Improbable are making a cloud gaming platform, not a game engine. https://improbable.io/games/blog/how-spatialos-works-with-ga...

I can't recommend the Every Circuit app enough (http://everycircuit.com). It's an interactive, real time circuit simulator. I've been using it for the past couple of years to teach myself electronics. I'd read about how, for example, opamps worked, but it wasn't until I could play around with them and try them in virtual circuits that I really understood how to use them. Honestly, for learning, it the best resource I've come across.

It strikes me that this is similar to the 'no true ai' paradox, where as soon as a program can do something, such as beat a human at chess, then it stops being AI and starts being just computation. As soon as something philosophical becomes rigerous or well understood, we stop calling it philosophy and start calling it mathematics.

Don't know why you are being down voted. Even if you are incorrect, it would be interesting to hear why. Anyone care to comment?

Really nice idea, but it seems like quite a reliable way to win is to fill all the squares in red, and then change all the places it tells you are wrong.

Perhaps rather than pointing out which cells are wrong, highlight the group/row/column that break the rules instead. That might make it slightly harder.

Wait, they've got rid of unique pointers? When did that happen? They were there a couple of months ago. That was one of my favourite language features...

  On the backend, Hacker News runs on one core, and Graham calls this a “remarkable feat of scaling.”

Wow, Really? I'd say that is pretty remarkable, yes. Is there anywhere that goes into more detail about this?

I find this comment interesting given the recent (ok, continuous) talk about not using maths puzzles in programmer interviews. This is perhaps an interesting real-world case that demonstrates how a mathematical outlook leads to much cleaner code.

Ok, solving this kind of thing is rare, but still...

Instead of failing with an error at compile time, it will emit code that, if run, will fail with a 'type error' at run time.

Hmmm, you're probably right. I had in mind something like GenStgExpr[1] that make up the STG type in GHC. I'd imagine with all the optimisations, serialization and code-gen that is based directly off that data structure, any significant change will have at least 1000 line nock-on effect. Perhaps I'm over estimating though. I'd guess it comes down to the size of the project.

1) https://github.com/ghc/ghc/blob/master/compiler/stgSyn/StgSy...

Sure, for small programs, that's probably a better approach. But this could really come in handy when your program is split across 100 files and you change a central data type. Now you can update and test in batches without having to refactor 1000s of lines in one go.

Actually, GHC has been using GIT for about a year now. There was a lot of discussion but darcs has (mostly) been dropped. There are a few libraries that are still darcs-controlled but generally because nobody has got round to migrating them I think...

Regarding 2: You're correct, the main order book is public and usually anonymous. There are also non-public books called dark pools where you cannot see what other people are bidding. You are also correct in supposing that a lot of meta-games go on, but dark pools don't remove this entirely; they just change the rules. For instance you could, if it is allowed, submit a tiny orders in increasing price until it gets filled; then you know something about the price in the pool.

  Its never been legit for such burglars to gain access to a building and leave a note describing the poor security on the CEO's desk.

Unless, of course, you happen to be Richard Feynman. Which most of us aren't.

http://www.silvertrading.net/articles_lagniappe_01_richard_f...

Care to elaborate on that? I'm fairly entry-level when it comes to vim and I'd be interested to hear some good examples of what it can do over something like sublime.

  Use enums for your op codes, and a switch statement (depends on compiler). If you use enums and a switch, the compiler can generate a jump table because it knows the enum will always be in a certain range. Much better performance than a bunch of if/else statements.

You can generate some beautifully simple interpreters this way, but switch/dispatch is not the way to go for high performance. Jump tables like that are not a good candidate for optimisation by compilers and they kill any sort of branch prediction your CPU is doing.

Here's an post (and follow up discussion) by the author of the Lua, where he explains why the main loop is written in assembler and why it beats compilers:

http://news.ycombinator.com/item?id=2588696

Thanks, uniqueness typing has been a bit of a hobby of mine for a few years, so I'm familiar with 1 & 2. Uniqueness in system-level languages, however, is not something I know so much about, so something like 3 is pretty interesting.

Do you know if there is any explanation of 'unique pointers' and 'unique closures' anywhere? I'm quite interested to see some of the decisions, especially wrt the type-system.

There is a (fairly) simple proof of that, however. You may well be aware of this already, but in case someone hasn't seen it before:

  Each comparison of objects provides one bit of information.
  So k comparisons provide k bits of information, or 2^k possibilities. 
  Therefore to distinguish between n options, we need at least log_2(n) comparisons.
  There are n! ways of ordering a list of length n.
  log(n!) ~ n * log (n) 
  So to sort a list of length n, we need at least O(n * log(n)) comparisons.

It certainly requires more maths than just counting 'for loops', but I find the explanation surprisingly elegant.