I am a very technology oriented person and this makes me kinda geeky by definition. All my friends know that I am good with computers and programming. For those who don’t know me, do you think it’s because I study hard at college? No, it’s because in my childhood I was so attracted to computers that video games were not cutting it anymore, so I found programming and I got hooked. I read so many books and articles on programming and that’s what made me so good at it. However, now I try to read technical material as little as possible, and it’s not because I don’t want to grow, it’s because I changed my priorities and I have to grow in a different area of interest.

My current area of interest is business. Why did I made such a change? Let’s go back to one of my dreams first. About four years ago when I entered the university to study computer science, I thought that college is the last step I have to take, and after I graduate great job awaits me at a big company. Does this sound familiar to you? The main reason why I switched from one topic to another is that I don’t like following rules, and a big company will have a huge rule book. So, I changed my dream of becoming a good programmer at a big company to becoming a business owner. For this to work I have to totally change my environment. I can’t remember what I read but I memorized the following quote: spend one hour every day on a topic of your interest and after five years you will be a master of that specific topic. So, I started with exposing myself to business related information: books, twitter streams, magazines etc.

During the summer I read three books whose titles I would like to share with you.

• Getting Real: The smarter, faster, easier way to build a successful web application by 37signals.
• REWORK by Jason Fried and David Heinemeier Hansson.
• Linchpin: Are you indispensable? by Seth Godin.

All these books are business books. Let’s start with Getting Real and REWORK. REWORK actually is a revamped and extended version of Getting Real. If you are planning to buy one of these get REWORK. In REWORK authors talk about common mistakes that startups do. If you are familiar with 37signals practices you know that they go for simplicity and clarity in both their applications and business environment. If you are like me and know nothing about business you must read it — it will completely change the way you think about starting a business (especially web/software).  I was working for a startup this summer and was able to see some of the mistakes that were covered in REWORK. For example, we had meetings twice a week where we had to update our status because there was some higher power involved in the company. The length of a meeting ranged from one to three hours which is a complete waste of time, and REWORK nicely explains why “meetings are toxic”. Read this book!

Linchpin is another great book. It’s main purpose is to make the reader unleash the artist within. As the author says: we’ve been brainwashed. We are constantly being brainwashed by our friends, family, school, colleagues who say that we have to follow the rules in order to secure our future. The book tries to engrave the exact opposite on the reader’s mind. In order to secure your future you have to become an artist: you have to take an extra step that makes your work flawless or brings joy to people. The reason for taking this step is that it’s the only thing that keeps you in your job or makes you a competitor of huge companies who have power to deliver goods fast and at low cost. Linchpin is a very inspirational book.

I hope you will be able to read these books. They are really worth your time. I have a few more books on my reading list which I am planning to cover here after I finish reading them. I also found this very interesting site called StartupDigest. If you subscribe you will receive an email once in a while with upcoming startup events in your area. Maybe I will meet you in one of these! :)

The code of the compiler and testing version of the vm is available for download from github. I am not going to explain how they are implemented but I will explain how one can create his custom instruction set by extending the compiler and how to write code that compiler understands.

The compiler was written in python because it makes the work with text and strings trivial. There are three files: compiler.py, vmc.py and myis.py. The compiler.py is basically the class that provides all the logic: lexical analysis, compiling, linking, etc. The parser in the compiler does not support comments. So, if you are going to write anything longer than my factorial example you may get lost in the code. The compiler only supports 7 types of tokens where each token is separated by a white space:

• instruction – an instruction (see myis.py instructions variable).
• register – a register (see myis.py registers variable).
• @register – a register that holds memory address and will be dereferenced by the virtual machine.
• immediate – an immediate value. Syntax: int(<number>) where <number> can be a number in any format supported by python.
• label – a label. Syntax <name>:
• reference – any name that does not fall under the instruction and register categories. Usually a label without a colon.
• string – a sequence of bytes. Syntax str(<string>) where <string> is any string supported by python.

A sample program that computes factorial can be found at github with the rest of the code; the syntax should become more clear by looking at it. However, you should be aware when using int() and str(); whatever will be inside the parenthesis is going to be evaluated by the python interpreter. Furthermore, int() and str() cannot take an argument with white space. For example, instead of str(“hello world”) you should use str(“hello\x20world”).

First let’s look how one can extend the instruction set by modifying myis.py.

registers = ["eax", "ebx", "ecx", "edx", "esp", "ebp", "esi", "edi"]
instructions = {
    "push"  : [{"opcode" : 0x00, "format" : "<cc", "params" : ["reg"]}],
    "pop"   : [{"opcode" : 0x01, "format" : "<cc", "params" : ["reg"]}],
    "mov"   : [{"opcode" : 0x02, "format" : "<ccI", "params" : ["reg", "imm"]},
               {"opcode" : 0x03, "format" : "<ccc", "params" : ["reg", "reg"]},
               {"opcode" : 0x04, "format" : "<ccc", "params" : ["reg", "@reg"]},
               {"opcode" : 0x05, "format" : "<ccc", "params" : ["@reg", "reg"]},
               {"opcode" : 0x06, "format" : "<ccI", "params" : ["reg", "ref"]}
],
...
}

Above you can see an excerpt from myis.py which contains two variables: registers and instructions. The registers variable is a list containing all valid registers that tokenizer will recognize. If the order of registers is changed the compiler will generate different instruction opcodes because it refers to registers by their position in the array. The instruction variable is a map table (dictionary in python terms) where each keyword is a name of an instruction mapping to a list that contains one or more dictionaries. Each inner dictionary has three keys:

• opcode – an opcode number.
• format – an instruction encoding format. See python struct.
• params – a list of parameters (in exact order) the instruction takes. Valid values are: reg, @reg, ref, imm, str. See tokens above for more details.

Sometimes an instruction can have multiple dictionaries as mov does in the above example. This should be only the case when instruction can take different set of arguments; then the compiler will iterate through till it finds the right match. There is also a special instruction defined in the myis.py – emit. The emit takes a string as an argument and emits bytes into the code. This can be useful if you want to make code overlap, reserve space for variables, or just manually inject bytes in the code. When using references as arguments the address of the reference will be translated to an offset relative to the instruction pointer. Simply by modifying myis.py you can introduce new instructions to the compiler; then write the code and compile it with vmc.py.

Once you have the bytecode the final step is to write a vm that will read it and execute the encoded instructions. Among the source files I have included a very basic sample vm that will execute the factorial program. The implementation is pretty straightforward.

Hopefully I have covered everything and didn’t miss any parts of the compiler’s logic. The source code I provide is highly experimental and it should have tons of bugs; nevertheless, it should give a good starting base to those who would like to write their own compiler and a vm.

The website will be used to keep all things related to me in one place for easy access. At the moment there aren’t much of the stuff yet, but eventually there will. What concerns the blog, I am planning to keep it more technical, however personal things might also pop out.

Finally, I hope you will find something useful here and don’t hesitate to drop me a line.

Edit: I switched to WordPress and decided to make comments open after looking at the trafic logs.