bkaradzic

Notes on header files

This article is also available here

After over 20 years working with C/C++ I finally got clear idea how header files need to be organized. Most of the projects in C++ world simply dump everything in .h file, and most of my C++ code was organized this way. Lately I started to separate function declaration from implementation as it was done in C. Now .h headers are exclusevely intended for function and class declaration with doxygen documentation style comments. Inline implementation of functions, class method implementation, etc. goes into .inl headers or .cpp files.

For example .h file would contain only declaration and doxygen style documentation comment:

jeremyong

Art of Debugging

Obligatory disclaimer, this is all opinion and cannot possibly generalize to all problems, workflows, environments, etc. This is meant primarily as a launching point for an open-ended discussion on best practices in debugging code. This is a sketch of what may be a brief book that covers each point below with anecdotes, examples, and techniques.

Hypothesis 0

The ultimate goal of a debugging session is to rule out possibilities until only one remains. All applications of best practices, techniques, and tools should be pointed at this purpose (contextualize all points below against this statement). Debugging is first and foremost a critical thinking problem, and presence of mind is your most critical asset. Establish a mental model but do not be afraid to invalidate it as the investigation unfolds.

Hypothesis 1

avafloww

/*<?php
//*/public class PhpJava { public static void main(String[] args) { System.out.printf("/*%s",
//\u000A\u002F\u002A
class PhpJava {
    static function main() {
        echo(//\u000A\u002A\u002F
        "Hello World!");
}}
//\u000A\u002F\u002A
PhpJava::main();

Trass3r

# first rebuild solution

# then
echo '[' > compile_commands.json
find obj/v140/x64/Debug/ -name 'CL.command.*' | xargs iconv -f utf-16 -t utf-8 | grep -hF '/c' | sed -r -e 's#\\#/#g' -e 's/"/\\"/g' -e 's#/c .+ ((.:/.+)/[^/]+\.[^/]*)$#{\r\n\t"command": "clang-cl.exe -m64 --driver-mode=cl \0 -Wno-error",\r\n\t"file": "\1",\r\n\t"directory": "\2"\r\n},#g' >> compile_commands.json
echo ']' >> compile_commands.json

# example use
"C:\Program Files\Git\usr\bin\find.exe" src -name "*.cpp" | "C:\Program Files\Git\usr\bin\xargs.exe" -n1 -P1 -t "C:\Program Files\LLVM\bin\clang-check.exe" -p . -fixit
find src -name '*.cpp' | xargs -n1 -P1 -t 'C:\Program Files\LLVM\bin\clang-tidy.exe' -p . -header-filter=.* -fix -checks=cppcoreguidelines-pro-type-member-init

sverrirs

using System;
using System.Runtime.InteropServices;
// ReSharper disable SuspiciousTypeConversion.Global
// ReSharper disable InconsistentNaming

namespace VideoPlayerController
{
    /// <summary>
    /// Controls audio using the Windows CoreAudio API
    /// from: http://stackoverflow.com/questions/14306048/controling-volume-mixer

bkaradzic

Orthodox C++

This article has been updated and is available here.

cobbpg

Unity hotswapping notes

Unity has built-in support for hotswapping, which is a huge productivity booster. This feature works not only with graphics assets like bitmaps and meshes, but also with code: if you edit the source and save it, the editor will save the state of the running game, compile and load the new code, then load the saved state and continue where it left off. Unfortunately, this feature is very easy to break, and most available 3rd party plugins have little regard for it.

It looks like there’s a lot of confusion about hotswapping in Unity, and many developers are not even aware of its existence – which is no wonder if their only experience is seeing lots of errors on the console when they forget to stop the game before recompiling... This document is an attempt to clear up some of this confusion.

Nota bene, I’m not a Unity developer, so everything below is based on blog posts and experimentation. Corrections are most welcome!

The basic flow of hotswapping

paniq

// World's Tiniest* Marching Tetrahedron
// by Leonard Ritter (leonard.ritter@duangle.com)

// this code is public domain

//      0
//      +
//    / | \
// 3 +-----+ 1
//    \ | /

richhickey

(require '[clojure.core.async :as a])

(def xform (comp (map inc)
              (filter even?)
              (dedupe)
              (flatmap range)
              (partition-all 3)
              (partition-by #(< (apply + %) 7))
              (flatmap flatten)
              (random-sample 1.0)

john2x

Clojure Destructuring Tutorial and Cheat Sheet

(Related blog post)

Simply put, destructuring in Clojure is a way extract values from a datastructure and bind them to symbols, without having to explicitly traverse the datstructure. It allows for elegant and concise Clojure code.

Vectors and Sequences