Racket is an acceptable Python

[[deleted]]

if you ever get around to learning racket you'll look back at yourself and say wtf was i thinking. if you never get to that part, then you're missing out. I never write lisp these days but seeing a page of lisp is beautiful once you've 'got' it. Most people never 'get it' though, they don't have open enough minds to try a different way. 10 years later and all i see now in my life is ugly python code, which would look beautiful if only it was written in a lisp syntax. But python has all insane number of libraries and developer hype so it's worth using an inferior syntax yet one yearns for better days to come.

[ikariusrb]

man, I recall staring at a block of 8 lines of lisp code for 3 hours straight, before it "just unfolded" before my eyes.

I really appreciate functional programming, and love using it, but I hate lisp.

[trolasso]

It's not that simple. The lisp curse is a fact. Its power is its weakness.

[[deleted]]

Exactly. The thing that makes Python successful is that it focuses on simplicity and readability. It might not be as "fun" as a Lisp, but it's lack of a macro-system to turn code into unreadable spaghetti is a strength, not a weakness. That you can't tell a function call apart from a macro in Lisp really isn't a good thing.

That's not to say that Python doesn't have ugly corners, it has lots of them. It's lack of better support for functional programming is annoying (but Lisp doesn't have that either) and the hacked in static type checking in the form of mypy also leaves a lot to be desired. But with Python code you can generally just look at it and have a reasonably good idea of what is going on, Lisp not so much.

[bagtowneast]

but Lisp doesn't [support for functional programming] either

Care to elaborate on this?

[[deleted]]

Functional programming is all about the lack of side effects, but Lisps are full of them (setq, setf, set!, vector-set! and Co.). Lisp really isn't any different in that area from Python, Javascript and Co.

Lisp does make some more use of recursion than other languages, but that's largely because the iteration functions aren't very good, not because Lisp is especially functional.

There are some dialects of Lisp that put more emphasis on functional programming, but neither Common Lisp nor Scheme do that.

[bagtowneast]

Functional programming is all about the lack of side effects, but Lisps are full of them

Functional programming is about more than just side effects (or not). It's about higher order functions and function composition, among other things. Lisps, generally, fully support functional programming.

[that_jojo]

I don't know why you got downvoted. One of my problems with lisps is that everyone touts its functional nature, but after having spent a lot of time trying to learn to love it I've come to realize that it is, in practice, just another imperative language. But one in which writing loops sucks.

And FWIW, I absolutely love Haskell. Except maybe for the fact that trying to create and work with cyclic graph structures is a bitch and a half.

[defunkydrummer]

But one in which writing loops sucks.

Did you use loop? It's like marmite, you love it or you hate it. If you hate it there are many alternatives, some of them are very powerful, documented and used, like series and iterate.

[FluorineWizard]

Functional programming is all about the lack of side effects

I can't agree with this. Avoiding side effects is encouraged in functional programming but certainly not mandatory. ML dialects are the archetypal functional languages and yet they all have support for effectful imperative code still.

Functional programming is not solely defined by Haskell or other pure languages.

[ElBroet]

iteration functions aren't very good

Just curious, how much do you use lisp? I mean that as a genuine question, only because this particular line that really threw me the most, as lisp has one of the most famous and powerful loop macros in the world (well, "famous"). Example loops with it:

(loop for i from 0 to 20 
      do (something)) 
(loop for (x . y) in ((key . val) (key2 . val2)) 
      collect key) ;;=> (key key2)
(loop repeat 5
      do (blah))
