Lisp. Lisp is the only language

Why there are other programming languages besides Lisp? With Lisp's macro system you can create any language you need ever. Small, big, finely tuned for your task. Supporting other languages means opposing progress and delaying the inevitable future. There should be only one language and myriad languages at the same time. The one language is Lisp.

>>70
That's still syntax. Just because you use binary digits as your alphabet, that doesn't mean you don't have syntax. Without syntax, there can't be language.
IHBT

[/ascii] fuck you whorecode

>>79
Define |> and all the macros that define your DSL in order to support it.

IHBT

>>52
Learning Lisp is not difficult.
>>21 never said that Lisp, he mentioned the high layer of abstraction and implied it's a mind-opener.

>>51
Why don't you bold your overlines?

>>83
define .
define []
define (:)
define =
define $

>>81
But it isnt predefined. It can be anything you could imagine.

>>85
i lol'd

>>85
nice.

>>81
What about Forth, does it have syntax? It's a succession of words, like Lisp is a succession of lists, delimited by *whatever character reads lists in the readtable*

>>89
Sure, Forth's basic syntax is this:
program ::= word [whitespace program]
word ::= <any printable ascii character>*
whitespace ::= <any whitespace character>*

To all speaking about syntaxen and antisyntaces, see >>25.

>>86
Actually, the syntax is predefined. You [i]can[i/] change it, yet that still doesn't mean it doesn't have one. And when you do change it, it is no longer Lisp, it's something else entirely. A language is it's syntax and it's semantics. If you change one or the other, it's not really the same language anymore.

>>92
You are now aware of the ``in Lisp DSL'' and the fact that #( is just a reader macro.

Also >>91.

>>91
It's not about making anyone happier, it's about not saying downwrite wrong shit just for sound bite.

s/write/right/

>>94
Saying ``non-syntax'' and ``simple syntax'' is the _fucking same thing.
Non-syntax implies having syntax that is not real syntax. The syntax dictates how something has to be done/written, in Lisp you can change it whenever you want.

LISP Is Semantic Programming.

>>84
>>21 never said that Lisp, he mentioned the high layer of abstraction and implied it's a mind-opener.
What higher level of abstraction are you talking about? Closures and higher-order functions? VB.NET code monkeys all have had this mind-opening revelations already, come to terms with it and don't consider it something worth boasting of.

Look, I'm not saying that it's not mind-opening, it most definitely is. Like, you know, the realization that each integer can be thought of and operated on in terms of its prime divisors. That is a pretty WHOA realization too, before you thought that all integers are like black boxes, now you see the structure in them, the true nature.

I'm saying that these are pretty basic, simple things. You must learn them, but you can't boast about it. It's like learning to use toilet, which another pretty important stage in personal development!

When I see a person who remains in this excited state about Lisp for months and years and decades, I can only assume that she is retarded, that she was never able to completely understand and internalize these higher-level concept, so they never lost this earth-shattering quality for her. And doubly retarded because she doesn't notice that she positions herself as being dumber than VB.NET code monkeys these days.

A mind-opening revelation is supposed to left the mind in the more open state and pass. If instead the mind is forever locked in some half-open, perpetually being opened, state, it is not normal, it's some kind of phimosis.

>>93
It doesn't matter how syntax is implemented. It's still there. But I kinda see what the ``no syntax'' comes from. Lisp is actually just the interpreter/compiler program, whith which you interact through a basic predefined language (which is also called Lisp), which itself has constructs that allow you to tell the interpreter/compiler to modify (mostly the syntax of) the language it implements. And the same goes for Forth. But to say that Lisp doesn't have syntax is still misleading. Because, if you're talking about the language, that's just plain absurd; and if you're talking about the compiler/interpreter, well, it wouldn't have a syntax anyway, it would understand a syntax.

s/what\( the ``no syntax''\)/where\1 thing/

>>90
Sure, any language's basic syntax is this:
program ::= character [program]
word ::= <any ascii character>*

>>101
Nope, that syntax right there allows for constructs that wouldn't be part of most languates. That basic Forth syntax I gave you is pretty much the syntax of Forth in interpretation mode. Of course, when you go into compilation mode, it has all the extra syntax for control flow constructs and stuff. But yes, I get what you're saying, what I posted wasn't even close to a complete Forth syntax.

>>101
You just demonstrated beyond any reasonable doubt that you are not qualified to participate in a discussion about programming language syntax.

>>102 the same applies to you, for not recognizing just what >>101 wrote.

>>98
What higher level of abstraction are you talking about? Closures and higher-order functions?

