In article <47a154ae$0$4950$4c368faf / roadrunner.com>, phlip2005
@gmail.com says...
> Jerry Coffin wrote:
> 
> > Strangely, C had actually implemented a relatively complete assert
> > facility around the time it became possible to do so in Lisp.
> 
> Even the oldest C could do stringerization, with a trick:
> 
> #define assert(foo) if(!(foo)) fprintf(STDERR, "\
> foo
> \ failed");

I don't think the _very_ oldest C could handle this. If you ever feel 
like looking, Dennis Ritchie has a museum on his web site that includes 
some early C compilers. These include some versions so old some of the 
_very_ basic parts of the language were still in flux (e.g. on that 
doesn't support 'struct' at all). OTOH, but the mid-70's, things had 
settled down quite a bit -- in particular, memory was no longer quite so 
constrained, so he could implement a more complete language without 
simply overflowing the memory available on the (only) Unix machine at 
the time. 
 
> Someone check my syntax, but that would reflect 'whatever' if you failed 
> assert(whatever). However, this could not _reliably_ reflect argument 
> values. Even C++, with <iostream>, cannot reliably reflect both arguments 
> and values, for an assertion that's healthy to type.

True -- I didn't mean to imply that its original assert was identical or 
equivalent to what you've written; quite the contrary, C (and C++) have 
make any sort of reflection quite difficult at best. OTOH, what they 
provided 30 years ago (or so) still seems to be better than what Ruby 
does by default...

> So C++ made up for this by letting me put a breakpoint into the 
> assertion, so it would break directly into the calling code. I could TDD 
> in the debugger quite effectively like that.
> 
> What my assertion gives for a Ruby project, without a debugger, is all 
> the "watch points" that a debugger would have provided:
> 
> assert_{ reflect_string(statement) == statement }       --> false - 
> should pass
>     statement                 --> "lambda{|*a| p( a ) }"
>     reflect_string(statement) --> "lambda{|*a| p(a) }".
> 
> Yes, Lisp probably did, too, that before I was born!

Without knowing how old you are, that's harder to guess. Then again, 
even if I did know your exact age, it could be hard to answer. Most 
languages draw a clear line between the compiler/interpreter/whatever 
and your code. Lisp doesn't; it allows you to play directly with the 
implementation quite easily, and it's generally considered quite 
reasonable for ordinary code to use things that would be completely 
hidden and inaccessible in most other languages. As such, it's usually 
difficult to say anything like "nobody did X before day Y", with respect 
to Lisp.

-- 
    Later,
    Jerry.

The universe is a figment of its own imagination.