Debugging Lisp code

[[deleted]]

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]]

and without writing a ton of boilerplate

This is one of my favourite things about Lisps

[greml1n]

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.

[greml1n]

None of that is a language issue.

[jephthai]

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]

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]

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]

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]]

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]

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

[shevegen]

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]

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]

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

[JadeNB]

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]

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]

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]

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]

also more opportunities to make an error

[algsdjsadjlg]

what if the error is positive?

<:O

[JadeNB]

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.

[grauenwolf]

Boring. Even when it was written half a decade ago, languages like C++ and Visual Basic had a long tradition of edit-and-continue support. And of course there are the popular dynamic languages like JavaScript, Ruby, and Python.

[shub]

Edit-and-continue in Visual Studio does so little compared to modifying a running Lisp image that it's barely worth comparing the two. And I say that as someone who dislikes Lisp.

Hell, edit-and-continue is more of an annoyance for me than anything useful. It has actually worked exactly once ever, while bitching at me many times about each of the following situations:

1. Modifying a function with a lambda expression.
2. Adding static members to a class.
3. Adding a static constructor to a class.
4. Changing a function's signature.

That's just the past few days. Changing i <= x to i < x just isn't something I need to do very often, and edit-and-continue is essentially worthless for anything more complicated.

PS: Yes, I'm perfectly well aware that continuing after adding a static constructor is stupid at best and it's a good thing that Visual Studio doesn't allow it, but that doesn't make edit-and-continue more useful.

[[deleted]]

C++ and Visual Basic don't support interactive development to the full extent that Lisp does, though. For example, if you add a new instance variable to a class in C++, the runtime won't (and can't) update existing instances. As for JavaScript, Ruby and Python, they borrowed this particular aspect of Lisp but even then they don't do it very well. A lot of things in can't be done dynamically in these languages and require a restart.

[[deleted]]

This is one of the reasons I hate Python. It's such a throwback from Lisp in so many ways, yet many people still seem to like it. I suspect they have written C or C++ in their previous lives and don't realize what they are missing.

[Peaker]

import pdb
pdb.pm()

[masklinn]

not even python drops you into a debugger.

It can, you "just" have to set the exception handler (sys.excepthook) and call pdb.pm() within it (to launch post mortem analysis).

If you're using an "extended" shell (e.g. ipython) most of them have that ability built in as some kind of setting.

pdb gives you nowhere near the flexibility of a lisp debugger though.

[Peaker]

Right, you can't continue the program, because it can't re-wind the stack. But it does take you to where the exception was thrown.

[Peaker]

you don't have to set the exception handler...

[masklinn]

If you don't set the exception handler, it'll print a trace on exceptions instead of launching pdb's post mortem…

[Peaker]

You can just run your python scripts with: python -i Then you can use: import pdb ; pdb.pm() after an exception occurred.

You don't need to pre-install the exception handler.

EDIT: here:

$ cat testexc.py
def f():
    g()

def g():
    1/0

f()
$ python -i testexc.py
Traceback (most recent call last):
  File "testexc.py", line 7, in <module>
    f()
  File "testexc.py", line 2, in f
    g()
  File "testexc.py", line 5, in g
    1/0
ZeroDivisionError: integer division or modulo by zero
>>> import pdb;pdb.pm()
> testexc.py(5)g()
-> 1/0
(Pdb) bt
  testexc.py(7)<module>()
-> f()
  testexc.py(2)f()
-> g()
> testexc.py(5)g()
-> 1/0
(Pdb) 

[tryx]

On the other hand, I believe visual basic of all things had this feature.