Code=data, you can make a program that writes your program at runtime
I just woke up and can't write nothing more than this.

When I see a person who remains in this excited state about Lisp for months and years and decades, I can only assume that she is retarded

We (well, most of us) are not in that state about Lisp, we're just saying that Lisp has things other languages don't have (or, few languages have: TCL has homoiconicity and can ``fake'' macros using upvar and uplevel, which are both really powerful and enable call-by-name, Forth has macros (immediate words), etc)
Of couse, I have periodically a big "Aha!" when coding in Lisp, when ``discovering'' a new way to do things, and do them better.
You never really master Lisp, you always have something new to learn because of the freedom it gives to the programmer.

Also,
she
IHBT.

>>104
Yes, I do realize that the ``basic Forth syntax'' I posted is also too general to be called a Forth syntax, and is hence not just ``incomplete'' but plain wrong. But anyway, that just goes to show that Forth does have a syntax (that is actually not that simple) even if it is extensible.

>>96
Non-syntax implies having syntax that is not real syntax. The syntax dictates how something has to be done/written, in Lisp you can change it whenever you want.
Oh, so Perl has a non-syntax too.  Thanks for clearing that up!  And here I thought you were just being a jerk and using words with no meaning because you thought they sounded vaguely impressive.

>>105
Code=data, you can make a program that writes your program at runtime
I just woke up and can't write nothing more than this.

... I repeat, yes, the realization that there's no magic inside the computer, that a C compiler is just another program, and that there's nothing special about source code to prevent it from being generated by another program, is mind-opening.

The alternative -- I'll spell it out for you, -- believing that compilers work by magic and that only a human can write source code, is outright retarded. Stupid. Idiotic. In a clinical sense, like shitting your pants.

Unless you are a babe, or just began learning to program, of course. But if you are a dude in your twenties, shitting your pants or thinking that compilers are magical, that means that you are mentally retarded.

And if you are a dude in your twenties or older, and you tell everyone about how you've discovered that you can shit in the toilet or that code is data, you are exactly one small step above clinical mental retardation.

Which is made all the funnier by your attitude, demonstrated for instance in the "beating the averages" by Paul Graham (the "blub paradox" part).

We (well, most of us) are not in that state about Lisp, we're just saying that Lisp has things other languages don't have

Every popular language developed in the past twenty years has higher-order functions and some form of compiler-as-a-service functionality. The former makes macros technically unnecessary, the latter is the gist of the "code is data" idea, true homoiconicity is just the glazing.

Every. Popular. Language. Not just TCL. Perl, Python, Java, Ruby, C#. Even C++ gets true closures now.

Every. Popular. Language. Does this sink in?

What can I feel about a person who is ignorant of this basic fact of nature, but (or, "and because of it") considers himself an expert on relative merits of programming languages, and his chosen language to be superior to most of the rest?

Of couse, I have periodically a big "Aha!" when coding in Lisp, when ``discovering'' a new way to do things, and do them better.
You never really master Lisp, you always have something new to learn because of the freedom it gives to the programmer.

This is not limited to Lisp. This is true for every popular language developed in the past twenty years. Unless you can't see that freedom, because you are an idiot, of course.

It is not about the language, it is about what you write using the language, and every popular language developed in the past twenty years lets you get to that part relatively painlessly.

>>108
... I repeat, yes, the realization that there's no magic inside the computer, that a C compiler is just another program, and that there's nothing special about source code to prevent it from being generated by another program, is mind-opening.

that a C compiler is just another program, and that there's nothing special about source code to prevent it from being generated by another program
Are you really a Lisper? Have you ever heard of eval? Calling gcc from a C program to compile a C source ``generated'' at runtime, written in a file with fwrites and fprintfs is not homoiconicity, and the compiled new program doesn't have nothing to do with the current running one.

compiler-as-a-service functionality.
Not the same, read above.

The former makes macros technically unnecessary,
That's not true, learn to macros.

the latter is the gist of the "code is data" idea, true homoiconicity is just the glazing.
You never used eval in Lisp, ok.

Every. Popular. Language. Not just TCL. Perl, Python, Java, Ruby, C#. Even C++ gets true closures now.
Every. Popular. Language. Does this sink in?
Did I mentioned closures? Where? I know that.

What can I feel about a person who is ignorant of this basic fact of nature, but (or, "and because of it") considers himself an expert on relative merits of programming languages
see >>108

