#AltDevBlogADay

http://TheChaosEngine.com focuses on video game development (art, programming, design, general topics). To get full access you would need to send an work email to confirm that you are from the industry. There are also some indies, educators, and ex-video game folks (so it's not a strict order). There is also http://www.altdevblogaday.com/ also for game development. Recently http://flipcode.com has been getting up from long sleep (it was my favourite site back in the days).

1) http://www.altdevblogaday.com/ 2) http://mechanical-sympathy.blogspot.com/ 3) (Not really a blog, but so great) http://lwn.net/ 4) (For entertainment) http://thedailywtf.com/

http://altdevblogaday.com If you haven't heard of it, Mike is the engine director at insomniac, and a regular speaker at sony dev confs. Lots of great posts from all kinds of game developers. From the about page: >What is #AltDevBlogADay? >#AltDevBlogADay is a group of game developers (generally found on Twitter) that want to blog more regularly. An idea inspired by iDevBlogADay. >It’s simple! Each day people will be assigned to blog. Each person has contributor access and can post his original writing on to this site directly. Or provide a summary and link to his original writing on his own blog.

One of my favorites: http://www.altdevblogaday.com/2011/05/17/understanding-the-fourier-tra…

No, I was correct about the standards: http://www.altdevblogaday.com/2012/03/22/intermediate-floating-point-p… C98: "5.10 The values of the floating operands and the results of floating expressions may be represented in greater precision and range than that required by the type; the types are not changed thereby." You're right that most compilers in practice changed the precision to double. I think we're in violent agreement (and I learned a lot from this debate!) :)

Don’t scribble data all over memory via pointers. Each time you follow a pointer it will be a cache miss: [hash pointer] -> [Task Control Block] -> [Socket] -> [App]. That’s four cache misses. Incidentally, game programmers have been spreading the gospel on this issue for several years now. See for more: http://macton.smugmug.com/gallery/8936708_T6zQX#!i=593426709&k=ZX4… http://research.scee.net/files/presentations/gcapaustralia09/Pitfalls_… http://www.altdevblogaday.com/2011/11/07/an-example-in-data-oriented-d…

Carmack has been thinking about functional programming for a while and posted his thoughts on applicable lessons for C++ a year ago: http://www.altdevblogaday.com/2012/04/26/functional-programming-in-c/ He's a great developer and has always pushed boundaries. I look forward to his postmortem after this project is finished.

I wonder why you lost or never had any faith in static analysis. On Apple's platforms it's becoming a really big "thing". Also John Carmack talked about the benefits of static code analysis at QuakeCon 2012. Also a good read: http://www.altdevblogaday.com/2011/12/24/static-code-analysis/

Javascript is quirky. It's a great language, but c'mon...please. That horse has been beaten to death and the long discussion on this topic alone is proof of it's quirkiness and it's numerous pitfalls. The idea that (optional) strict typing and (optional) well-defined OO practices would only work to act as a "safety net" for new developers is, quite frankly, ludicrous. Static typing is the bedrock of static analysis and if you can't see the value in static analysis, take a read here - http://www.altdevblogaday.com/2011/12/24/static-code-analysis/ You're welcome to keep doing things the hard way. You will certainly be enabled to do so since Javascript is not going anywhere. But easy-to-use Javascript-compatible languages with powerful, precise and accessible features are the future, IMO. I don't think I'm alone in that sentiment given the recently budding interest in this arena.

Would be interested if its worthwhile/possible using shaders as a wrapper for three.js. All I got when I was searching was there was a mozilla bug report and a hacked patch to expose SIMD through js[1], and a project to add SIMD support to vectors in Dart[2]. [1] https://bugzilla.mozilla.org/show_bug.cgi?id=644389 [2] http://www.altdevblogaday.com/2012/06/18/bringing-simd-accelerated-vec…

Though this is Bruce's personal blog, the equivalent post on AltDevBlogADay is at http://www.altdevblogaday.com/2012/07/06/when-even-crashing-doesnt-wor… and has more discussion, etc (and is one of the best programming blogs to follow at the moment, IMHO).

There's a fantastic intro to modern game cheating and cheat detection here, for anyone interested: http://www.altdevblogaday.com/2012/04/02/extravagant-cheating-via-dire…

http://altdevblogaday.com/ This is a blog with multiple authors, so I check this once a day.

