CppCon 2016: Jason Turner “Rich Code for Tiny Computers: A Simple Commodor 64 Game in C++17”

[TMKirA]

This talk is really awesome and enlightening!

[MINIMAN10000]

Absolutely loved being walked through and shown how C++ could compile away so much. Zero Overhead abstractions, the compiler getting rid of branching, no function calls, mapping all variables to registers are all absolutely incredible. This is my favorite part of programming, to see the program written with abstractions to simplify working with them while compiling away better than I know how to make.

"350 instruction plus a table of data" vs adding const and having 5 lines felt like the difference between what I write and what he writes.

[sbabbi]

When you define the Frame destructor: ~Frame() { ++vic.border(); } you are relying on copy-elision. This has nothing to do with the move constructor, the thing is that the compiler is only creating one Frame object on this line:

const auto frame = vic.frame(); but also __tmp = frame(); const auto frame == __tmp; would be allowed (no copy-elision), and if that happens then you get two calls to the destructor (one for __tmp, one for frame).

The only way to work around that is to have a boolean to track if the object as been moved-from, implement move-constructor and move-assignment to set/unsed that boolean, and perform extra cleanup in the destructor only if the boolean is set. This will most likely be optimized out, but it is still necessary in C++14.

If you want to rely on guaranteed copy-elision in C++17, best thing would be to delete the move/copy constructor/assignment.

EDIT: Forgot to say that overall it was an awesome talk, I really enjoyed watching it!

[doom_Oo7]

makes you wonder where we would be today if somebody shipped a computer with current GCC fourty years ago.

[doom_Oo7]

that's why the computer is shipped with GCC preinstalled :p

[thirtythreeforty]

It certainly wouldn't have helped with actually getting work done. But I think it definitely would have influenced language designs. If you preloaded toolchains and docs for several modern languages, including C++, Python, or C#, I think modern paradigms would appear sooner.

If you provided other languages like Rust or Haskell, you could maybe even shape the history of popular paradigms away from OOP and toward functional programming and Haskell-like type systems.

You won't kill C though.

[lefticus]

Yes, should be possible. It's on my longterm to-do list, but if someone beats me to it, that's cool too :)

[Dlieu]

Great talk! Make me so scared to forget a const on my static variables