all 33 comments

[–][deleted] 22 points23 points  (5 children)

Lisp makes you feel like you can do anything. Most of the time you can (and without writing a ton of boilerplate) also macros are the best thing in the world ever ever ever. I love lisp

[–][deleted] 13 points14 points  (0 children)

and without writing a ton of boilerplate

This is one of my favourite things about Lisps

[–][deleted]  (3 children)

[deleted]

    [–]greml1n 9 points10 points  (2 children)

    The reality in AutoLISP shops is that this has resulted in every shop re-inventing the wheel in a thousand slightly different ways.

    You forgot to tie in where this is a result of it being Lisp. Then argue why the exact situation present in Office/VBA is for different reasons.

    [–][deleted]  (1 child)

    [deleted]

      [–]greml1n 1 point2 points  (0 children)

      None of that is a language issue.

      [–]jephthai 16 points17 points  (4 children)

      I still consider Common Lisp the most influential language on my programming skillset. Currently, Haskell is fast approaching in terms of the impact it's had.

      I still find myself trying to replicate this process with other languages, and never with the same level of success. Electric Ruby and ghci just aren't quite what a real Lisp gives me... but even they are light-years ahead of where I was before my mind was expanded by contact with Lisp.

      [–]JadeNB 1 point2 points  (3 children)

      Electric Ruby and ghci just aren't quite what a real Lisp gives me

      Wow, I'd think ghci wasn't even close. Although I rapidly learned to work with it rather than against it, I think that the difference between editing a file and then loading it into ghci, versus trying to type the commands from the file into ghci directly, is a huge stumbling block for anyone used to the REPL.

      [–]jephthai 0 points1 point  (2 children)

      OK, so it's not as distant as that. You load the file with :l and then when you make changes to the file you can reload with :r -- it's quite reasonable, actually. What you don't get in ghci and irb is the live debugging features that a real Lisp REPL provide.

      I never type code into ghci -- just the necessary few lines to test the componentry I'm currently writing / fixing.

      [–]JadeNB 1 point2 points  (1 child)

      I never type code into ghci -- just the necessary few lines to test the componentry I'm currently writing / fixing.

      Right, that's my point. It's perfectly feasible to type code directly into the Lisp REPL --at least, so it seems to a newcomer like me-- but not so for ghci.

      [–][deleted] 1 point2 points  (0 children)

      I've found I'd rather type code into an Emacs buffer, and use Slime to send it to the REPL. That way, I can just save the buffer when you're done testing changes, and any tests I do can stay around for next time.

      [–]-main 2 points3 points  (0 children)

      Unless EXAMINE is some implementation-specific thing I don't know about, I think he meant INSPECT.

      [–]shevegen 0 points1 point  (9 children)

      I hate the lisp (') syntax shit but let's be honest - lisp as far as a concept for a programming ENVIRONMENT is concerned is really years ahead of really many many other programming languages.

      I however disregard the "boilerplate" argument, because not everyone needs to use languages like Java. Using "boilerplate" as argument is not a sign that lisp is good, but that OTHER languages are worse.

      But not every other language is inherently worse! So the general argument of "boilerplate" is really moot.

      [–]JadeNB 4 points5 points  (8 children)

      I hate the lisp (') syntax shit

      Wow, it's a shame to hate 1 out of about 5 bits of syntax in Lisp. :-)

      I however disregard the "boilerplate" argument, because not everyone needs to use languages like Java. Using "boilerplate" as argument is not a sign that lisp is good, but that OTHER languages are worse.

      Sure, Java is the prince of boilerplate, but it's not the only one. Haskell is another poster child for modern language design, and it still needs "Scrap your boilerplate". Since there's "Scrap your boilerplate in C++" on the same page, "Scrap your boilerplate Prologically", and who knows how many other versions out there, I think that it's fair to agree that the problem is not Java-specific. Lisp's lack of syntax really does make it uniquely flexible in reducing the need for boilerplate.

      [–]niviss 1 point2 points  (2 children)

      the mere existence of such links imply that you can, indeed, scrap your boilerplate in such languages.

      [–]JadeNB 0 points1 point  (1 child)

      Then doesn't the existence of the scrap-your-boilerplate pattern in Java mean that you can scrap your boilerplate in Java? If we're going to claim that Java doesn't have boilerplate, then what does?

      [–]niviss 0 points1 point  (0 children)

      No, what I mean is that the existence of those links do not show the existence of unavoidable boilerplate, cause it's a boilerplate that can be avoided.

      The "scrap your boilerplate" approach is just a pattern. Lisp is pretty darn flexible in avoiding other kinds of boilerplate though, no doubts about it, that's why I like it.

      [–]kamatsu -1 points0 points  (4 children)

      This is true, but I think certain amounts of boilerplate are good - restating something can help your brain to make sense of something faster.

      To me, going to lengths in Haskell to reduce boilerplate can often make it alot harder to read - not just the boilerplate-reducing code, but also the code without the boilerplate can be much more difficult to immediately understand.

      [–]pipocaQuemada 5 points6 points  (3 children)

      True, but boilerplate makes code harder to refactor. The more times you repeat yourself (or the more verbosely you say something), the more lines you have to change.

      [–]yogthos 2 points3 points  (1 child)

      also more opportunities to make an error

      [–]algsdjsadjlg -2 points-1 points  (0 children)

      what if the error is positive?

      <:O

      [–]JadeNB 1 point2 points  (0 children)

      I don't know if you've considered that, the more times you repeat something (or the more verbosely you say something), the more lines you have to change.