CSCI 485 Lecture/Lab Notes

DISCLAIMER::: most of these are still just piccies of my handwritten notes for the various topics
... and my handwriting is bad enough even when it's not reduced to a jpg...

---

Ruby and generative programming

Assemblers and compilers

compilers: part 1 , part 2, part 3, part 4, part 5, part 6, part 7, part 8, part 9

tokenizing, parsing, and translating IttyBitty in Ruby
part 10, part 11, part 12,
bonus assignment

tokenizing SIMP in C

A lex tokenizing grammar for C
A yacc parsing grammar for C
part 13, part 14, part 15, part 16

Macros and preprocessing

Obfuscation

C++ Templates TMP

C++ template metaprogramming examples (based on the CodeProject notes):

• basic compile time computation,
• recursive compile time computation ,
• unwinding loops/recursion at compile time,
• compile time selection of if/else/switch blocks, and
• parameterized bodies for all the above,
• typesafe variadic functions,
• processing strings at compile time,
• variadic tuples
• compile time string parsing/regex

Implementing a preprocessor for Ruby
FSM to add ++ and -- to Ruby

Metaprogramming on the fly

Lisp metaprogramming on the fly:

• basic functions
• list implementations and side effects.
• eval and funcall
• lambda functions and closures
• macros
• dynamically analyzing function composition
• dynamically altering functions
• a self-modifying program to display the lyrics to the 12 days of Christmas
• A macro suite for moddable functions,
    - a short test script and resulting output
    - an interactive function editor/tester build from the macro suite

Asm metaprogramming on the fly:

• part 0
• part 1
• part 2
• part 3

Ruby code that self modifies on the fly can be done by building blocks of Ruby code as strings, based on user input, and then embedding these blocks into the rest of the program.

• Building storable/passable functions using lambda
• Allowing customized runs of methods by passing user defined blocks and running with yields
• Allowing customized runs of methods by passing user defined blocks and running with Proc.new.call
• A mini-interpretter to record and run ruby code
• Dynamically adding user-defined (and callable) methods to modules using eval
• Dynamically defining class fields and methods, and tracking their composition in hash functions: UserCode class
• Checking if something has been defined or not at run time defined? and respond_to?

Case studies

• Code smell and automated code cleaning: eliminating dead code, replace duplicated code with functions/macros, parameterize for "near duplicates"

• break up long methods

• standardize whitespace/layout

• auto-initialize by data type