Posts with keyword: lisp

                    Tail Optimized Mutual Recursion in Clojure

                    Clojure, a LISP-dialect dynamic language that targets the JVM has been generating some interest in the programming language community lately. By targeting the JVM, Clojure gets speedy performance in a cross platform way. One of the problems with targeting the JVM with a dynamic language that relies heavily on recursion is that the JVM doesn't support tail recursion (also called tail call optimization). The idea is pretty simple: for some common patterns of recursion the function call can be removed and the recursive function be optimized to a loop. The result is not only programs that run faster, but
                    Continue reading...

                    John McCarthy on the Elephant Programming Language

                    John McCarthy(click to enlarge) He wasn't on the program, but this morning's keynote was given by Professor John McCarthy--the inventor of LISP and coiner of the term "artificial intelligence." This morning, he's talking about Elephant 2000, a programming language designed for writing programs that interact with people. One of the things he points out that I find interesting is the idea that the compiler should generate required data structures without the user having to specify them. I'm not sure how that works from his explanation, but I'm certain that if we want languages that admit more parallelism, this is
                    Continue reading...

                    Types as Comments

                    Steve Yegge is at it again. This time he's taking on modeling: Well, we also know that static types are just metadata. They're a specialized kind of comment targeted at two kinds of readers: programmers and compilers. Static types tell a story about the computation, presumably to help both reader groups understand the intent of the program. But the static types can be thrown away at runtime, because in the end they're just stylized comments. They're like pedigree paperwork: it might make a certain insecure personality type happier about their dog, but the dog certainly doesn't care. If static
                    Continue reading...

                    Arc Is Released

                    Paul Graham has released Arc, his new language. Arc is still a work in progress. We've done little more than take a snapshot of the code and put it online. I spent a fews days cleaning up inconsistencies, but it's still in the semi-finished state most software is, full of hacks and note-to-self comments about fixing them. From Arc's OutReferenced Wed Jan 30 2008 16:21:31 GMT-0700 (MST) Paul mentions Arc in a number of his essays: The Hundred-Year Language http://www.paulgraham.com/noop.html http://www.paulgraham.com/progbot.html Some Work on Arc Arc Paul wrote HackerNews in Arc as a "big project" to shake out the
                    Continue reading...

                    ParenScript: A Lispy JavaScript Generator

                    Feedback on my interview with Bruce Johnson on the Google Web Toolkit led to ParenScript, a little language for Lisp that generates JavaScript. From the intro: ParenScript is a small Lispy language that can be compiled to JavaScript. It also comes with client-side HTML and CSS generation libraries. This approach simplifies the development of web applications by enabling all components of the application to be written in Lisp, so that HTML, CSS and JavaScript code can all be generated with the full power of Lisp and its macros. At the same time, ParenScript strives to produce maximally readable JavaScript
                    Continue reading...

                    A Lisp Interpreter in Haskell

                    Defmacro.org has an excellent little article on using Haskell to build a working Lisp interpreter--at least a good start at one. I do something similar with my 330 class using Gofer (an outdated dialect related to Haskell). I mostly use Gofer to show them how type inference works, but since they're studying interpreters, they might as well see an inerpreter in Gofer while we're at it. It's been too long since I've known monads well enough to decipher what he does at the end. I'm going to have to go back and review and then look at his article
                    Continue reading...

                    On the Acceptability of Lisp

                    Steve Yegge has a post that I just stumbled across on why Lisp isn't an acceptable Lisp. He hits on some great points, many of which numberless concourses of Lisp programmers would argue with him endlessly on. Nevertheless, good reading. His points: Which Lisp? Worthless Spec CLOS Macros Type System
                    Continue reading...

                    Practical Common Lisp

                    I just published an interview with Peter Seibel at IT Conversations. I did this interview as part of my Technometria podcast. I saw Peter's book, Practical Common Lisp, in the bookstore a while back and picked it up. Now, I'm a Lisp fan, so he didn't have to sell me on the language. Even so, as someone who sees a lot of programming language books, I was impressed with this one and read it cover to cover. Peter and I talk about his background, how he came to Lisp, some of Lisp's most powerful features (like macros, CLOS, and
                    Continue reading...

                    Effective Scheming

                    I received an email from a former student who's caught the Scheme bug. He says: I took 330 from you last year and I really enjoy coding in Scheme. I do any class project I can in Scheme -- even my Python code is riddled with lambda statements. I have two questions I was hoping you could help me with What are the prospects for kids who like coding in Scheme/Lisp, and how does one locate/maximize those prospects? What are some key things I could do to become a really great Scheme/Lisp coder? That is, what are some concepts
                    Continue reading...

                    LISP Ecosystems

                    I criticized Allegro yesterday at Between the Lines for a business model that sells programming language development environments like they were enterprise software. Programming languages and their development environments are free in the 21st century--at least that's how most people think about them. I can't imagine approaching a VC, for example, with a business plan that has as it's basis selling programming language tools. The problem is that programming languages depend on complex ecosystems of libraries, IDEs, testing tools, Web components, and so on. A reader at BTL said it in this way: Where's the ecosystem? LISP was born
                    Continue reading...

                    Who Knew?

                    Who knew that Peter Coffee was a closet LISP junky? First he published this piece on "exotic" languages that I commented on at Between the Lines and then yesterday, he put out an article entitled LISP Deserves a Fresh Look. Peter's argument has two prongs. His first point is that old arguments against LISP are largely no longer true. The current generation of application developers has been imprinted with a business model of mass-market software as frozen bits, packaged as executable binary files, delivered on inexpensive media units--floppy disks or CDs--to run on a PC. This model is merely
                    Continue reading...

                    JavaSchools, Scheme, and Sin

                    Joel Spolsky has a great essay on the perils of JavaSchools, those CS programs that adopt Java (or .Net, to be fair) because it is easy for students to learn. In it, he sings the praises of learning Scheme and being exposed to functional programming. Without understanding functional programming, you can't invent MapReduce, the algorithm that makes Google so massively scalable. The terms Map and Reduce come from Lisp and functional programming. MapReduce is, in retrospect, obvious to anyone who remembers from their 6.001-equivalent programming class that purely functional programs have no side effects and are thus trivially parallelizable.
                    Continue reading...

                    Time to Learn LISP

                    I just posted an article at Between the Lines called Time to learn LISP, a riff on Peter Coffee's recent piece on LISP and other "exotic" languages and techniques going mainstream.
                    Continue reading...

                    Ways of Thinking, Ways of Doing

                    In a recent column, Jon Udell says "much of what seems to be modern innovation is, in fact, rediscovery of ... Lisp and Smalltalk." He goes on later to say: If existing tools can do more than we realize, we could spare ourselves a bit of grief. But probably not a lot. Translating ways of thinking into ways of doing always takes longer than we predict. From The spiral staircase of SOA | InfoWorld | Column | 2005-09-28 | By Jon UdellReferenced Wed Oct 12 2005 09:55:00 GMT-0600 (MDT) This is an interesting point and one that's under-appreciated, particularly
                    Continue reading...