"compiler technology" is a very broad topic. Narrowing the scope of the question to "frontend" (parsing) or "backend" (code generation - which is also dependent on the type of hw/CPU you are targeting) might help. backend processing can be further refined with various optimization strategies. I'm making the assumption that the 'perfect' language is one that the user will actually deconstruct and translate during compilation.

I've requested the paper cited, but have not read it, so my answer should be taken in that context.

Other questions that need to be answered - what level are the students that are being taught? Different expectations for undergraduate students v graduate students.

I've implemented a stack architecture Pascal compiler in order to understand the concepts. Having something that then runs the stack code proved to be a blessing because it pointed to issues/errors that were not readily visible when we looked directly at the stack operations being generated by the compiler.

I've also implemented an interpreter for my team's language. It was much more interesting, with the end result being a huge data structure that was then 'walked' during execution.

In both cases, I learned quite a bit - but for different reasons. The frontend of the Pascal compiler was recursive descent due to keyword tagging. The interpreter was not, which lead to significantly more parsing difficulties.

You will first have to define the structure of your perfect language, through a grammar.

If this grammar fits within the power of most parser generators ("LALR" http://en.wikipedia.org/wiki/LALR), you will save yourself a large amount of trouble by using one (JCUP is a good one IMHO, but there are many others. http://www.cs.princeton.edu/~appel/modern/java/CUP/)

You will define the way every word is scanned and turned into a stream of higher-level objects (variable names, keywords, etc.), which will be matched with your grammar.

With that, you will have a parser skeleton, which you will have to complete with actions for each step of the parsing. Typically, in these actions you will build a tree structure that represents your program syntax (called an Abstract Syntax Tree, AST). But you can do anything you want in each action.

With that, you have a front-end to your perfect language.

The element of language performance that you can reach with this part is its expressiveness (how broad is the class of things that I can do with it) and productivity (how fast can I write a correct program). Of course, you may need more work downstream to make these language features a reality (for instance, garbage collection, which relieves the programmer from having to free their data structures and hence increases productivity, requires further compiler and runtime support).

You can either parse an input program that will sit in an input text file at once and compile (or execute directly) it, or accept input from a command-line, giving it a more interactive (but also throw-away) use.

If you execute your program directly by interpreting the semantics of the AST, you will build an interpreted language.

The other option, if you also want runtime performance, is to compile your program. There is a vast literature on how to optimize programs for various targets.

I wouldn't recommend to start doing this on your own, it's a lot of work.

You could leverage existing, open-source compilers such as LLVM or GCC by making your parser a front-end to their internal representation and then leverage its existing infrastructure.

Whatever your route, a common, final point in compiling programs is to generate assembly code for a specific machine, or byte-code for a virtual machine. LLVM has a few, GCC has more.

One remark on perfect languages: adoption by the masses is ultimately what makes or breaks a language. There are several languages out there that are - in a sense - perfect, but they never become popular.

Most languages that became popular derive from C (Java, C++, C#), so one could conjecture that adoption of a language is conditioned by how close it is to a language that people are broadly accustomed to.