>It is hard, though, to build and maintain the structures of the old, “smaller” internet. You can, today, still go back to the can-to-can structure that a personal website, an RSS feed, and a browser provide. I think the author ignores another reason that people (especially us techies) don't like to admit: The majority of people don't care about following a list of personal websites. Instead, websurfers just get whatever snippets of information they want (e.g. food recipe, medical trivia) from whatever website happens to have it and then move on. The disinterest in personal websites comes from both the websurfers and many content authors themselves. Some examples from the content creators... Clay Shirky's essay happens to be on the HN front page right now. But he doesn't maintain his personal website anymore. He gave reasons for it[1] and even said he regrets letting it rot. But even today, his personal website remains empty and previous links all return 404 errors. But he does stay active on Twitter: https://twitter.com/cshirky John Carmack's old personal website "altdevblogaday.com" is gone now.[2] But he does stay active on Twitter: https://twitter.com/id_aa_carmack Those 2 guys are obviously internet-savvy and need no lectures on personal websites -- and yet they choose to abandon them. As to examples for websurfers, if you ask normal people if they sometimes search the internet for a cooking recipe, they'll say "yes". But if then followup with "Can you…

The tweet contains zero substance. I did the dirty work to dig through the linked links to get the goods and share, enjoy! It's a good read. --- Thanks! A few comments: In some ways, I still think the Quake 3 code is cleaner, as a final evolution of my C style, rather than the first iteration of my C++ style, but it may be more of a factor of the smaller total line count, or the fact that I haven’t really looked at it in a decade. I do think “good C++” is better than “good C” from a readability standpoint, all other things being equal. I sort of meandered into C++ with Doom 3 – I was an experienced C programmer with OOP background from NeXT’s Objective-C, so I just started writing C++ without any proper study of usage and idiom. In retrospect, I very much wish I had read Effective C++ and some other material. A couple of the other programmers had prior C++ experience, but they mostly followed the stylistic choices I set. I mistrusted templates for many years, and still use them with restraint, but I eventually decided I liked strong typing more than I disliked weird code in headers. The debate on STL is still ongoing here at Id, and gets a little spirited. Back when Doom 3 was started, using STL was almost certainly not a good call, but reasonable arguments can be made for it today, even in games. I am a full const nazi nowadays, and I chide any programmer that doesn’t const every variable and parameter that can be. The major evolution that is still going on for me…

I only clicked to see the comments because it said Doom 3. Thanks for posting the article and thanks for pointing out the section on linked lists. I agree that that section is really interesting. In what sense do you mean lockless applications - applications built around compare and swap primitives or something else? I can't really follow what: "byte otherMembers[64]" is used for. What useful data is stored in there? If pointers are 32bit and cache lines are 64bit, the comment: "// over a cache line worth of other members" doesn't really make sense because you can only fit two full addresses per cache line. It's a shame that the idList type he is suggesting in favour of the other types, a resizeable heap array, is not declared in the body of the pdf. Might be worth looking it up. The distinction between non-intrusive and intrusive linked lists is new to me, I didn't know there was a word for that! This is the best "link" I've found on them: http://www.altdevblogaday.com/2011/12/06/intrusive-lists/

Two related things I've been studying in more depth lately: Dataflow programming and behavior trees(the game AI concept). http://en.wikipedia.org/wiki/Dataflow_programming http://www.altdevblogaday.com/2011/02/24/introduction-to-behavior-tree… The first comes up anytime you want to make a signal processing chain more modular and composable(graphics and audio are the classic applications) and many of its concepts share space with FP theory. Graph demonstrates a implementation built around certain needs of web apps. Note that it seems like implementations vary a lot with the data types - audio processing, for example, may allow for cyclical feedback loops, and mainly distinguishes between two types of data - multi-channel PCM data(which may be split and combined between nodes) and parameter changes over time. The second describes a form of concurrent finite states with good compositional properties - parent-child relationships that result in concurrency expressions passed back to parents(success, failure, in progress). Coroutines are comparable in power, but put emphasis on direct control of the concurrency, while BTs use modules of state + logic with pre-designed yielding points. (I think other finite state constructs have applications, too, BTs just happen to be my focus right now) I currently believe that highly-concurrent applications can be abstractly architected as a combination of dataflow, behavior trees, and asynchronous events - each one of those covers a very…

