Stories
Slash Boxes
Comments
NOTE: use Perl; is on undef hiatus. You can read content, but you can't post it. More info will be forthcoming forthcomingly.

All the Perl that's Practical to Extract and Report

The Fine Print: The following comments are owned by whoever posted them. We are not responsible for them in any way.
 Full
 Abbreviated
 Hidden
More | Login | Reply
Loading... please wait.
  • Common Lisp barely has syntax. Where are all the reliable F/OSS cross-platform CL implementations then?

    chromatic, I understand your frustration with jpersson's comparison, but that does not make your false analogy correct.

    If we start with the premise that "sharp objects are cheap and easy to fabricate", it's a huge leap to ask "where are all of the disposable samurai swords [wikipedia.org]?" In fact, there are very many "disposable sharp objects", but we call them "razor blades", "box cutters" and "toothpicks".

    Th

    • Languages with simpler syntax are easier to implement, easier to re-implement, and easier to build to a robust state.

      Aristotle expanded on what I meant, but I still want to push the point of CL. What does it take to write a CL reasonably competitive with SBCL? You have to compete with its performance (which likely means targeting architectures directly), or portability, or library support, or getting at least one of those an order of magnitude righter than SBCL. None of those have anything to do with

      • What does it take to write a CL reasonably competitive with SBCL?

        A whole heck of a lot. First, you need to be compliant with CLTL2 [cmu.edu], which clocks in at over 1,000 pages. Then, if you want to make an ANSI Common Lisp implementation, there's additional work to implement the diffs [tech.coop] between the two specs.

        By comparison, the original Lisp specification was 2 pages, the original Scheme specification wasn't much bigger. R4RS and R5RS both clock in at about 50 pages.

        All of this gets back to the original point of contention:

        Common Lisp barely has syntax.

        That assertion is simply untrue. Common Lisp has plenty of syntax. It's just that its syntax is quite regular and appears simple on the surface.

        If you were making a point that a language with a truly simple syntax should spawn a plethora of robust, open source implementations, then that assertion seems valid, even though you claim it isn't. Witness all of the robust open source Scheme implementations available today. If you want to take it back to the original vision of Lisp (car, cdr, cons and all that), then there are in fact thousands of these implementations produced every year. They just happen to be better known as "homework assignments" rather than "robust, production-grade open source systems". They tend to be written and forgotten (like many open source projects) because the language they implement simply isn't very interesting.

        Perhaps my analogy was over-broad, but if I wanted to write a robust, cross-platform F/OSS application in CL, my options are few. If ease of writing a parser for a language were really significant to the difficulty of implementing the language, I would expect to have more options.

        Now you're really conflating a whole mess of issues. :-)

        Common Lisp is not a simple language, even though its roots are in Lisp. Expecting it to be simple because it is derived from a language with transparently simple syntax is like expecting you to reproduce by mitosis because, at some point in your past, your ancestors were single celled organisms. Although parts of do you reproduce by mitosis, as an organism, you yourself do not split into two every time you find yourself in a vat of growth media.

        You are castigating Common Lisp for being complex, and not having the properties of a simple language. Common Lisp is complex. It is not a simple language. A simple language like plain old vanilla Lisp truly is simple, and has the kind of properties you assert Common Lisp lacks.

        • Common Lisp has plenty of syntax. It's just that its syntax is quite regular and appears simple on the surface.

          Perhaps we mean different things by syntax. The way I understood the original comment, syntax means "Things you need to write a parser for." For CL, that's basically identifying applications, atoms, conses, and symbols, while providing access to the parser for macros and allowing (optionally) a couple of special forms (I think you can provide everything you need if only eval and cond are spec

          • Perhaps we mean different things by syntax. The way I understood the original comment, syntax means "Things you need to write a parser for."

            No, we mean the same thing. Lisp is all cons cells and lambdas. It's a small language, which is why it can be defined in one page of code [technologyreview.com]. (I said "two pages of code" before, because Technology Review originally published an annotated version as a centerfold spread).

            Common Lisp is not that language.

            Common Lisp, for one example, supports macros. Macros are read by the reader function (the parser), and change its behavior. Common Lisp also supports modules, which can export macros, and also change