Unless you can't see that freedom, because you are an idiot, of course.
Indeed I can modify every little aspect of the C programming language.
Modern?
Indeed I can modify every little aspect of Python, I don't even use indentation anymore, and I implemented multiline that accept statements with my powerful macro sys-Oh.
Well, Ruby has extensive metaprogramming support and nice syntax for it at runti-Wait, but that makes it SLOW AS FUCK!!!
I don't really know, maybe Perl 6, but it's a mudball of operators.
Maybe I am an idiot, can you please enlight me?

It is not about the language, it is about what you write using the language, and every popular language developed in the past twenty years lets you get to that part relatively painlessly.
Implement the ``in Lisp DSL'' in your favourite popular language that is good just because it's popular, please.

Calling gcc from a C program to compile a C source ``generated'' at runtime, written in a file with fwrites and fprintfs is not homoiconicity, and the compiled new program doesn't have nothing to do with the current running one.
It is not homoiconicity but it is a full embodiment of the "code is data" idea. Why do I need to repeat myself? Ah, because that's what one has to do when talking to a not very bright person. But I digress.

If you don't see how you can achieve everything macros give you by runtime codegeneration, then you don't truly understand the "code is data" concept. Which is my point, really -- to remain fascinated by some idea you must forever have it half-understood. Not because it's too complex or rich, but because you are fucking dumb. Also because you and your circlejerk fellows keep telling ourselves that you've already there, that you've "become better programmers simply by learning Lisp", and there's no need to move forward.

The former makes macros technically unnecessary,
That's not true, learn to macros.
That is true. You don't understand that because you don't understand the essence behind macros. You see them as a final concept, kind of like some VB.NET dolt might view his "if" operator.

Did I mentioned closures? Where? I know that.
I mention closures because with closures you technically don't need macros (which you don't understand). Also, three of the six languages I mentioned have fully-fledged eval, C# has expression trees and C++ has touring-complete templates.

Indeed I can modify every little aspect of Python, I don't even use indentation anymore,
You are concerned about indentation because you are not a programmer.

Implement the ``in Lisp DSL'' in your favourite popular language
You are an idiot. ``in Lisp DSL'' is not the something, it's not a thing.

>>110
And so, after witnessing no less than two ad hominem fallacies, I declare the other guy the winner.

>>111
go fuck yo'ureself

>>111
Yeah, "my uninformed opinion is as good as your expert knowledge", and when the other side points out that the opinion is, in fact, uninformed, it's an "ad hominem" and automatic loss.

Internet is an elitist meritocracy, baby. If you are an idiot, you would be called an idiot and your opinion would be disregarded, appeals to "ad hominem" wouldn't protect you.

>>110
but it is a full embodiment of the "code is data" idea.
Explain why, I give a reason of why it IS NOT:
and the compiled new program doesn't have nothing to do with the current running one.

The evaluation must be done in the current scope of the current program, not elsewhere, not using a compiler, it must be done inside the language, it's not about macros, it's about evaluating fucking code generated at runtime by the current program, for the current program.

This is code=data:

(define (generate-lambda args-list &rest body) `(lambda ,args-list ,@body))

You can eval this at runtime and will generate a lambda using the runtime arguments you give to that function, not macro, at runtime. And will return the lambda, it's not an indipendent file that does indipendent things. The code I generate at runtime is used in the current program. Get it? Eval.

That is true. You don't understand that because you don't understand the essence behind macros. You see them as a final concept, kind of like some VB.NET dolt might view his "if" operator.
Nope, the only thing that resembles Lisp macros in a ``modern'' programming language are D mixins and Nemerle macros.

I mention closures

Ok, but it is known that all new languages support closures

with closures you technically don't need macros (which you don't understand)

Why? A macro is code executed at compile-time, it generates code, a closure is created by from a new lexical scope that closes over a free variable, at runtime. They are not interchangeable, they are two different things, it's like saying ``with functions you don't need ifs''.

Also, three of the six languages I mentioned have fully-fledged eval,

But the code is not data.

C++ has touring-complete templates.

But I can't pass code to a template.

You are concerned about indentation because you are not a programmer.

It was an example, can't I make examples?

You are an idiot. ``in Lisp DSL'' is not the something, it's not a thing.

If it exist, it is a thing. Implement something like that in your favourite popular language.

>>114
Oh god, I wrote some mutant strange CL/Scheme derivative there, I really wanted to write:
(define (generate-lambda args-list . body) `(lambda ,args-list ,@body))

ITT: Lisp. Lisp the language of faggots

>>116
ITP: >>110 that can't admit he's lost.

>>117
Winning on the Internet.
( ≖‿≖)

The evaluation must be done in the current scope of the current program

Why? It seems like you think that "programs" are real and important, and can't see the computation behind them. The "code is data" concept is about computations. The restrictions you try to impose ("in the same program", blah blah) are utterly irrelevant.

