Just finished SICP with Racket

And I'm not convinced about anything other than that Racket is slow as shit in a funnel. Explain this satori thing to me.

>>38
You've got a point.

racket sucks. use python, it should be much faster than that antiquated lisp crap

>>42
alas, it isn't.

>>40
I haven't seen any that works with mutually recursive calls, like the ones you would use to implement state machines. Of course, in that case you would be told to use ``pythonic'' endless loops with exception throwing/catching to switch states.

>>44
state machines
python
elif:
elif:
elif:
elif:
elif:
elif:

>>45
fuck you nigger

>>46
The truth. It hurts

FUQIN EXPERT PROGRAMMER here, what's going on in this thread?

>>45
def state_loop(state, args):
    while True:
        state, *args = state(*args)

>>49

(define (state-loop state args)
  (let-values (((state args) (apply state args)))
    (state-loop state args)))

>>50

(define (state-loop state args)
  (call-with-values (apply state args) state-loop))

How would you code a state machine?
1) >>49
2) >>50
3) >>51 (faggot)

4) Cudder

>>52
Google "swine before perl"

>>52
GO(TO)'s and labels.

>>55
>>50 gets optimised to jmps due to TCO.

>>56
yes. the total cost of ownership is especially optimizable.

>>42
http://shootout.alioth.debian.org/u32/which-programming-languages-are-fastest.php

According to that page, the great python has 41.79 points while poor racket has 4.42. Indeed, python is much faster!

>>58
According to the last GIT commits, they have improved the shootout benchmarks, they are all > 1.5x faster.

>>59
According to my python interpreter, You're an anus!

>>58
According to this graph: http://shootout.alioth.debian.org/u32/racket.php

Racket in half of the cases is more verbose than Java. Can you fucking believe it? More verbose than Java!

Lol at Scheme's "elegance".

>>58
those aren't points, they're seconds.

>>62
Excellent work, inspector.

>>61
In Java, most of the code is type declaration, access specifiers and such, in Racket, like in Scheme and Lisp, it's 99% actual code. The code length is not the same as verbosity, or would you say that C is verbose because of all those mallocs and frees making the code look bigger?

Also, it is comparing Racket to Java. Racket's code length is ½ of the Java one in the majority of cases.

Racket is also faster in that benchmark.
A fair comparition would be, though, comparing Racket with Java -server: http://shootout.alioth.debian.org/u32/benchmark.php?test=all&lang=racket&lang2=java, which is known to be faster than the client one (but being a resource hog) and, in fact, also faster than Racket.

>>64
In Java, most of the code is type declaration, access specifiers and such, in Racket, like in Scheme and Lisp, it's 99% actual code.
That only shows that the ``actual code'' of Lisp is even more bloated than it would otherwise appear.

>>65
That only shows how much you are confused about the words ``bloated'' and ``verbose''. I explained that immediately after the phrase you quoted, read the rest of my post.

oh sweet sweet mary dubs O__O

>>66
Hey Doc, what do you think about that guy who customized his Lisp interpreter (I have no idea whether it was Scheme/CL/whatever) so that it imported various constructs from ML/Haskell and other?

>>68
From the source he posted some time ago (http://dis.4chan.org/read/prog/1293351605/27,28), it was CL.
I have no problems with him implementing a DSL, it's fun and a good exercise, every Lisper has made at least a simple DSL in his career.
I envy his DSL, it seems to have done a really good work with it and should be proud of it, but he shouldn't post his code written in it and say ``I wrote x in Lisp'', when it's clearly a DSL.
What makes him appear like a stupid is his stubborness on the fact that that's just Lisp, plain Lisp, giving reasons like ``it has lists and sexps''. Of course, a DSL have to give a way to communicate with the underlining language/system, that's the purpose of its existence, the fact that his language can communicate with the underlining CL implementations only strengthens the motivations to call it a DSL.

He should just post the complete implementation and then saying ``I wrote x in my Lisp DSL''.

>>69
I disagree, but only slightly. The problem is that it's hard to tell what is a DSL and what is the original language, especially if the original language allows (and even encourages) macros. After how many macros does a Lisp stop being a Lisp and become a DSL? Does removing the parentheses and putting something else in place (do/end, {}/[], etc.) automatically makes the language a DSL?

Personally, I'd say that the only way to tell apart a DSL from the original is whether you can still escape into the original language. I'm not sure though...

I think that the fact that he can say ``I wrote x in Lisp'' should not anger /lisp/ers; quite on the contrary, they should feel proud of the power and extensibility of their favourite language. I think the real reason why some are angry is because that guy still refuses to publish his macros and documentation. The frustration experience by the aforementioned is akin to that of showing a child a very interesting toy then taking it away from them.

*experienced

>>70,71
The difference between a Lisp macro and a DSL is, IMHO, that a Lisp macro has its syntax and all, but it's still under the domain of the Lisp reader (with the exception of a reader macro, whose purpose is to extend the reader instead of the language), whether a DSL needs its own parser.

The loop macro is a perfect example of the extensibility of Lisp, but it's just a macro, its parser parses a list of symbols with car and cdr and generates code, it can't have something like f(x, y, z), it would be parsed as 'f '(x ,y ,z) and would also be a syntax error, because , has already a special meaning for the reader.

In a macro, you can't know if after the foo symbol there was a space, a newline or a tab, because your macro is just a piece of Lisp code that runs at compilation/expansion time.

His DSL seems to not respect the reader, a piece of code could be written without any space (http://dis.4chan.org/read/prog/1293689458/1), and I doubt he would just take a big symbol, transform it to string, do the parsing and fight with the reader at every parser iteration. As seen in http://dis.4chan.org/read/prog/1293689458/37, he calls a repl function (macro?) and passes his code as string. He does all the parsing and calls the Lisp reader when necessary.

A nice work indeed, but it can't be called ``Lisp'', parsing a string at compile time and generating code can also be done with D mixins/templates, something like loop still can't be done in other languages.
But this is just a speculation, we don't really know how the DSL and its parser works, it could be anything.

AUTISM ALERT

http://jjinux.blogspot.com/2008/02/scheme-implementing-cons-car-and-cdr.html

>>73

(define cons
  (lambda (x y)
    (lambda (c)
      (c x y))))

(define true
  (lambda (x y) x))

(define false
  (lambda (x y) y))

(define car true)
(define cdr false)

(define-syntax list
  (syntax-rules ()
    ((~ x l ...) (cons x (list l ...)))
    ((~) '())))

>>70
The frustration experience by the aforementioned is akin to that of showing an autist a very interesting toy then taking it away from them.
FTFY

>>75
go fuck a goat you cock sucking niggerfaggot

>>76
Well, I can't really say ``go back to board'', now.

u liek my codan? http://pastebin.com/FTAGv0Kx