
Designing Zachtronics' TIS-100 - csbrooks
http://gamasutra.com/view/news/244969/Things_we_create_tell_people_who_we_are_Designing_Zachtronics_TIS100.php
======
archagon
I love Zachtronics' games, but they're kind of in the uncanny valley of
gameplay for me. After a few hours, I start to wonder why I'm optimizing all
these in-game circuits when I could be doing the same with my actual code! (On
the other hand, they also make me realize how great Woz must have felt when he
got Breakout down to just 44 chips.)

The performance comparisons to other players is a brilliant feature, though.

~~~
gcb0
it should be fun for kids to start learning to code. but then, the move things
around like that may do more damage than good on understanding multicore :)

~~~
boomlinde
The most similar real world example that works like this is the GA144. 144
cores are laid out in a grid, and you pass data from one core to another by
sending it "north", "south", "east" or "west".

It's a puzzle game, though, and probably aims less at being a practical
teaching tool than a set of novel and obscure problems. If it teaches anything
it'd be approaching odd problems in general, just like spacechem did.

------
ansible
TIS-100 is way more pleasurable to program on than real hardware. It is so
easy to debug! Everything is visible.

People accomplished great things back in the 8-bit era with the tools they
had, but the stuff they do today with the same hardware is truly mind blowing.
I attribute that at least partially to things like that C64 emulator [1] where
you can just view all of the system's memory during execution.

[1] [http://icu64.blogspot.com/2009/09/first-public-release-of-
ic...](http://icu64.blogspot.com/2009/09/first-public-release-of-
icu64frodo.html)

------
obstinate
This game is brilliant, in case you haven't tried it. Also, it will teach you
the true fury of stream programming with only twelve instructions and a single
addressable register.

~~~
strangecasts
The instruction set design really deserves praise: people who haven't done
assembly before report picking it up without too much trouble, and it manages
to fit several opportunities for subtle tricks in the space of the 13
instructions.

The moment you realize that you can use JRO with a direction to control flow
from another node, it feels like a genuine revelation while being immediately
obvious and logical in hindsight.

~~~
chinpokomon
JRO UP? As in pulling in a value from the up port. I didn't see how that gives
me a whole lot since wouldn't I need to know in the other node what the offset
would be? I considered that this would be valid, but I couldn't see a way to
make it really useful.

~~~
obstinate
It allows you to use another processor to do control flow based on an input,
freeing up cpu time. For example, suppose you wanted to emit to DOWN:

    
    
       0 if LEFT is <= 0
       UP if LEFT is > 0
    

So you have two options

    
    
       S: MOV LEFT ACC
       JGE E
       MOV 0 DOWN
       MOV UP NIL
       JMP S
       E: MOV UP DOWN
    

Or you could do this:

    
    
       S: JRO LEFT
       MOV UP NIL
       MOV 0 DOWN
       JMP S
       MOV UP DOWN
    

And left would send 1 if its value is <= 0, or 4 if it's >0\. In this case it
only saves one cycle for the node under consideration, but it could be a good
deal more if the conditional is more involved.

------
IsTom
> This game is kind of a throwback to the kinds of games I used to make

I think this is a very important part. Personally I enjoyed pre-spacechem
games a lot (e.g. [http://www.zachtronics.com/the-codex-of-alchemical-
engineeri...](http://www.zachtronics.com/the-codex-of-alchemical-
engineering/)) because they were difficult and because they were very simple.
Spacechem got grander and it was still fun, but for my simple tastes
infinifactory isn't bare enough.

------
watmough
This is neat, but you can do some real hacking on software with something like
[http://www.ollydbg.de/](http://www.ollydbg.de/)

~~~
strangecasts
It's not really intended as a replacement for reversing/assembly challenges:
design-wise it's actually fairly similar to his previous games like SpaceChem,
in that you're trying to break up solutions into discrete chunks that each
individual node can handle.