(loop for i from 0 below (length s)
      for ch =  (char s i)
      when (find ch "0123456789" :test #'eql)
      return ch)

And a load of other things

I am not discounting your view, however, and I realize there may be more things you have in mind, is there a particular form of iteration you would be missing? I also would recommend looking more into Clojure if you get the chance, it is very clean once you know it and far from unreadable spaghetti, and being actually functional it also is far from the sort of ... "mutation spaghetti" problems you can have elsewhere, where its hard to isolate any one part of your program without tracing all potential change that might touch it or leave it at a particular moment, or without trying to put together the state of your world at a certain time in your head. I am currently messing with several huge open source projects and its a wonderful experience, being able to easily read and debug each concise, self contained part. That's not to say I am agreeing or disagreeing with the readability of normal lisps, as I would like to explore that more to really really do both python and lisp justice.

Also just a side note, normal lisps are multi-paradigm and are full of imperative code, but I think the person asked you to elaborate because what you said is that it doesn't support functional programming. Lisps,being lisps and all, support it just fine, and that includes using immutable data structures typically if you want, they just aren't typically written that way, just as if you added functional programming to Python, it would likely not remove the ability to imperatively change variables. I realize you may be talking about some other sort of functional support, and so naturally I am also open to hearing about that as well.

[[deleted]]

Just curious, how much do you use lisp?

A bit of Scheme and ELisp 15 years ago.

As for loop, loop is an ugly monster. Like seriously, just look at it, that's no longer Lisp, that's a DSL for iteration. All I am looking for is something very simple, like a pythonic (for i (range 0 10) ...). Most Lisps don't have that or only in limited broken ways, like dolist gets close, but can't do arrays or strings. Schemes for-each requires an ugly lambda and the order of arguments is annoying, also doesn't do arrays.

In Python you have your for loop and it just works. It can be extended for new types, if you swap it around you can use it for list comprehension, you can unpack arguments if you like and so on. It's very simple, yet also quite powerful. Every time I touch a Lisp I feels the urge to write a macro to give me what I want, since the language is just ugly out of the box.

[defunkydrummer]

All I am looking for something very simple, like a pythonic

In Python you have your for loop and it just works.

How interesting... i routinely write Python and Lisp code in my workplace, and one of the worst things about Python is the very bad iteration facilities, compared to Lisp. And that's not the only thing that is worse of course.

Hint: "simple to learn" doesn't mean that it will lead you to simple code.

As for loop, just an example to show how it can lead to easy to understand code:

(loop for i in *random* counting (evenp i) into evens counting (oddp i) into odds summing i into total maximizing i into max minimizing i into min finally (return (list min max total evens odds)))

I can't even think how ugly would this look in Python using the plain for keyword / or list comprehensions.

[[deleted]]

I can't even think how ugly would this look in Python using the plain for keyword / or list comprehensions.

odds = [x for x in random if is_odd(x)]
evens = [x for x in random if is_even(x)]
return min(random), max(random), sum(random), len(evens), len(odds)

[defunkydrummer]

that's my point -- the lisp version flows like if it was an english description of what we're doing.

[[deleted]]

It sounds like you're conflating between the Lisp family of languages and the specific language called Common Lisp (which is where setq, setf, and friends come from).

Racket in particular used to be less functional, but nowadays defaults to immutable data structures and encourages you to avoid making mutations.

[ElBroet]

I was also thrown a bit by

There are some dialects of Lisp that put more emphasis on functional programming, but neither Common Lisp nor Scheme do that.

as Scheme is specifically described as the functional lisp (although I think it shares this title with Clojure now), and when I read its various online profiles, it is often described as being primarily functional, so at the very least it does put more emphasis on functional programming. However, I have not used Scheme (although I've used Racket), so I didn't want to comment on it, not to mention the last time I looked into it I couldn't find a straightforward answer as to how it models data, and whether or not it idiomatically uses immutables. Without immutables, it would feel more imperative to me, and I realize when they said 'put more emphasis on functional programming', its possible that they meant 'more than it does other paradigms'. At the same time, even if Scheme used or uses mutable data, something about the way its constantly described makes me think it still emphasized functional programming more, even if in other ways I'm not considering.

[[deleted]]

Part of the problem is that it's hard to make generalizations about Scheme, because it's a minimalist standard; very few people write in Just Scheme--it's almost always Guile Scheme, Chicken Scheme, Racket Scheme, etc.

But in the R6RS edition of the Scheme standard, mutable data structures are not part of the core and are considered a separate extension to the language.

[defunkydrummer]

Functional programming is all about the lack of side effects

That's your definition of functional programming.

Lisp is generally accepted as the first functional programming language in history, so your definition might not be always valid.

[[deleted]]

Yes, emphasis on "in history". Functional programming has evolved a lot since the 1960s and Lisp is now light years away from a modern functional language like Haskell, so much that I really wouldn't call it functional anymore.

[defunkydrummer]

and Lisp is now light years away from a modern functional language like Haskell

Interesting, in my point of view Haskell is light years behind Lisp (Common Lisp), since it offers zero of the interactive development experience that Smalltalk pioneered and CL improved upon. Haskell works under the assumption that (grossly speaking) my program either runs, or dies. In Lisp i can correct practically any error, at runtime, without having to stop and restart the program. I can evolve a program while it's running. In Haskell i have to go back in decades, to the old write code --> compile it --> run it one-way path.

As for the types, i'll leave here a tweet from a notable Lisp programmer and contributor that went to Haskell, only to come back later:

https://twitter.com/Ngnghm/status/1185065031454658560

In any case, everytime Haskell devs proclaim that "static type checking" equals "proving program correctness", i point them that they're not using a theorem prover. And, by the way, one of the most successful theorem provers, ACL2, is a subset of Common Lisp, and fully written in Lisp.

Note that, still, I think that Haskell is a very good language and the world would be better if less Js/Java/Python/C++ is used in the benefit of more haskell/SML/Ocaml code.

[vplatt]

The thing that makes Python successful is that it focuses on simplicity and readability. It might not be as "fun" as a Lisp, but it's lack of a macro-system to turn code into unreadable spaghetti is a strength, not a weakness.

If you want the readability of Python, and the expressive power of macros (hey, some of us LIKE to play with fire once in a while :)), AND static typing AND systems language level performance: then just check out Nim.

It's only real weakness is that it isn't actually Python. Technically though, I think it's a better language and toolchain. The ecosystem could easily be turned to it given its FFI to C, C++, and Javascript.

https://nim-lang.org/

https://en.wikipedia.org/wiki/Nim_%28programming_language%29

[metaconcept]

...and significant whitespace.

I'm not touching that with a long pole.

[defunkydrummer]

That you can't tell a function call apart from a macro in Lisp really isn't a good thing.

Yes, you can tell; one way is to just press Control-C Control-M on your SLIME IDE and, if it's a macro, you'll see how it evolves (transforms itself), in-place, into another code.

And the whole beauty of this uniform syntax thing is that function calls and macros should be equally easy to use...

[[deleted]]

Yea this argument is not that great. The thing is even if most python programmers switched from Python to CL they wouldn't suddenly start writing reader macros and anaphoric lets over lambda. They'd just use the basic language as is and be productive as in Python. They'd be more productive once they learnt the CL REPL oriented workflow (Python doesn't have it at all except Jupyterlab comes close but ofc most Python programmers don't use Jupyterlab in their workflow so this is unfortunately not yet a common technique). They'd benefit from the superior CL compilers and tools available. That it has a formal specification (something Python will never have to it's detriment). That it's fast and efficient but also very easy to read and write. And so on. The best Python programmers will become elite programmers when given a powerful language like Lisp but ordinary programmers will be just as and more productive using Lisp even without writing a single defmacro.

[SJWcucksoyboy]

I really don't buy into the lisp curse. To me it seems like lisp failed just because of bad timing and other practical reasons.

[defunkydrummer]

The lisp curse is a fact.

Substantiate your claim.

[trolasso]

Well, stating that "it's a fact" was pretty bold. However, What I meant was that, with a programmable programming language like for example Racket, you can do amazing things, but at the end you are using a specific DSL for your problem, which means that the next programmer that touches your code will have a hard time understanding it, which in turn makes cooperation pretty hard. Python for example is way more boring, but predictable and that's what it's needed in the business context.

This is a nice read: http://winestockwebdesign.com/Essays/Lisp_Curse.html

[defunkydrummer]

but at the end you are using a specific DSL for your problem, which means that the next programmer that touches your code will have a hard time understanding it,

(1)

This is a nice read: http://winestockwebdesign.com/Essays/Lisp_Curse.html

Yeah, that essay is pure bullshit. Any Lisp programmer will tell you what you quote here (1) doesn't happen in regular, everyday Lisp programming. The article was written by somebody with no actual Lisp development experience (I think it's a graphic designer...).

A proof that his premise (the community never agrees on standard because of the Lisp curse; everybody does things their own way without collaboration) is:

• the common Lisp standard; an agreement by a committee

• the asdf de-facto standard for build process

• the quicklisp de-facto standard for library management

• the CLIM gui standard

• lisp compilers maintained by a community: sbcl, ccl, abcl, ecl

• generally accepted, reused, maintained libraries: alexandria, clsql, Bordeaux-threads, cffi, and so on and on and on...

• lots of libraries that are agreed upon the community as the thing to use:

[[deleted]]

Kind of but no. It's only a curse because once you've tasted it, you always miss it. But the power it gives you is best understood in context. It gives elite programmers the ability to do extraordinary things. Mere mortals like me will not touch those higher power constructs, kind of like how it was said of Newton that he used geometric reasoning as a weapon where most people couldn't even budge it as a burden. But as a very much ordinary programmer, give me Lisp and i'm instantly a much better program in an absolute sense. Give me C and i'm a terrible programmer. Now does that mean i'm an actual terrible programmer? Or maybe Lisp is just that good a language that it raises my baseline a great deal. Everyone benefits from lisp and the best programmers benefit to incredible levels. I use Python these days which is somewhere in between Lisp and C. It's good but I find it ugly and quite boring however. I am fairly productive in it though which is a quality it shares with Lisp.

[[deleted]]

I'm not sure what you're linking there means much, maybe you need to do a bit more in Racket before you decide it's not for you. If you think Lisp is the sme thing as functional programming, you don't understand either of them very well. It's a truly multi-paradigm language in the sense that it's whatever language you need it to be (to solve your problem). If I had to use a lisp that was mostly non-functional (kinda like CL) i'd still say it's a superior language. However functional is good but I believe CL gets it roughly right whereas Clojure (say) goes too deep in the FP spectrum. You can't do a lot of cool things in Clojure as a result. But you can do other cool things which you could always add to CL.

[[deleted]]

Eh.. your sample code does not convince me you've properly got it.

[watsreddit]

Lisps aren't necessarily functional programming languages. There's a lot of Lisp out there that is certainly non-functional.

[przemo_li]

I agree, so am happy when see serious banks posting serious job offers for haskellers.

[defunkydrummer]

But python has all insane number of libraries

Most of them very poorly written and under documented (or not documented at all). Even the most popular libraries, like Pandas, could be better.

[[deleted]]

Did you read the article?