It's like if a not very bright Lisp programmer declared that Haskell is less powerful than Lisp because in Lisp conses are mutable, while in Haskell you have to return another cons, and another cons is not the same cons. Like if computation cared about such minutae.

Nope, the only thing that resembles Lisp macros in a ``modern'' programming language are D mixins and Nemerle macros.
Again, you are talking about superficial resemblance.

>> with closures you technically don't need macros (which you don't understand)
Why? A macro is code executed at compile-time, it generates code, a closure is created by from a new lexical scope that closes over a free variable, at runtime. They are not interchangeable, they are two different things, it's like saying ``with functions you don't need ifs''.
And again, the shallowness of your thought is astonishing.

Macros and closures are tools. Instruments. They are used to achieve some goals, to write a program that has certain form and does certain things. I say that having closures allows you to do anything you can do with macros, in a more or less similar fashion. Like, screws and nails look differently and are applied differently, but in the end when you need too planks put together, it doesn't matter much if they are nailed or screwed together.

And yes, with anonymous functions I don't need a built-in "if", I can write my own which would be used in pretty much the same fashion. Have you read your SICP today?

Also, three of the six languages I mentioned have fully-fledged eval,
But the code is not data.
Why, is there such a huge difference between using a single grave mark and two quote marks?

But I can't pass code to a template.
Um, why do you want to do it? I urge you to go look at boost::lambda (the interface, not the implementation) to get a feeling of what is possible with templates.

It was an example, can't I make examples?
It is bad enough when you can't see "what" behind "how", as above. It is even worse when you bring up stupid "what"s, like changing the method for indicating nesting. You can go discuss such matters with your buddies, I'm completely not interested in it. I don't want to replace FOIC with braces, I don't want Language-Integrated BBCode, neither is related to programming. Not interested at all, sorry.

>> You are an idiot. ``in Lisp DSL'' is not the something, it's not a thing.
If it exist, it is a thing. Implement something like that in your favourite popular language.
http://www.google.com/search?q=%22in+Lisp+DSL%22&ie=utf-8&oe=utf-8

Why? It seems like you think that "programs" are real and important, and can't see the computation behind them. The "code is data" concept is about computations. The restrictions you try to impose ("in the same program", blah blah) are utterly irrelevant.
Please, just shut up.

It's like if a not very bright Lisp programmer declared that Haskell is less powerful than Lisp because in Lisp conses are mutable, while in Haskell you have to return another cons, and another cons is not the same cons. Like if computation cared about such minutae.
You're getting boring.

Again, you are talking about superficial resemblance.
Lisp macros are called Lisp macros because Lisp has Lisp macros.

And again, the shallowness of your thought is astonishing.
Macros and closures are tools. Instruments. They are used to achieve some goals, to write a program that has certain form and does certain things. I say that having closures allows you to do anything you can do with macros, in a more or less similar fashion. Like, screws and nails look differently and are applied differently, but in the end when you need too planks put together, it doesn't matter much if they are nailed or screwed together
From today, start programming in BASIC, not even Visual Basic, just BASIC. It is Turing-complete, it's just a tool, it has everything you need, it can do all the computations you need to do because it's Turing-complete, blah, blah.
Stupid brainless troll.

And yes, with anonymous functions I don't need a built-in "if", I can write my own which would be used in pretty much the same fashion.
(define (if p t f) ; how does I branched without something to branch with now, without using (lambda (x y) x) and (lambda (x y) y) for true and false, because they are not #t and #f, because they are not t and nil, (``somebranch-when-eq?-p-#t'' (t) (f))
)
(if (number? 3) (lambda () (display "it's true")) (lambda () (display "it's false")))

Have you read your SICP today?
I have, what about you? Have you compiled your metacircular evaluator in C, today? Hahaha I'm so funny, C is not homoiconic!

Why, is there such a huge difference between using a single grave mark and two quote marks?
Because Lisp programs are lists, C++ programs are not strings. '(1 2 3) is a shorthand for (quote (1 2 3)). Are you saying that C++ translates "string" to string(string);? What about the spaces, then?

http://www.google.com/search?q=%22in+Lisp+DSL%22&ie=utf-8&oe=utf-8
You are new to /prog/, aren't you?
Here, take a look of what we call ``in Lisp DSL'': http://dis.4chan.org/read/prog/1293689458
The name derives from the guy that, posting his code written in the DSL, keeped saying he wrote it in Lisp.
From then, he was called ``in Lisp'' guy, the DSL ``in Lisp DSL''.

Even if we joke on it, the DSL is very powerful and pure art.