#siraben has taken my term-rewriting language #Qfitzah and seems to have gotten it to bootstrap a #C compiler. #bootstrappable #compilers
on 02026-09-02Anton Ertl’s comments on getting tail-call optimization out of GCC in #C for the GForth #Forth implementation — Python got there first, he said, and congratulations.
on 02026-08-10endoh1 #IOCCC entry is shaped like a Nixie tube. #C #small-is-beautiful
on 02026-07-30Bjarne #Stroustrup #interview #video: “I ... probably know most of #C++? But it’s not in the front of my mind most of the time. I look it up when I need, need it.”
on 02026-05-30#Interview with Bjarne Stroustrup. “One of the things that has kept #C++ viable is the zero-overhead rule: What you don't use, you don’t pay for. Making member functions virtual by default would violate that and make it much harder to provide efficient concrete types. Making virtual the default is “obvious” to people who think of classes as huge things living in complicated hierarchies.”
on 02026-05-22#stage0 #C compiler in #asm. #compilers
on 02026-05-20#Itanic’s Not a Thing (#NaT) bit can cause passing too few register parameters to a #C function to crash the program because the compiler tried to spill a NaT value to the stack. Also leaf functions that don’t create their own stack frames can get an Illegal Operation fault for “writing a stack register that lies outside the current frame”; SPARC-like sliding windows, I guess, but by variable amounts. #history #gross #facepalm
on 02026-04-29Interdata 8/32 bit shift instructions made Dennis Ritchie say “Shit!!” #history #C
on 02026-04-14as of C23 they’ve standardized the GCC behavior where unsigned-to-signed casting in #C does the obviously intended twos-complement bit pattern reinterpretation instead of being implementation-defined
on 02026-04-03#Za3k got a no-dependencies #qr-backup restoration program working with help from Claude; it was 5300 lines of #C, which could be trimmed to 2000, and then minified to fit on one printed page in a tiny font.
on 02026-02-24Norman Ramsey’s C-- ("C minus minus"), a #C subset designed as a targer for #compilers
on 02026-02-09Wingo on using #C as a target for #compilers #toread
on 02026-02-09#Tsoding #screencast #video about #Sean-Barrett’s single-file header-only #C libraries like stb_image_write. Mostly remedial C.
Compound literals (struct point){3, 4} were introduced to #C in ANSI C99
on 02026-01-12#Diomidis Spinellis promising to explain how the #C preprocessor should work on his blog.
on 02025-11-07#PDF by #Diomidis Spinellis explaining how the #C preprocessor should work. #toread
on 02025-11-07#Diomidis Spinellis explaining how the #C preprocessor should work. #toread
on 02025-11-07#GCC discussion on how the #C preprocessor should work, quoting Dave Prosser #toread
on 02025-11-07explanation of #Fil-C #C #compilers for #security
on 02025-10-28incompatibilities in #C and #C++ when porting to #GCC 15, which updates the default version of C to C23, which requires prototypes.
on 02025-10-15incompatibilities in #C and #C++ when porting to #GCC 15, which updates the default version of C to C23, which requires prototypes.
on 02025-10-15#C# has a using statement analogous to Java’s try-with-resources, and since 8.0, a using declaration analogous to RAII that avoids adding another syntactic level of nesting.
“But instead, their faces turned bright white. They slowly turned to look at each other. It was clear that they made the same mistake that many before them had made: believing Try-Finally to be as infallible as things like database transactions.” #humor #C#
on 02025-10-10“#Java Was Strongly Influenced by #Objective-C ...and not #C++...” #history
on 02025-10-08System.Console.ReadLine in #C# doesn’t actually read from the system console, but stdin. But only up to 254 characters by default! And it can still throw an OutOfMemoryException! “Reads the next line of characters from the standard input stream. (...) If standard input is redirected to a file, the ReadLine method reads a line of text from a file. (...) After compiling the example to an executable named ReadLine1.exe, you can run it from the command line to read the contents of the file and display them to the console. The syntax is: ReadLine1 < ReadLine1.txt” #documentation
"Abseil" is “an open source collection of #C++ libraries drawn from the most fundamental pieces of #Google’s internal codebase”
on 02025-09-07“We are extremely pleased to announce the availability of the new “Swiss Table” family of hashtables in Abseil and the absl::Hash #hashing framework that allows easy extensibility for user defined types. Last year at CppCon, We presented a talk on a new hashtable that we were rolling out across #Google’s codebase.” #C++ #Swiss-tables #performance
on 02025-09-07#video of a talk by Kulukundis at cppcon 2017. Kip says, “Presentation about the latest tricks in hash tables. Uses SSE instructions and man is it fast. Good benchmarks against the standard C routines.” Heh: “As with anything like this, benchmarks are the only source of truth you will ever get, and they are lies.” Called "Swiss tables" (because Alkis and Roman, its primary developers, “are in the Zurich office”, and it’s “closed hashing”), supposedly the fastest hash table in the world. “What did we gain? (...) the vague feeling of superiority when we force a difficult decision onto the user. And that is the #C++ way.” You put metadata about which array elements are full or deleted into a separate byte array, along with truncated-to-7-bits hash values, to avoid needing magic sentinel values for your key type. By using SSE matching to look for truncated-hash matches in a 16-bucket group, you can find the candidates in three instructions, which also means that your erase function can avoid inserting tombstones “if any other element in the group was empty”, which seems like a pretty big win actually. Also he mentions “other sizes [than power of 2] with fast modulus”. #algorithms #performance #hashing
on 02025-09-06C23 permits a kind of structural rather than nominal compatibility rule for structs, which allows you to get a very limited form of type-safe parametric polymorphism in #C through the preprocessor.
on 02025-09-02#object-orientation in #C in the #Linux kernel and in #OSDev in general #toread
on 02025-08-27#video of Endoh’s #IOCCC winner, a raytracer written in the #C preprocessor.
on 02025-08-13#tutorial on #undefined-behavior in #C and #C++
on 02025-08-12#tutorial on #undefined-behavior in #C and #C++
on 02025-08-12Chris #Wellons explores how to do interactive programming in #C, following Casey #Muratori’s “Handmade Hero”, by reloading a shared library. #toread
on 02025-07-23Rich Hickey’s explanation of type-safe callback functors in #C++ from 01994
on 02025-07-22Rich Hickey’s #C++ callback library using template functors
on 02025-07-22Casey #Muratori’s keynote about, largely, #disjoint-unions and how it is sad that #C++ doesn’t have them. “I’m not saying OOP was a mistake. I’m saying this [a compile-time hierarchy of encapsulation that matches the domain model] was a mistake.” Also traces the #history of records in #programming-languages through Simula and Hoare’s record-handling paper and the “plex” of Douglass Ross of the MIT Servomechanisms Laboratory in AED, Algol Extended for Design, and also #Sketchpad, which had in-memory records (“chickens”) linked together in circular linked lists, which apparently was an idea he got from Ross (“n-component elements”). Both Ross’s plexes and Sketchpad had function pointers in the records. (But the constraint solver was “the most unencapsulated thing that you could possibly imagine”.) Also documents how Looking Glass in 01998 introduced the #Entity-Component-System pattern in Ultima II Underworld, but really introduced it with Tom Leonard’s Thief: The Dark Project. At 82'40” he points out that he independently invented a worse version of ECS at definitionSIX for Negaman in 01997. “It’s just, I sucked at it, and Looking Glass was good.” Basically his “35-year mistake” thesis is that we almost had ECS in 01963 with Sketchpad, but it took until 01998. He likens 01990s OOP dogma to playing Magic: The Gathering, which I think is insightful. At 136'45” he tells his devotee Ryan Fleury that he has snatched the stone from his hand and may now leave. Nice quote: “You should focus on the hardest stuff. You should say, ‘what solves the hardest problems?’ because we can always then take that and scale it down, and remove things from it or dumb it down, for people to use in cases that aren't as hard. But it’s almost impossible to take something that only solves simple problems and scale it up to something that solves hard ones.”
on 02025-07-22TMS320C3x #C #compilers user’s guide #PDF says, on p. 3-4 (p. 101/301): “All integer types (char, short, int, long, and their unsigned counterparts) are equivalent types and are represented as 32-bit binary values.”
on 02025-06-12On how to do custom #allocators support right in #C, by Chris #Wellons.
on 02025-03-19#math #video #toread about #optimization in #C of Fibonacci number computation
on 02025-03-18on "unity builds" or “amalgamation builds” where you concatenate all your #C source code into one huge file with #include and compile it
on 02025-01-09#VSCode has a “TestExplorer” plugin which has #C# support
on 02024-12-09in #VSCode you can evaluate JS or #C# in the current scope in the #debugger window (“Debug Console”)
on 02024-12-09#C# string comparison and #equality
on 02024-12-09#C# string comparison #tutorial #documentation. “(...) the most common operations[,] String.Equals[,] String.Equality[,] and String.Inequality, that is, equality operators == and !=, respectively perform a case-sensitive, ordinal comparison. (...) Many string comparison methods (such as String.StartsWith) use linguistic rules for the current culture by default to order their inputs.” Also demonstrates Array.Sort and List<string>.Sort with a StringComparer, etc. #equality
#C++ #documentation for unique_ptr with a #tutorial extended example
how to make a unique_ptr in #C++ with make_unique
#introduction to unique_ptr in #C++
"mp-units" is a #C++ header-only library for #dimensional-analysis, proposed for standardization in C++29
on 02024-11-22some complex join #queries in #LINQ. #C#
on 02024-11-22more #C# #LINQ #queries basics
on 02024-11-22more #C# #LINQ #queries #tutorial #documentation: IEnumerable<string> highScoresQuery2 = from score in scores where score > 80 orderby score descending select $"The score is {score}"; “A query expression must begin with a from clause and must end with a select or group clause. Between the first from clause and the last select or group clause, it can contain one or more of these optional clauses: where, orderby, join, let and even another from clauses.”
more #C# #LINQ #queries like IEnumerable<int> scoreQuery = from score in scores where score > 80 select score; for which this is Microsoft’s #tutorial #documentation
#C# #LINQ #queries people.Where(p => p.Age >= 30).GroupBy(p => p.Age) or people.Where(x => x.Name == "Harry Potter").ToList() vs. var barkingAnimals = from animal in animals where animal.Sound == "Bark" select animal; which is “language level query syntax”
a #C++ library for using an #ESP32 as a #USB host. #microcontrollers
on 02024-11-20#C# supports Python-like triple-quoted strings but with some whitespace-stripping rules which don’t apply to its @"" strings, which are also potentially multiline.
The difference between classes (which are reference types) and structs (which are value types) in #C#, but this time in Spanish.
on 02024-09-30The difference between classes (which are reference types) and structs (which are value types) in #C#
on 02024-09-30#GCC lets you associate #asm registers with particular #C variables, either global or local.
on 02024-09-23getting limited recursive iteration in the #C preprocessor (up to, say, 1024 iterations)
on 02024-08-08JeanHeyd Meneide’s story of how <a href="../tag/embed.html">#embed finally got through the #C standardization process
the #C preprocessor can finally do binary file embedding with <a href="../tag/embed.html">#embed since C23
more on #C preprocessor tricks
on 02024-08-04conditionals and limited recursive iteration in the #C preprocessor using pattern-matching
on 02024-08-04Walter Bright’s explanation of #X-macros from 02010 in #C and #D
on 02024-08-04An article from 02001 about #X-macros in the #C preprocessor
on 02024-08-04Application of #X-macros in the #C preprocessor to serialization and deserialization
on 02024-08-04More on #X-macros in the #C preprocessor
on 02024-08-04#X-macros in the #C preprocessor
on 02024-08-04how preprocessor macros work in #C and #C++, explaining when the preprocessor paints them blue
on 02024-08-04how preprocessor macros work in #C and #C++, explaining when the preprocessor paints them blue
on 02024-08-04if #Clang encounters a GCC installation in a directory such as /usr/lib/gcc/aarch64-linux-gnu/8 that lacks some expected files, such as iostream and libc++.a, it may fail to be able to compile a #C++ “hello, world” with the error fatal error: 'iostream' file not found
The #Watcom #C compiler has been released as pseudo-free software (for personal use only).
on 02024-06-30notes on #C++ idioms
on 02024-06-30more detailed explanation of #safe-bool in #C++
on 02024-06-30article on the “safe bool” idiom which was necessary in old versions of #C++ to prevent operator bool from unintentionally providing a conversion to integers or pointers; explicit operator bool solves this problem in standards since C++11
POSIX 2003 (or 2008?) requires open_memstream and open_wmemstream functions for stdio to dynamically-allocated memory buffers, present in glibc since 1.0.x; now they’re proposed for standard #C. Also getline() as a better replacement for gets().
#cppreference’s #C reference, #CC licensed
on 02024-06-30Offline #CC licensed versions of the #cppreference site, which it turns out covers not only the #C++ standards but also the #C standards. Already in Debian as cppreference-doc-en (but seven years old) and with online downloadable archives as well (the latest of which is a few weeks old and only 6MB). #reference #documentation
on 02024-06-30Offline #CC licensed versions of the #cppreference site, which it turns out covers not only the #C++ standards but also the #C standards. Already in Debian as cppreference-doc-en (but seven years old) and with online downloadable archives as well (the latest of which is a few weeks old and only 6MB). #reference #documentation
on 02024-06-30list of “modern” #C++ features: smart pointers, STL containers and algorithms, <string> (and string_view), type inference (“deduction”), range-based for, constexpr, initializer lists for vectors, move semantics, lambda expressions, exceptions, std::atomic, and something called std::variant
in #C++ you can use HUGE_VAL from <cmath> for double-floating-point infinity.
Microsoft's #tutorial #documentation for #C++’s new (as of 13 years ago) range-based for statement. Recommends for (const auto& y : x) or, when necessary, the non-const version.
aha, #C++ since C++11 now has the Java-like for (auto flust : flusts) { ... } syntax. It uses the preincrement operator to increment the iterator, != to test for termination, and flusts.begin() and flusts.end() for the bounds, or if those aren’t found, begin(flusts) and end(flusts) (plus there’s a special case to let flusts be a bare array). The flusts expression lives until the end of the loop, but temporaries within it don’t (except in C++23). But until C++17 you couldn’t iterate over a nul-terminated string with this syntax without defining a special iterator for it. #documentation
#video about #C++ constexpr and #performance by #Daves-Garage (Dave Plummer) using a sieve of Eratosthenes example
apparently if you’re returning a pointer to an object you continue to manage the lifetime of, you should just return a raw pointer in #C++ rather than a smart pointer
on 02024-06-2311-page #PDF #paper proposing a #C++ aggregate initialization change in C++20
on 02024-06-23more discussion of the #C++ aggregateness rules.
on 02024-06-23complaint that #C++ aggregate initialization is not allowed if you have constructors, but you can use the static “named constructor” idiom, or you can create an implicit type-conversion constructor from another type that is a mere aggregate and use double curly braces. Apparently C++ is smart enough to interpret your {{.y=1}} as the type that there’s a type-conversion constructor for.
C-style aggregate initialization in #C++ is allowed for certain class types, but the rules have changed over time and got significantly (mostly) looser in C++14, C++17, and C++20, base classes, and default member initializers, but still no user-declared or inherited constructors, virtual member functions (!), virtual base classes, private or protected direct base classes, or private or protected direct non-static data members. Apparently non-constructor non-virtual member functions have always been allowed. Public direct base classes are treated like members. Also C-style designated initializers were added in C++20. And the = is optional since C++11.
std::make_unique is the easiest way to make a unique_ptr in #C++. Also one of the examples says the boring constructor for an example struct is “no longer needed since C++20”. #documentation
More detailed #tutorial #documentation about #C++ std::unique_ptr, for which it recommends using auto p1 = make_unique<Class>(ctor args); and auto p2 = std::move(p1);. Oh also apparently there's Java-like iteration syntax in C++ now: for (const auto& song : songs) {...}.
Smart pointers in #C++ come from <memory>. #Tutorial shows examples with std::unique_ptr, which it recommends as the default choice for “POCO”. Never create them in a parameter list because it isn’t exception-safe. std::shared_ptr adds a reference count, and std::weak_ptr provides weak access to a shared_ptr object. #documentation
how to make your custom container work with #ranges in #C++
on 02024-06-23so for example there’s a #range version of find_if in #C++ now.
the #Alexandrescu #range type is standardized in #C++ since C++20.
on 02024-06-21in #C++ you should use std::unique_ptr, std::shared_ptr, and std::weak_ptr, but not std::auto_ptr, which was never a good idea and was removed in C++17.
the cppreference site is licensed #CC BY-SA. #C++ #documentation
on 02024-06-21#C standardization and defer rather than C++-style RAII and destructors
"CBMC" is a bounded model checker for #C and C++ programs, part of #CProver. #formal-methods
on 02024-01-30a #small-is-beautiful non-cryptographic #PRNG called "PCG32" by M.E. O'Neill, in 9 lines of #C. #algorithms
on 02023-12-06Why #C scanf is broken and unusable.
#Wellons explains why the #C library is bad and he avoids using it whenever possible.
on 02023-12-06The 01995 #book on "lcc", the #C compiler, written by then-Princeton-prof David R. Hanson and Bell Labs Technical Staff member Chris Hanson. #compilers
on 02023-09-04A 9600-line-of-code #C compiler by Rui Ueyama, the original author of LLVM’s lld. No idea how much RAM it needs to run. #compilers
on 02023-09-04A public database of test cases for #C #compilers.
on 02023-09-04A #C compiler in 500 lines of Python, targeting #wasm, whose breaks made implementing for “extremely cursed”. Implements arithmetic, precedence, int, short, char, string constants, pointers, simple arrays, functions, and typedefs, but not structs, the preprocessor, or casts. #small-is-beautiful #compilers
In #C++ the declarations T x(); and T x(void); are equivalent, so you can use the #C syntax in your header files with impunity.
In #C++ the declarations T x(); and T x(void); are equivalent, so you can use the #C syntax in your header files with impunity.
very unusual #C formatting style (and a very interesting algorithm as well)
on 02023-07-15examples of incompatibilities between #C and #C++
on 02023-07-05examples of incompatibilities between #C and #C++
on 02023-07-05#C preprocessor trick of defining data structures as higher-order #macros
on 02023-07-02Jens #Gustedt’s "Modern C" #ebook is #CC BY-NC-ND and is reputedly the best current #C book
on 02023-06-22ImageMagick can render text into an image and produce XBM or XPM output, which are suitable for using with #include in a #C program. It can use both #TrueType outline fonts and bitmap formats like #BDF or #PCF. This is potentially a kludgy alternative to understanding the #font #file-format
on 02023-06-02A compiler for the "B" programming language from which #C grew, written in modern times to be compatible with the original bytecode interpreter, with backends for #PDP-8 (unfinished), #PDP-11, amd64, #RISC-V (64), and #MIPS (32); by the retrocomputerist #aap from Berlin, who has squoze.net. #history
on 02023-02-16how #Genode uses #C++ “consciously”
on 02022-10-12#GCC moved to #C++ starting in 02008 and that’s why it takes so much time and space to compile now
on 02022-05-21#C++ #SNARKs #crypto an embedded DSL for snarklib
on 02022-02-11#Yoda’s jeremiad against standard #C
on 02022-02-09commentary on #Yoda’s jeremiad against standard #C; lots of commentary by Walter Bright
on 02022-02-09#C on Unisys, Cray, Prime, Symbolics, Eclipse, etc. #retrocomputing
on 02021-11-06#Yoda says #C didn't really have nasal demons in C89
on 02021-05-29#ebook about #Selfie, the #bootstrapping system that emulates a subset of #RISC-V and compiles itself from a subset of #C and has a #SAT #solver for bounded model checking
on 02021-02-09what even is wchar_t #C
#PDF #paper on “lenient execution” of #C, relevant to “friendly C”. It assumes allocated memory to be initialized, provides garbage collection, and so on.
on 02017-11-25fine points on virtual destructors in #C++
on 02017-07-17The current #C++ "rule of three".
on 02017-07-17#C++ shared_ptr-controlled objects are better allocated with make_shared, halving the number of allocations.
The details of the #C++ #Rule-of-Three (as of 2001, before move semantics), by Koenig and Barbara Moo.
on 02017-07-17Uninitialized data in #C can easily give rise to undefined behavior
on 02017-07-13using #SQLite nicely in #C++ with sqlite_modern_cpp, executing queries and throwing exceptions in the destructors of temporaries (!!)
on 02017-05-19Compile-time lookup tables in #C++ with template metaprogramming with C++14 generalized constexpr, using GCC extensions
on 02017-05-19In modern #C++ there is a std::to_string which does what you would expect with ints and stuff; in older C++ you had to put it to a stringstream and then .str() it
The 2011 #C++ standard required #GCC to break #ABI compatibility in GCC 5.1, although they did it in a backward-compatible way. But it’s not for some little-used feature; it’s for std::string.
The #C++ “Super-FAQ”
on 02017-04-15A #6502 #C cross-compiler (used for compiling #Contiki). Also supports Nintendo NES and Apple ][+.
on 02017-03-22The International Obfuscated #C Code Contest listing of all previous entries for all years, with brief explanations of what they do. Some parts are public-domain (entries up to 2011); others are noncommercial use only (the guidelines and rules themselves); others are licensed under some version of CC BY-SA (entries 2012 and later). All entries are under about 2 kibibytes, under 1 kibibyte or 1.5 kibibytes in early years. Generally, to fit within this limit, entrants have to find ridiculously simple ways to do difficult things, as well as micro-optimizing to insane levels. Many of the world’s best programmers (Dan Bernstein, Oscar Toledo, Fabrice Bellard) compete. #smallisbeautiful
on 02017-03-22A comparison of compact #C standard libraries, including dietlibc, musl, uClibc, and (as a control) glibc
on 02017-03-22#C #compilers bugs on objects bigger than PTRDIFF_MAX
on 02017-03-11#C in 4 functions in like 527 LoC (with a stack bytecode interpreter) #smallisbeautiful #compilers #toread
on 02017-03-11A walkthrough of Win16 programming in #C (with WndProcs and whatnot).
on 02016-11-13Dan Bernstein proposes a “Boring #C compiler” or “boringcc” for #security
on 02016-11-11John Regehr’s regrets about his “Friendly #C” proposal
on 02016-11-11#Ryg’s explanation of “Why do compilers even bother with exploiting undefinedness signed overflow? And what are those mysterious cases where it helps?” #C
on 02016-11-11The explanation of what LP64 means and why they chose it #C
on 02016-11-11#C #compilers sometimes don’t respect termination behavior of programs, turning infinite loops into no-ops
on 02016-10-06#Zig is Andy Kelley’s new safe programming language aimed at incrementally replacing #C. Supports custom allocators and whatnot. Generates code with LLVM. I don’t understand what its memory management model is.
on 02016-09-23blog post about #C declarator syntax and type systems in #compilers
on 02016-09-23Eric Niebler’s #C++ library for #Alexandrescu #range #software-design iteration
on 02016-08-03Driven by Boost’s Eric Niebler, #C++ is going to standardize a version of #Alexandrescu’s #range interface from D. (Whither STL‽) #software-design #toread
on 02016-08-03getting 7× #performance on #prefix-sum with #SSE in #C++
on 02016-08-03Memory management in #C programs, from the point of view of Nethack.
on 02016-07-24CBMC is a bounded model checker for #C and C++, using #SAT solvers and SMT solvers to statically check array bounds. Licensed under a 4-clause BSD license. Intended for embedded software. #formal-methods
on 02016-07-04a #C++ program demonstrating the violation of strict aliasing rules (and thus getting undefined behavior) without using any casts.
on 02016-05-09why #C compilers like to exploit the undefined behavior of signed overflow in order to generate decent loop code with int counters on LP64 platforms.
undefined behavior in #SQLite and more on Regehr’s proposal of a “friendly #C”.
on 02016-03-18Rui Ueyama wrote a #bootstrapping #C compiler in 5000 lines of code in 40 days. Starts with a run-time stack machine and single-level parser directly emitting code, later separated into a more conventional tokenizer-parser-generator structure. Supporting standard ABIs. After 29 days it was able to partly self-compile, after 37 days it incorrectly thought it could compile itself, and after 40 days it was self-hosting. #compilers
on 02015-12-14programming #SSE in #C and #vectorization of your code despite conditionals
on 02015-11-19a tiny #C subset #interpreter from 2011 for scripting a #microcontroller or two, in 3500 lines of C, which is interestingly like ONE THIRD the size of mawk, in “a few k of code space”. #smallisbeautiful
on 02015-09-05An API for sockets in #C that makes it reasonably easy to do the basic things you need.
on 02015-08-23“Assistive Context-Aware Toolkit (ACAT)”, the #input-method (etc.) Sai Prasad at Intel wrote for Hawking. “written in #C# using Microsoft Visual Studio 2012 and .NET 4.5 and runs on Microsoft Windows 7 or later. Word prediction functionality is powered by Presage, an intelligent [#GPL] #predictive text engine created by Matteo Vescovi”. Apache License 2.
on 02015-08-17difficulties with #OO in e.g. #C++ when programming #video-games for the #PlayStation 3 in 2009. Unfortunately these are slides. Basically the author’s claim is that C++ encourages memory layouts that have terrible #performance on modern hardware. Very concrete, with lots of C++ #examples and PowerPC #asm disassembled from them of 3-D programming and diagrams of #cache line evictions and whatnot. Basically his recommended cure is to use #parallel-arrays for most things and “flat” contiguous level-order tree linearizations for tree data.
on 02015-08-13Another #RMQ #algorithms #tutorial, this one in #C++.
on 02015-08-10using #formal-methods to verify #C #compilers and carry through proofs of your #verifiable-c programs through to the #asm using separation logic. Appel, Leroy, and some others.
on 02015-08-06An attempt to do dimensional analysis (units) in #C++ template #metaprogramming in a sufficiently strong way to show that #linearalgebra operations are dimensionally correct, by Mark Yagnatinsky in response to Yossi Kreinin’s challenge.
on 02015-08-05