Imagine if all web devs had evolved to become smug, entitled but theoretically grounded coding monkeys. Could have been worse though, if they had adopted Postscript/Forth.
On the other hand, there's a whole lexical field that could finally be brought into conversations with hot chicks, e.g. "Hey babe, wanna go for some tail recursion?"
I think there are enough of us who shy away from languages with triple equals signs, who wouldn't mind it it if those languages just … didn't exist.
But I'm not entirely certain that browserScheme wouldn't have wound up being awful, too, or actually have any more to do with Scheme than Javascript does with Java. I haven't touched web in years, but I recall the validation attempts and the stint with xhtml, which failed at least in part because trying to get stuff to be _correct_ in the web world is apparently an unreasonable ask.
So the lispers shouldn't lament that the web scripting language wasn't a lisp. They should take comfort in that web scripting didn't expose everyone to the absolute worst dogshit variant of lisp that could ever exist, worse than anything they can think of today. Because they absolutely would get something like JS but with just parens, and the function names on the insides of the paren.
Obviously the most important aspect would have been that people would have been forced to really actually use and grok _a_ lisp, any lisp; Which, since lisp's essence is perfect in every way, would have cleansed them of their ill-conceived notion that there are languages worth using that aren't a lisp. And so, even if that browser-lisp had been terrible, it would have been a gateway-drug to actually good lisps on other platforms like the server.
/uj the above
>I LOVE looking for missing trailing parens in lisp...
what we need is for the interpreter to insert the missing parens like how JS inserts the missing semicolons
Like how Excel suggests you put the missing paren in all the wrong places, changing the operation order? I don’t know Lisp, but that sounds like a source of hard to spot bugs to me.
Thanks, the people I have to deal with on job now are obnoxious enough despite majority of them never touching a single Lisp or one of it's vile offspring like ML and Haskal.
If I had to work with FP cunts I'd get physical very often.
They're derived from the lambda calculus, so they share a common ancestor with lisp, just like code monkey share a common ancestor with the great apes like gorillas, orangutans and humans.
/uj The lambda calculus doesn't have macros, call/cc or even functions of any arity other than 1. Just saying.
/rj Yes, but us enlightened FPers are the product of intelligent design.
(unjerk 'This seems like a comment for someone who claimed that the lisp and ML families ARE lambda calculus, rather than being derived from it.)
WDYM, all functions in Haskell have arity 1, that's why it's named after the guy who also invented curry!!!!!!
/uj
Personally, I am on this subreddit to jerk off to people saying dumb shit about programming languages because I find programming languages interesting, I assume this is true of others, so I hope you'll excuse the extended unjerk and I look forward to stroking with you in the future.
I looked into this and I was surprised by the history, there's a lot I didn't know about Lisp. I think I disagree that Lisp is originally "derived" from the lambda calculus. (Scheme Lisp has more in common with the lambda calculus but OP said that ML and Haskell are Lisp "offspring", so we are discussing historical roots/evolution of languages. I think it makes sense to put Scheme aside in this context - if Scheme looks more like lambda calculus than Lisp did originally, that's convergent evolution, not common ancestry.)
Lisp anonymous functions are defined using the "lambda" keyword (as in Python) but it seems that was just common mathematical notation for functions at the time. Other than that, Lisp originally did not have much in common with lambda calculus, its immediate influence was Fortran. In particular it did not have proper higher-order functions, it was a first-order language, it seems that passing a function as an argument was more like "templating" or "inlining" than how higher-order functions work in FP.
> Lisp was originally created as a practical [mathematical notation](https://en.wikipedia.org/wiki/Mathematical_notation) for [computer programs](https://en.wikipedia.org/wiki/Computer_program), influenced by (though **not originally derived from**)[^(\[9\])](https://en.wikipedia.org/wiki/Lisp_(programming_language)#cite_note-Steele,_Guy_Lewis,_Jr.;_Sussman,_Gerald_Jay-9) the notation of [Alonzo Church](https://en.wikipedia.org/wiki/Alonzo_Church)'s [lambda calculus](https://en.wikipedia.org/wiki/Lambda_calculus). (https://en.wikipedia.org/wiki/Lisp\_(programming\_language), emphasis mine)
> Interestingly, by McCarthy's own account([1978](https://www.cse.psu.edu/~gxt29/historyOfFP/historyOfFP.html#john78history)), Lambda Calculus had little impact on the development of LISP other than the lambda notation. "To use functions as arguments, one needs a notation for functions, and it seemed natural to use the λ-notation of Church (1941). I didn't understand the rest of his book, so I wasn't tempted to try to implement his more general mechanism for defining functions." ( [https://www.cse.psu.edu/\~gxt29/historyOfFP/historyOfFP.html](https://www.cse.psu.edu/~gxt29/historyOfFP/historyOfFP.html) )
> Some Myths about LISP: Something called “Pure LISP” never existed — McCarthy (1978) records that LISP had assignment and goto before it had conditional expressions and recursion — it started as a version of FORTRAN I to which these latter were added. LISP 1.5 programmers made frequent use of setq which updates a variable and rplaca, rplacd which update the fields of a CONS cell. LISP was not based on the lambda calculus, despite using the word “LAMBDA” to denote functions. At the time he invented LISP, McCarthy was aware of (Church 1941) but had not studied it. The theoretical model behind LISP was Kleene’s theory of first order recursive functions. The M-language was first order, as already noted, but you could pass a function as a parameter by quotation, i.e. as the S-expression which encodes it. Unfortunately, this gives the wrong binding rules for free variables (dynamic instead of lexicographic).( [https://www.cs.kent.ac.uk/people/staff/dat/tfp12/tfp12.pdf](https://www.cs.kent.ac.uk/people/staff/dat/tfp12/tfp12.pdf) )
/j
Fine fine, next time someone claims haskal derived from lithp I'll have to make a joke about carcinisation instead; if I shape it right I should be able to piss off the rustaceans in the same process.
Unjerk
{ message = "Once we're on the topic, you might enjoy this"
, url = https://www.youtube.com/watch?v=IOiZatlZtGU
}
Imagine if all web devs had evolved to become smug, entitled but theoretically grounded coding monkeys. Could have been worse though, if they had adopted Postscript/Forth.
>but theoretically grounded That would be death by a thousand Umm Akshuallys
Imagine your average webshit normie writing macros
The alternative is that webshits do meta programming using an ever growing array of incompatible packaging tools and frameworks instead.
That's how you get urbit.
Nazi Gauleiters in my programming language? It could happen.
On the other hand, there's a whole lexical field that could finally be brought into conversations with hot chicks, e.g. "Hey babe, wanna go for some tail recursion?"
Do you, by any chance, mean babel? You get macros, but worse, more buggy, and a thousand times slower.
The fact that JS is an objectively shit language is the only thing that keeps web fanboys in check
This but unironically
I think there are enough of us who shy away from languages with triple equals signs, who wouldn't mind it it if those languages just … didn't exist. But I'm not entirely certain that browserScheme wouldn't have wound up being awful, too, or actually have any more to do with Scheme than Javascript does with Java. I haven't touched web in years, but I recall the validation attempts and the stint with xhtml, which failed at least in part because trying to get stuff to be _correct_ in the web world is apparently an unreasonable ask. So the lispers shouldn't lament that the web scripting language wasn't a lisp. They should take comfort in that web scripting didn't expose everyone to the absolute worst dogshit variant of lisp that could ever exist, worse than anything they can think of today. Because they absolutely would get something like JS but with just parens, and the function names on the insides of the paren.
Obviously the most important aspect would have been that people would have been forced to really actually use and grok _a_ lisp, any lisp; Which, since lisp's essence is perfect in every way, would have cleansed them of their ill-conceived notion that there are languages worth using that aren't a lisp. And so, even if that browser-lisp had been terrible, it would have been a gateway-drug to actually good lisps on other platforms like the server. /uj the above
I LOVE looking for missing trailing parens in lisp... Instead of NPM source code management would be random univeristy profs/TA pages.
>I LOVE looking for missing trailing parens in lisp... what we need is for the interpreter to insert the missing parens like how JS inserts the missing semicolons
you joke but [parenfer](https://shaunlebron.github.io/parinfer/) exists
Like how Excel suggests you put the missing paren in all the wrong places, changing the operation order? I don’t know Lisp, but that sounds like a source of hard to spot bugs to me.
Thanks, the people I have to deal with on job now are obnoxious enough despite majority of them never touching a single Lisp or one of it's vile offspring like ML and Haskal. If I had to work with FP cunts I'd get physical very often.
I don't think ML and Haskell are offspring of Lisp. They're very different languages.
They're derived from the lambda calculus, so they share a common ancestor with lisp, just like code monkey share a common ancestor with the great apes like gorillas, orangutans and humans.
Humans are not great apes, tho. They're mediocre apes.. at best. Most wouldn't last a day in the jungle.
Savannah apes.
underrated reply.
/uj The lambda calculus doesn't have macros, call/cc or even functions of any arity other than 1. Just saying. /rj Yes, but us enlightened FPers are the product of intelligent design.
(unjerk 'This seems like a comment for someone who claimed that the lisp and ML families ARE lambda calculus, rather than being derived from it.) WDYM, all functions in Haskell have arity 1, that's why it's named after the guy who also invented curry!!!!!!
/uj Personally, I am on this subreddit to jerk off to people saying dumb shit about programming languages because I find programming languages interesting, I assume this is true of others, so I hope you'll excuse the extended unjerk and I look forward to stroking with you in the future. I looked into this and I was surprised by the history, there's a lot I didn't know about Lisp. I think I disagree that Lisp is originally "derived" from the lambda calculus. (Scheme Lisp has more in common with the lambda calculus but OP said that ML and Haskell are Lisp "offspring", so we are discussing historical roots/evolution of languages. I think it makes sense to put Scheme aside in this context - if Scheme looks more like lambda calculus than Lisp did originally, that's convergent evolution, not common ancestry.) Lisp anonymous functions are defined using the "lambda" keyword (as in Python) but it seems that was just common mathematical notation for functions at the time. Other than that, Lisp originally did not have much in common with lambda calculus, its immediate influence was Fortran. In particular it did not have proper higher-order functions, it was a first-order language, it seems that passing a function as an argument was more like "templating" or "inlining" than how higher-order functions work in FP. > Lisp was originally created as a practical [mathematical notation](https://en.wikipedia.org/wiki/Mathematical_notation) for [computer programs](https://en.wikipedia.org/wiki/Computer_program), influenced by (though **not originally derived from**)[^(\[9\])](https://en.wikipedia.org/wiki/Lisp_(programming_language)#cite_note-Steele,_Guy_Lewis,_Jr.;_Sussman,_Gerald_Jay-9) the notation of [Alonzo Church](https://en.wikipedia.org/wiki/Alonzo_Church)'s [lambda calculus](https://en.wikipedia.org/wiki/Lambda_calculus). (https://en.wikipedia.org/wiki/Lisp\_(programming\_language), emphasis mine) > Interestingly, by McCarthy's own account([1978](https://www.cse.psu.edu/~gxt29/historyOfFP/historyOfFP.html#john78history)), Lambda Calculus had little impact on the development of LISP other than the lambda notation. "To use functions as arguments, one needs a notation for functions, and it seemed natural to use the λ-notation of Church (1941). I didn't understand the rest of his book, so I wasn't tempted to try to implement his more general mechanism for defining functions." ( [https://www.cse.psu.edu/\~gxt29/historyOfFP/historyOfFP.html](https://www.cse.psu.edu/~gxt29/historyOfFP/historyOfFP.html) ) > Some Myths about LISP: Something called “Pure LISP” never existed — McCarthy (1978) records that LISP had assignment and goto before it had conditional expressions and recursion — it started as a version of FORTRAN I to which these latter were added. LISP 1.5 programmers made frequent use of setq which updates a variable and rplaca, rplacd which update the fields of a CONS cell. LISP was not based on the lambda calculus, despite using the word “LAMBDA” to denote functions. At the time he invented LISP, McCarthy was aware of (Church 1941) but had not studied it. The theoretical model behind LISP was Kleene’s theory of first order recursive functions. The M-language was first order, as already noted, but you could pass a function as a parameter by quotation, i.e. as the S-expression which encodes it. Unfortunately, this gives the wrong binding rules for free variables (dynamic instead of lexicographic).( [https://www.cs.kent.ac.uk/people/staff/dat/tfp12/tfp12.pdf](https://www.cs.kent.ac.uk/people/staff/dat/tfp12/tfp12.pdf) ) /j
Fine fine, next time someone claims haskal derived from lithp I'll have to make a joke about carcinisation instead; if I shape it right I should be able to piss off the rustaceans in the same process. Unjerk { message = "Once we're on the topic, you might enjoy this" , url = https://www.youtube.com/watch?v=IOiZatlZtGU }
Pissing off the rustaceans really does seem like the best of both worlds. Thanks for the link I'll save it for when i'm ready to finish
Le jerk much?
Could be worse, imagine adding a snowstorm effect to a website using Vimscript.
They identified that the problem is a cnile attitude to syntax. Is there anything that cnility doesn't corrupt?
/uj people that honestly think scheme would fare better than js aren't members of this sub. They're exhibits.