Browse by Tags

Tagged Content List
  • Blog Post: FScheme - Scheme in F#

    [Part 1 of the FScheme series ] One of my New Year’s goals is to re-read Lisp in Small Pieces and implement all 11 interpreters and 2 compilers. As much as I like the "Lisp in Lisp" idea and enjoyed the eureka moment in SICP when Sussman writes the metacircular interpreter on the board to the...
  • Blog Post: Functional I/O (Historical Debugging)

    [Part 14 of the FScheme series ] Historical Debugging in VS2010 is quite the engineering feat! We can actually pull off something similar in our interpreter with amazing ease. Because of the pure nature of our functional I/O system (last two posts ) and the already centrally managed world state and...
  • Blog Post: Functional I/O (including “I” this time)

    [Part 13 of the FScheme series ] Now to add input to our Functional I/O system; following up on the previous post . We already had bouncing balls so how ‘bout we add a mouse-controlled paddle and make a primitive “Pong”? Mouse Input To keep it simple, we’re just going...
  • Blog Post: Functional I/O (or at least “O”)

    [Part 12 of the FScheme series ] I just watched Matthias Felleisen’s talk on Functional I/O and read this paper and decided to bolt on a little I/O system to the FScheme interpreter we’ve been building. It’s a pretty nice FRP-type system. Reading the paper or watching the talk is...
  • Blog Post: Playing Dice with the Universe

    [Part 11 of the FScheme series ] We’re now taking the first small step into the world of nondeterministic logic programming (chapter 16 of Bill Hails’ book ). Hopefully you enjoyed the last post about continuation passing and found the idea to be ripe with potential power; indeed so powerful...
  • Blog Post: Turning Your Brain Inside Out with Continuations

    [Part 10 of the FScheme series ] We’re into one of the most magical chapters in Bill Hails’ book . We’re about to add a very strange and dangerous feature to the interpreter: ‘call/cc’ (“call with current continuation”). To appreciate the beauty of it, we’ll...
  • Blog Post: Recursion Is The New Iteration

    I remember the strange feeling as a kid the first time I saw structured BASIC after having been doing everything with line numbers. Any time I happened to walk into a Radio Shack in the early 80s I’d just have to leave this behind:   I was in a GOTO / GOSUB world ( give it a try ). The first time...
  • Blog Post: Language vs. Library

    [Part 9 of the FScheme series ] Primitives Perhaps this post should have gone along with the one about macros and how Lisp is a “programmable programming language.” The common tension in any language or runtime design is how much to build in as primitives and how much to implement as...
  • Blog Post: Oh, The Humanity!

    [Part 8 of the FScheme series ] 'set', 'begin', 'define' Here we implement chapters 10 and 11 of Bill Hails’ book . We’re about to do something hideous and horrible to the language (and to our interpreter). We’re about to add assignment. This is a travesty to a pure functional...
  • Blog Post: No Wait, Macro the Ultimate!

    [Part 7 of the FScheme series ] The Soul of Scheme We’re now getting into the language-oriented features of Scheme. This is why Scheme is one of my very favorite languages. Scheme is of course a multi-paradigm language; functional, imperative (next post), object oriented (soon), but most...
  • Blog Post: What's Lisp Without Lists?!

    [Part 6 of the FScheme series ] Once again, I must plug Bill Hails’ book Lists How could we even be pretending this is Lisp when we have yet to add lists! We need to add the standard ‘cons’, ‘car’, and ‘cdr’ for constructing and destructing list structure...
  • Blog Post: What ‘letrec’ Can’t Do

    [Part 5 of the FScheme series ] In this series I’m glossing over all the gory details. You really should read Bill Hails’ book ! Simultaneous 'let' We just added ‘letrec’ to solve the issue of bindings referring back to themselves. Remember that to implement it we first...
  • Blog Post: Rinse and Recurse

    [Part 4 of the FScheme series ] Recursive ‘let’ Normal ‘let’ can’t be used to bind names to recursive expressions (ones referring back to the names) because the expressions end up being evaluated in the calling environment before it’s been extended with the names...
  • Blog Post: Lambda the Ultimate!

    [Part 3 of the FScheme series ] Continuing along in Bill Hails’ book . Be sure to follow the previous posts . Lambda Now we’re going to add the all-powerful ‘lambda’! Since we’ve already done all the environment-passing plumbing from the last post, this will be...
  • Blog Post: Just ‘let’ Me Be Already!

    [Part 2 of the FScheme series ] Still working through Bill Hails’ awesome book . Adding to the FScheme interpreter from this previous post . Now we’ll add ‘let’. To do this we’re changing the evaluation model into an environment-passing one. Environment Passing ...
  • Blog Post: The Lambda Calculus

    Mads Torgersen’s post the other day was very cool! The first time I really understood Lambda Calculus was from this little 8-page paper . Relating it to Scheme made it stick for me. After reading Dr. T’s post I was just now having some fun playing with it in Scheme and couldn’t resist making a post of...
Page 1 of 1 (16 items)