The Orange Duck

From a previous article of the same author: http://theorangeduck.com/page/c-preprocessor-turing-complete

> This is a fairly clear distinction and a compelling argument. Clearly there are languages where you can effectively express unbounded recursion function() { function() } and the C preprocessor is not one of them.

>* But there are a number of subtleties going on here. For example, if we consider the set of macros I created to be the "machinery", and the "language" to be the Brainfuck input to my system, then it is indeed Turing complete. That is - I have created machinery which can simulate Turing complete languages. Taking all the above definitions into account, consider how odd it is that Turing complete machinery can be expressed in a non Turing complete language.*

And from the “Brainfuck interpreter written in the C preprocessor”: https://github.com/orangeduck/CPP_COMPLETE

> Currently the maximum recursion depth is set to around 1000 and the data array size around 100. These can be easily extended but for now, as a general rule of thumb computations exceeding 1000 steps may not run.

Here is the problem. We can consider the one-step-interpreter: it’s a function that has as arguments a program, the current instruction index and the whole memory state, and this function computes the next instruction index and the next whole memory state. This one-step-interpreter is primitive recursive.
He put that function inside a bounded loop, which is also implementable as a…

It would be pretty interesting to use a neural network for AO! It's a good coincidence you linked to SSIM based adaptive sampling, I'm actually using the research you linked to: I implemented the OptiX API for SSIM prediction. So far, we've used it for choosing where to send more rays, but I'm not aware of anyone using it to adapt the max distance for AO rays. That might be fun & fruitful to try!

I'm not certain, but I think in theory that capping the max distance will always bias the AO (to the extent that AO even makes physical sense). You can reduce the bias by mixing lengths, but I'm not sure if you can ever fully compensate for it. More importantly, it's always (theoretically) biasing to separate AO shading from the normal surface shading & lighting calculation. AO is a beautiful simple hack, but I'm not sure it will survive the future, especially as ray and compute budgets increase.

I know I've seen other AI attempts to learn AO & global illumination, just googling a bit:

http://theorangeduck.com/page/neural-network-ambient-occlusion

https://www.youtube.com/watch?v=z_zmRWxU-PY

I'm sure there will be lots of people recommending great books, so i want to give you some general advice:

sadly, a lot of language related libraries are in C/C++, so if using those sounds a pain to you, just ignore them for now.

get somthing simple working soon, such as an interpreter for Forth [0] written in any language you already know.

do the parsing later, there is so much more to learn about compilers and language runtimes!

when it's finally time for parsing, i recommend parser combinators [1]. they are pretty easy to implement yourself, once you have understood the concept and are very flexible.

do not forget about proper error messages with line/col information.

any kind of performance optimisation is strictly forbidden until you know what you are doing.

[0] https://en.m.wikipedia.org/wiki/Forth_(programming_language)

[1] https://www.theorangeduck.com/page/you-could-have-invented-parser-combinators

"people on the 'net jerking themselves off" is a pretty good descriptiob of freenode's ##c. I'll quote Daniel Holden (the author of the book on implementing a lisp you mentioned above)'s words on the matter[1]:

This channel is hardly known for being friendly. Generally anything other than K&R is regarded as Socratic corruption. And not checking the return value of malloc is on par with adultery. Nor do they have much concern for encouraging the next generation of C programmers. I remember witnessing a new C programmer ripped for several minutes on the channel for simply mentioning the heap and stack in their explanation. Instantly he was shot down with "implementation detail and not defined in the C standard" and told to ask his question in #unix. The channel is generally a great place to go if you want to be told you're an idiot.

1: http://www.theorangeduck.com/page/ready-fight

IK doesn't "solve" the core problem of realistic character motion. Sure you can tweak foot positions to stop them from sliding but the farther they get from the original animation data the worse the result will look. It's no panacea.

There are new approaches to generating realistic character motion being shown at SIGGRAPH every year, getting better and better, but the best ones are largely too expensive for games to adopt. Plus, for player-controlled characters, at a certain point you run into a fundamental tension between control responsiveness and physical realism of animations.

I recently saw a great article on the topic which even comes with a WebGL demo: https://theorangeduck.com/page/code-vs-data-driven-displacement#footlocking

I think of neural networks as "smooth compression" - something that compresses a key-value database into a continuous non-linear function. Previously Daniel Holden wrote about something similar in his blog (https://theorangeduck.com/page/machine-learning-kolmogorov-complexity-squishy-bunnies)

I agree with the author's sentiment that "learning" might be a misleading term. Neural networks can just be seen as specialized programs that just compress certain kinds of data extremely well (at the cost of extremely high pre-computation). But it's still a very useful technique to tackling previously intractable problems.