I have desperately wanted to understand the Fourier Transform and signal processing for a long time. In high school I read every tutorial or book I could get my hands on, hoping that one would finally "click." The very first thing I did when I got to college was approach the CS faculty and ask for recommendations for literature that would help me understand it. My college didn't have a signals and systems class, but a few years later I heard that Richard Lyons's book "Understanding Digital Signal Processing" was supposed to be the friendliest book on the subject so I bought and read it. I say all of this just to impress upon you that I was serious about wanting to understand this stuff. Despite all the effort, the FFT and DFT were never more than opaque blobs of math to me, mysterious boxes that you put inputs into and could extract outputs from (albeit in a very obscure format that seemed to involve complex numbers for no apparent reason). I sort of gave up and forgot about it for several years. Recently I came upon Stuart Riffle's article (http://www.altdevblogaday.com/2011/05/17/understanding-the-fourier-tra… which explained it in terms of the circular approach that this article adopts. Rotate the waveform about the origin at the frequency of interest and average the samples, simple as that. I am not exaggerating when I say that after 10 minutes of reading that article, I had an understanding that years of highly motivated knowledge-seeking had not given…

John Carmack wrote a great blog post a while back about Static Code Analysis. http://altdevblogaday.com/2011/12/24/static-code-analysis/ While not all of this is immediately applicable to JSHint and the like, it provides some insight into why static code analysis can be seen as helpful. As you also mention, it's really helpful for code within a codebase to be consistently written. JSHint can help enforce some of that consistency. This is where JSHint really shines. If your JS is tied to some sort of "build" process (even a short 1-2 second one), catching errors before running the build is incredibly helpful. If you intend to minify your JS code (as you should) before distribution, finding missing semicolons can be very important, indeed. I find the most helpful JSHint errors to be about mistyped variable names. It's so much easier to see that in my editor, fix it, and THEN run it in the browser.

After spending hours searching, I ended up finding the way I wish I'd seen it explained in the beginning: http://www.altdevblogaday.com/2011/05/17/understanding-the-fourier-tra…

I remember reading "Latency Mitigation Strategies", by Carmack. It doesn't mention the Oculus except in an acknowledgment at the end, but it might be about the same thing lifeisstillgood is talking about: http://www.altdevblogaday.com/2013/02/22/latency-mitigation-strategies… HN discussion: https://news.ycombinator.com/item?id=5265513

Visual Studio now ships with a reasonably good static analyzer built in. We're using it more than our aging copy of PC-Lint. (Carmack's review: http://www.altdevblogaday.com/2011/12/24/static-code-analysis/)

I suppose I will get a FB account now, so that may lead to some writing a little longer than tweet length If only there existed such a thing before facebook, a platform to enable others on the internet to read it,... a blog if you will. Oh wait... http://www.altdevblogaday.com/author/john-carmack/ -------- I guess If someone gives you a lot of money you have to talk nice about them.

Carmack has written a lot detailed information about the latency problem, which is much more demanding for VR, and about how to mitigate it: http://www.altdevblogaday.com/2013/02/22/latency-mitigation-strategies…

Carmack is a late add to the Occulus team, but he's been doing real work in reducing latency: http://www.altdevblogaday.com/2013/02/22/latency-mitigation-strategies…

I am not as experienced as you, far from it, but my -very limited - understanding of functional programming is that it's all about limiting side effects, which means limiting the ways you can screw up something. I could try to explain what I think, but John Carmack did it much better than I would ever do in a blog post, that was once submitted on HN: http://www.altdevblogaday.com/2012/04/26/functional-programming-in-c/

You might be interested in the articles Carmack[1] and Michael Abrash[2] have written about VR. [1] http://www.altdevblogaday.com/2013/02/22/latency-mitigation-strategies… [2] http://blogs.valvesoftware.com/abrash/latency-the-sine-qua-non-of-ar-a…

John Carmack wrote a very interesting post about this same topic. http://www.altdevblogaday.com/2012/04/26/functional-programming-in-c/ To sum it up, he's still writing code in C++, but it has become less and less like C++. His code has become less OOP and more functional.

> C++'s C heritage Well, at this point it's more like C++'s C++ heritage. > const correctness It certainly exists in plenty of other languages, but in a non-broken way. C++'s const correctness model is mostly broken, by the way [1]. D's model is a bit more sane [2]. Languages like Haskell or Clojure (AFAIK) make immutability a default. This kind of functional style is a good thing for C++ developers overall, as emphasized by John Carmack [3]. [1] Once again, the C++ FQA has plenty of wisdom to share: http://yosefk.com/c++fqa/const.html [2] http://en.wikipedia.org/wiki/Const-correctness#const_and_immutable_in_… [3] http://www.altdevblogaday.com/2012/04/26/functional-programming-in-c/ > RAII didn't catch in other languages That's because most other languages are garbage collected. (Not that RAII is a bad thing, it's just not needed.)