126 karma · joined June 5, 2013
http://blogs.technet.com/b/next/archive/2012/11/08/microsoft...
edit: also, there are already vision-based behavioral/gait analysis software in existence (how well they work is another question)...so conceivably we can also recreate an actor's performances?
Said article: http://www.aeonmagazine.com/being-human/how-consciousness-wo...
http://newscenter.berkeley.edu/2011/09/22/brain-movies/
Correction: we can read arbitrary images, but so far only with cat's brain:
http://www.polymtl.ca/polystim/en/navigation/Prothesevisuell...
There had been experiments showing that visual cortex stimulation to generate imagery is possible:
http://onlinelibrary.wiley.com/doi/10.1111/j.1528-1157.1998....
Expression related optimizations: Constant Folding, Constant Propagation, Global Propagation, Strength Reduction, Common Subexpression Elimination, Partial Redundancy Elimination, Induction Variable Elimination, Reassociation
Loop related optimizations: Loop Invariant Code Motion, Loop Peeling, Loop Unrolling, Loop Distribution, Loop Autoparallelization, Loop Fusion, Loop Fission, Loop Interchange, Loop Tiling/Stripmining, Vectorization, Scalarization
Memory/cache related optimizations: Cache blocking, False Sharing Elimination, Structure Peeling, Structure Splitting, Array Contraction, Multi-dimensional Array Dimension Reordering
Control flow related optimizations: Code block re-ordering (by frequency), Branch prediction (by static analysis/feedback guided), Code hoisting/sinking (to optimize CPU pipeline), Automatic Inlining, Tail Call Optimization
Code generation related optimizations: Register allocation (np complete), Peephole optimization, Superoptimization (no one really does this yet, but cool nonetheless)
Analysis (interprocedural/intraprocedural): Alias Analysis (flow/context (in)sensitive), Points-to Analysis, Escape Analysis, du chain Analysis, Live Variables Analysis, Memory Access Pattern Analysis (to guide memory layout optimizations), Available Expressions/Copies Analysis, Loop Dependency Analysis, Control Flow Analysis, Dominator data flow Analysis, Globals Analysis
Miscellaneous: Static Single Assignment, Data Flow Analysis (in, out, transfer, meet!), Worklist Algorithm (for Data Flow Analysis!), Symbolic Execution/Abstract Interpretation
Writing straightforward code is the best thing you can do for a compiler. They can tell exactly what you want to do, and do their best to generate the fastest/most memory efficient code possible. Help compiler help you!
Also, compiler usually comes with several different levels of optimizations. And you can tune each one of these optimizations, like you would with a racing car. Read the manual!
Our intelligence could just as well be a complicated mesh of a huge number of 'rules' that have evolved over a long period of time in response to many difficult situations that had threatened the survival of our ancestors. They are also what we call intuition/pre-born knowledge/natural tendencies and reflex responses.
Having said that, we have not ruled out the possibility of intelligence (albeit of a form different than ours) arising as an emergent phenomena from simple rules. But if we were to replicate human intelligence on silicon, I'm more inclined to believe that we'll have to 'manually' encode a huge number of situation-specific rules, e.g. when you see wriggly thing run away.
A new programming paradigm allows us to reframe a problem in a different space, much like how changing a matrix's basis changes its apparent complexity, so to speak.
The ultimate goal, I think, is to come up with a paradigm that would map computational problems, without loss of generality, to what our primate brains would find intuitive. This lowers our cognitive burden when attempting to describe a solution, and also to allow us to see clearer what the cause of a problem may be. For example, if you're a game developer, and you find some rendering problems due to some objects intersecting each other, but you're not sure where it happens, Instead of poring over text dump of numerical vector coordinates, it'd be better to visualize them. The abnormality would present themselves clearly, even to a layman's eyes. I suspect this is what Victor is trying to get at. Imagine, if you will, that you have a graphical representation of your code, and a piece of code that could potentially segfault shows up as an irregularity of some form (different textures, different color, different shape, etc), so you can spot them and fix them right away. The irregularity is not a result of some static error analysis, but is instead the result of some emergent property resulting from graphical presentation rules (mapping from problem space to graphic space). We're good at spatial visualization, so I wonder if it's valid to come up with a programming language that would leverage more of our built-in capability in that area. This may seem like wishful thinking or even intractable (perhaps due to a certain perception limitation...which we have to overcome using more cognitive resources), but I certainly hope we'll get there in our life time.
Captain: We have now landed at SFO. We will now taxi to gate A3.
Passengers: OH CRAP. bumps up and down
But in all seriousness, this could be a precursor to a more fluid form of wing morphing, i.e. without joints. Sort of like Eddy in Stealth, which morph its wings to direct jet exhaust downwards to create vertical lift.
Granted...since you explicitly stated that your compiler focused on compile speed, I guess optimized code generation isn't your main concern, since the two are more or less mutually exclusive.
This seems like a fairly useful technique, provided the given bytecode file isn't terribly big (since you're uh...converting it into string representation), and that the bytecode isn't some run-once-throw-away code, otherwise you spend more time converting it into Lua code and JIT-ing it.
Having said that, I wonder if it'd be even less of a hassle by skipping the bytecode part. Just transpile the source written in your custom language straight into Lua code, and have that code JIT'ed instead. Many high level structures/information would be preserved, allowing JIT to do an even better job perhaps?
Anyhow, I digressed. Still fun to speculate, I say.