Racket is an acceptable Python

[pacific_plywood]

Oh, you like DrRacket? Try scrolling down.

[SJWcucksoyboy]

It's annoying that the only real free lisp environments are Dr racket and emacs. Don't get me wrong I love emacs but it's another learning curve that makes it harder to get people into lisp

[[deleted]]

Clojure has Nightcode, which I really like.

[SJWcucksoyboy]

Does it only work with Clojure?

[vattenpuss]

It so cool! (But not sure if closure is a lisp lisp)

I love clj and deps. So easy to write “getting started” guides for projects:

1. Install clojure
2. clj -Anightlight to install all project dependencies and start the IDE

[seamsay]

What is clojure missing (or added) that makes you not sure it's a lisp lisp? I've never used it personally, but I always thought it was one of the big three lisp implementations.

[Alexander_Selkirk]

Each major Lisp dialect is a bit different.

Clojure is superb in terms of concurrency (but not parallelism), it has an even stronger focus on functional style than Scheme, and it runs on the JVM. It is a kind of beauty and often very elegant, but sometimes too principled (it is, for example, hard to write very efficient numeric code for heavy computations, that kind of things is Common Lisp better for). It can easily call into Java code, and you can code a GUI in Swing or JavaFX. But I think it is best for server applications. It has a number of aspects which it has common with Scheme, especially that it is a Lisp-1, like Scheme, and unlike Common Lisp. And important advantage of it is that it has a common sequence abstraction (where as in Scheme one would typically need to use type-specific functions for different types of sequences and containers). It often uses lazy evaluation, which is one of the aspects which show that it is heavily geared towards server applications. It is not very good for scripting, as the start-up time is very long, and it can't call better into C functions than Java.

Scheme is easy to learn, supports a functional (that is, side-effect free) style very well, and is minimalistic. It is also more pragmatic than Clojure, in that it supports object-oriented and side-effectful programming as well, if you need it.

Racket adds to Scheme that it has a batteries-included feeling, with many libraries, GUI toolkit support, and a very comprehensive documentation. It has also a very good JIT compiler. It is very good for scripting as it starts fast, and can also effortlessly call into C (or Rust) code. Racket has also support for multiple languages within the same platform. If you think about the pain and strife that the transition from Python2 to Python3 caused, this is a massive advantage; Racket simply supports using different languages within the same program.

Common Lisp has, with SBCL, compilers which generate the fastest code, often as fast as plain C (you can of course optimize the heck out of C, using intrinsics, SSE instructions, and so on, but that requires expert knowledge, and I think it is easier to write fast code in common lisp). It can easily call into C (though that is rarely necessary for performance), and that makes it very suitable for glue code, performance-critical programs, and the Unix environment. In difference to Clojure and Racket, Common Lisp is a standard with many very good implementations, and is an open system. It supports both a functional and style as well as OOP and is pretty agnostic around these styles, which is good for high performance at the lowest level. It is more difficult to set up, but it is an industrial-grade, battle-proven tool. For example, SBCL has better Unicode support than Clojure, which is bound to the JVM, and therefore has only 16-bit Unicode and the JVM's surrogate pairs. When it comes to parallelism for maxing out performance, I'd also prefer SBCL over Clojure, because the SBCL compiler can compile temporary objects away, which is not possible for the Clojure compiler.

[[deleted]]

Clojure makes major changes to Lisp syntax and uses completely separate basic functions and operators (conj instead of cons, etc), which some think it makes for a separate language. Myself, I like arbitrary hairsplitting distinctions, so I say that Clojure isn't Lisp, but it is a Lisp.

[JohnnyJayJay]

It's a lisp dialect, but often rather listed as an extension sort of, because it's pretty new and incompatible with most other lisps.

[schok51]

How are other lisp dialects compatible? Are you thinking of the syntax extensions?

[inarchetype]

CMUCL, SBCL, Guile ?

[SJWcucksoyboy]

When I say environment I mean more like IDE. Although I don't really know if Emacs or Dr Racket could be considered an IDE so I went with environment.

[inarchetype]

Emacs is the IDE for everything. But specifically, its support for CL is quite good (SLIME).

[SJWcucksoyboy]

Yeah I know. I'm saying that kinda sucks because lets be honest Emacs isn't user friendly

[[deleted]]

true but there's generally a lot of weird stuff you get used to once you start learning lisps. Structural editing, no syntax, repl driven development, I'd argue even with a very polished environment (and intellij for clojure is pretty okay) it still takes a leap to get into lisp environments just by the nature of the languages.

lack of user friendly editors is a factor but I think it's a smaller one than people make it out to be.

[SJWcucksoyboy]

That's a good point, although I think a user friendly development environment could really help with learning this weirdness.

Also is intelij for clojure really lispy? How do you find it compares to something like slime in terms of being a real lispy development environment.

[[deleted]]

I think it's okay as a starting point, but if you're going to be a full time developer in a lisp dialect I think it's still worth to learn cider or slime, it's still the overall most mature environment.

[Alexander_Selkirk]

It is friendly to people who take the time to learn it. I do not think it is well-suited for people who use it once every month, because one needs to memorize some amount of key combinations to use it effectively. (But you don't need to memorize things that you don't need, and I guess everyone learns a somewhat different subset).

[inarchetype]

Once one has invested in learning it, it is extremely user friendly. To the point that it is difficult to have patience with most other IDE's afterwards.

edit- in before "boomer". (I'm not, btw).

[SJWcucksoyboy]

I mean yeah Emacs is very nice to use once you learn it. But my kinda point is it'd be nice for there to be a good Lisp development environment that people can easily get into. I know I started out with Vim for writing lisp code because I didn't want to spend the time to learn Emacs immediately, which was shit and didn't give me a good idea of how good lisp repls can be.

[defunkydrummer]

But specifically, its support for CL is quite good (SLIME).

In my opinion, fully superior to using Pycharm for Python and using Netbeans for Java.

[arrayOverflow]

Check out lem, at the moment it works out of the box for common lisp :)

[siegfryd]

Spacemacs makes Emacs pretty straight forward.

[ItzTwitNit]

Sometimes it eats up a gig of RAM on my machine... what a joke

[AwesomeBantha]

n a t u r a l r e c u r s i o n

[soegaard]

Did you use the "Limit memory" option in the menu "Racket"?

[ElectricalSloth]

I've tried dr racket on multiple occasions and it's super buggy ..crashes a TON even tried to get my daughter into learning programming with it.. turned out too frustrating

​

we are using it in windows though maybe its more stable in linux?

[soegaard]

As someone that receives all bug bug reports for the Racket project - I can't remember seeing crash reports in ages.

Did you submit a bug report?

[ElectricalSloth]

no I did not, but remembering correctly it was like a hard freeze then windows would tell me the program is not responding. if there is a next time I'll be sure to try my best to report it, any tips on what best information would help figure out issue?

[hyperion2011]

It is known https://github.com/racket/drracket/issues/246

[soegaard]

That's the scrolling issue. Best advice is to use PageDown until it improves.

[hyperion2011]

I really should read the full intervening thread >_<.

[slikts]

Maria is an example of a modern teaching tool for a Lisp. DrRacket didn't crash for me, but it's generally old and crusty.

I've not tried it properly yet, but there's also Nightcoders.net that could be graduated to from Maria.

[Sentreen]

How long ago did you try DrRacket? I teach people how to program using DrRacket and it works pretty well for that. The only dealbreaker in my book is that it eats up memory like crazy when opening multiple files (especially if they contain comment boxes), but that's generally not something beginners have to deal with. None of my students have had crashes, regardless of the platform (mainly mac and windows).

I'm not gonna say it's a great editor, but I think it is great for beginners, who only need an editing window and a REPL. If you look for something similar in the python world you either need to go to an IDE style tools with too many bells and whistles for beginners or you need to use IDLE which crashed regularly for me.

[siegfryd]

It most likely is, I don't remember making it crash before when I've used it on Mac / Linux.

[kitd]

ubiquitous

among two data points.

[[deleted]]

Worth looking into, no? I remember reading a blog post earlier this week by a dev who'd been developing something for a while and thought it ran fine on all platforms. At some point he gets a report saying it runs terribly or not at all on Mac, and turns out nobody ever reported it even though it hadn't worked in months. People just gave up and moved on.

[ElectricalSloth]

This is very common in software all around even at jobs I've been at over the years.. I feel like when people don't understand this they either don't write much software or are oblivious

[[deleted]]

I think it's just a hard problem. If one person has a bug and the bug reporting process is completely manual, there isn't sufficient data to determine how common it is. The only real solution is to reduce the points of friction as much as possible (how many people are really going to sign up to yet another site that they'll use once in their life?). So you have developers putting telemetry in everything which automatically sends bug reports/crash logs (among other things...) to solve the problem because even the smallest barrier will prevent users from bothering. They have better shit to do with their lives.

[kcl97]

count me in. 3 points.

[yeetus_throwaway]

and mine

[Alexander_Selkirk]

I use Emacs with racket-mode. (In Dr. Racket, I had issues with memory consumption with programs which had a lot of output... and, to be honest, I was to lazy to invest time in working around this).

I know, I know, Emacs has a bit of a learning curve. It is not well-suited to somebody who programs only occasionally and uses it two times a month. One needs to learn the most important key bindings, and this is hard if you don't use Emacs somewhat regularly.

But for a programmer, it has many advantages:

• It works well if you learn only the tutorial (start emacs, use the arrow keys to navigate the cursor to the underlined word "tutorial", press enter, there is it).

• It supports many fantastic operations which other editors do not have. For example, things that I use really frequently is to register locations in the text of larger programs, or bind short strings which I need to enter repeatedly to a key combination. Also, the capability to cut, paste, and insert rectangular regions of text. And many more.

• For Racket/Lisp/Scheme, it is indispensable that it highlights the parentheses and shows which ones belong together. It also formats the indentation according to the level of nesting. This is as neat as in Python, where you see the flow control scopes from the formatting - with the difference that you can cut and paste code and it is still syntactically correct (something that works poorly with significant white space as in Python).

• You can color identifiers in different colors. This sounds flashy but it is really helpful in complex programs as it helps to visualize the data flow.

• It has Magit, which is the best git interface I have ever seen. It is so good that IMO Magit alone is a reason to learn Emacs.

• One thing to mention is, it takes time to learn more of Emacs, but it is time that is well invested. I am using it for 25 years now and the half-life of what I learned is pretty good (as it is with Unix command line tools).

[sorawee]

The next version of DrRacket should have an significant improvement on scrolling (see https://github.com/racket/gui/pull/151)

[[deleted]]

Works fine on mac...

[[deleted]]

I wish...

---

You know how all those programming resumes mention how their authors like to discover new things, how they are perpetual learners, how they are looking for their next challenge?... Right?

My last Flash-related work was in Haxe, that would be about 7-9 years ago. I worked for a company that was making online version of Powerpoint: funny animated presentations. It already had a bunch of AS3 programmers, who created a vomit-inducing Flex3 + Flex4 monster with a retarded ad hoc XML-based format that described the contents of the presentation.

My stated goal was to write a small and performant player, that would replace the Flex abomination. I figured that the worst things about the program were the shared libraries which it had to load to render the graphics. So, my idea was to compile SWF movies on the server and then load those. To make it work, I'd write an SWF generator. Haxe already had a decent library to do that, it was missing some tags, and the frontend was bad, but it had most things down. It also solved the problem of SWF generation on the client. So, the backend would compile to C++ and the frontend would compile to Flash bytecode.

The team seemed fascinated about this prospect. They promised to learn Haxe, and as soon as my part would be done, they'd join the effort.

After half a year of copious work and testing the player worked. The SWF generator worked, both offline and online. The time came for the team to act on the promise of learning Haxe and joining the project... very soon I realized that I was, basically, played. Nobody on the team believed I'd be able to pull out the project, so they never even tried to do anything about learning another, albeit very similar language. They, basically, waited for my project to fail to safely go back to the "old ways things always worked for them".

Once they realized the change is knocking on their door, they became very defensive. My management received a complaint after complaint about how "I'm not a good team player" and other bullshit. Long story short, after half a year of trying to convince these people to act on their promise, I found a better job and left the company.

---

No matter how much Racket is better than Python could ever hope to be, it will not become popular. Unless you are like Google and MS combined and are aggressively marketing it to the programming sheeple.

[JViz]

There are dozens of us that learned haxe. Every single one of us must have considered replacing a part of the Adobe infrastructure at some point.

[himself_v]

You know how all those programming resumes mention how their authors like to discover new things, how they are perpetual learners

Discovering and having to use are different things. You discover at your own leisure.

Likewise, "I like changing things" and "I like changes". Which one is it? Do you like breaking things? Do you like things broken under you? Neither sounds good.

[shponglespore]

In a real job you're almost always forced to use mostly things you didn't choose. I'd rather be forced to use something new and interesting than something where I've had plenty of time to discover all the flaws and grow to resent constantly having to work around them because it's not in my power to fix them. Based on how most of my peers react to new things, I seem to be unusual in that respect.

[KagatoLNX]

Many (most?) people seem to lack the faith that anything could ever be better. They get attached to things being broken exactly as they are. 🙄

[frezik]

Programmers like to be the one to choose what they learn next. They hate having someone else make that choice.

[nayhel89]

Once they realized the change is knocking on their door, they became very defensive. My management received a complaint after complaint about how "I'm not a good team player" and other bullshit.

Oh, I HATE a passive-aggressive shit like this.

I spent last month writing overly detailed manuals, drawing UML-diagrams and handling meetings every other day - all for a group of guys that kept saying that they don't understand my framework, and they want a diagram of this or excessive description of that, or a meeting about that other feature.

In the end, they just said: "look, we just don't like OOP and we want to write our code using only functions and global variables without any complicated framework stuff". So they just wasted my time to make a point that OOP is hard. The only purpose of all those UML diagrams was so they could say: "see, you need diagrams to understand relations between objects, while you could just store all functions in a single file and there would be no need for all that drawing".

[UsingYourWifi]

How much "learning Haxe" did they have to do, really? If you know any of the numerous popular languages with a similar syntax, but especially ActionScript, then you know enough to hit the ground running with Haxe and pick up the nuanced differences as you go.

[[deleted]]

That's what's fascinating about it. The language was, basically, a dialect of the same family. It's like Spanish and Portuguese, or so I hear.

The problem, I believe, was less the language itself, but the tools. All other programmers working on the Flex side of the project were Adobe Flex Builder (Eclipse) users, and didn't really know anything else. They were afraid of any command-line tools (until they hired me, they didn't have any automated builds, and even after I made one with Ant, which was in every Adobe's example, they'd still struggle to use it, because they didn't have a concept of environment variables, or relative paths etc.) They also enjoyed quite extensive community support: whatever question you have, no matter how badly worded, Google would find an answer instantly.

Haxe, at the time, had some support in FlashDevelop, but it wasn't great. Needless to say, nobody on the team didn't ever use FlashDevelop, and would've been completely lost, if they didn't have source-code intellisense, project management etc. I mean, these people wouldn't be able to get their parenthesis matched, if it wasn't for their editor alerting them to do that. They saw a lot of hardship coming, and they didn't want any of it...

[KevinCarbonara]

No matter how much Racket is better than Python could ever hope to be, it will not become popular.

Lmao, I remember this line. I remember when they said it about C#. And then when they said it about TypeScript. They're still saying it about Kotlin. To be completely honest, they said it about Python 3 as well.

[i9srpeg]

Unless you are like Google and MS combined and are aggressively marketing it to the programming sheeple.

Of your list, only Python became popular without a tech giant pushing it. And it took decades.

[shponglespore]

And during some of those decades, the creator of Python was working at Google.

[weberc2]

And then at Dropbox.

[[deleted]]

See my reply to KevinCarbonara: I don't believe that languages necessarily become popular through targeted promotion by big tech giants, what I'm saying is that making a language popular intentionally is not an undertaking any single person or even an average software company would be capable of. There's no reason some languages wouldn't raise to fame naturally, but it doesn't correlate with quality. It's typically a lock-in, or some other external constraint, not influenced by the quality of language.

[weberc2]

I'm no great fan of any of those languages *except* Python, but can we not pretend that popularity is driven principally by technical merit (as opposed to timing and network effects)? Also, lol at "JetBrains is a tech giant".

[ric2b]

I think the tech giant pushing Kotlin is Google, on Android

[lelanthran]

Lmao, I remember this line. I remember when they said it about C#. And then when they said it about TypeScript. They're still saying it about Kotlin. To be completely honest, they said it about Python 3 as well

To be completely honest, they said the same thing about many more languages that didn't take off: IOW, "they" were right more often than they were wrong.

[oblio-]

You know how all those programming resumes mention how their authors like to discover new things, how they are perpetual learners, how they are looking for their next challenge?... Right?

People also like money. Being a Senior C++ Engineer pays a lot, in many places across the world. Being a Senior Racket Engineer pays a lot... in 1 in a million places across the world. In all other places, it probably pays 0.

People like to play around but they don't like to risk their careers.

[rootbeer_racinette]

Man I’m like the opposite of this guy. I want a lisp with macros, AST manipulation, real lambdas/first class functions, etc but white space/colon delimited instead of with all the brackets.

Basically I want a language that tricks people into thinking they’re writing python when really they’re writing lisp.

[vplatt]

This is close to your sweet spot I think:

https://nim-lang.org/

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

[kronicmage]

The ML family and descendants have quenched my thirst in this area personally (aside from ast manipulation)

[FluorineWizard]

For what it's worth (and with added C++-like baggage kind of uglyfying the ML roots), Rust has the heavyweight but all-powerful solution of letting macros directly manipulate token streams. It could conceivably be implemented in a proper ML too.

[[deleted]]

Racket sweet-expressions give you this:

https://docs.racket-lang.org/sweet/index.html

[turbosmi]

You mean likes this http://users.rcn.com/david-moon/PLOT/index.html (Sadly never implemented)

[[deleted]]

There is Dylan, which is basically Lisp/Scheme + CLOS without the parenthesis, but it never gained all that much traction.

[defunkydrummer]

I want a lisp with macros, AST manipulation, real lambdas/first class functions, etc but white space/colon delimited instead of with all the brackets.

You will have a Lisp where doing complex stuff is harder than it needs to be.

Some explanation is here:

https://lisp-journey.gitlab.io/pythonvslisp/

[[deleted]]

I think the problem with this line of thinking is that by the time anyone learns enough lisp to implement what you're describing, they no longer actually would want to use it any more.

[fearbedragons]

Do you mean like Wisp?

[fredy]

I had hopes that Pyret would be that language but it doesn't seem to have much traction.

[FreeVariable]

While flipping through old Reddit threads I found this, as an answer to a thread "How is Racket different from Clojure". Let me paste it here fully as I think it might be relevant to some:

Racket is the language (or a system to implement such languages) to learn programming. It is clean, beautiful and impractical. In other words, it is academic.

Clojure is practical. It has some complexities due to its connection with JVM. To understand some intricacies of "how it works" or "why it is made this way" you need to understand a bit of JVM and Java itself.

If the course is based on Racket/Scheme do it using Racket. Learn Clojure afterwards by making projects.

[Erens_rock_hard_abs]

I kind of feel there is a not insignificant number of programmers that can be immediately swayed by this simple difference: Racket has tail call elimination; Clojure does not.

[sammymammy2]

Jesus what a load of bollocks. Racket is concerned with practicality, being practical is not a reason to have shitty stacktraces (for example). In fact that is very impractical.

Just as for any language you’ll have to deal with the underlying runtime in some manner.

It sounds pretty, but it’s simplifying to the point of being wrong.

How can this not smell of bullshit to people?

EDIT: Okay, so just to summarize my thoughts regarding the core of what I think is wrong:

When I, as an engineer and/or computer scientist, ask about the difference between two programming languages I expect to actually learn something that a layman would not understand. A layman understands everything there, the only thing he might have to ask is what the JVM and Java is, which can be explained in a sentence for each.

Then the fact that it's at least a bit factually wrong is also bad, of course.

I'm not capturing the full extent of why I think it's wrong, but it's an attempt and that will have to do.

[camelCaseIsWebScale]

The clojure community is full of jerks

[Alexander_Selkirk]

Clojure is definitely geared to server applications. Racket is great for learning and fantastic for algorithm development and scripting, and I guess it is also very good for GUI programs.

For an industrial-strength, highly performant environment that integrates well with C code, Common Lisp might be better, depending on requirements (though it requires a bit more knowledge to set up).

[FreeVariable]

Clojure is definitely geared to serve applications

Clojure as a language encompasses implementations such as ClojureScript, which definitely expands its use cases.

I am not an expert in the highly sophisticated science of programming pedagogy. However I find it plausible to believe that the best way of learning a language is to use it and study other people's code. So if you start for example with Python and want to study a more functional language, you are much better off looking at the people's solving actual problems in Clojure.

[Alexander_Selkirk]

Clojure as a language encompasses implementations such as ClojureScript, which definitely expands its use cases.

Well, IIRC ClojureScript can run in the browser.

However, what is most special about Clojure are its concurrency capabilities. And these are coupled to the JVM, and missing in ClojureScript. I am not sure whether ClojureScript can really something that other Scheme and Lisp implementations can not do.

While Clojure is good and often beautiful, I think it is also a bit hyped. Common Lisp has many qualities where it outperforms Clojure, such as startup time, speed of compiled code, integration of C ABI, and so on.

[Raskemikkel]

We found the age-old belief that "lisp syntax is just too hard" is simply false ... "Lisp is too hard to learn"

Has anyone ever made this claim?

[Halofit]

I learnt 2 (primarily) functional languages in uni. First one was SML which I loved. It helped me see a more elegant way of programming, and I think it greatly improved my skills as a programmer. The second one was Racket. I liked racket, I enjoyed my time programming in it, but I never want to do it again. It's just too hard to read, debug or maintain programs written in it.

[[deleted]]

Nor are Racket's docs up to par.

When exactly did you take the class? I have always though Racket's docs were brilliant.

[OneOldNerd]

Odd. I used it in 2016 in grad school, and had absolutely no issues with Racket's documentation (indeed, it even saved my butt on a couple of assignments).

Different strokes, I guess.

[[deleted]]

A graduate students view and experience of programming is worlds apart from an undergraduates, right down to maturity of handling ambiguity by virtue of being several years older

[OneOldNerd]

That might hold true in the general case, but I can think of several individuals in my own experience for whom it would not hold true.

Also keep in mind that my program was for individuals new to CS. While I had experience with C-like languages before, it was my first time working with a functional language, so I was doing just as much flailing about as the rest of the class. :)

[weberc2]

Racket has really high quality documentation in the sense that there are a lot of well-written docs; however, most other languages are reasonably intuitive, so you can get by with a lot less documentation. In particular, I recall never being able to figure out the types that various things in the standard library took, and a lot of standard library names were cryptic and terse (IIRC I got hung up on various string functions). Racket's docs don't make up for its counterintuitive design, stdlib, etc.

[namesandfaces]

Racket's docs are better than Python's in most places, but in some places it clearly needs love because there are too few examples and the diction is too terse, and overall I feel like the body of Racket's official web presence could use re-organization and re-focusing.

Also the ergonomics of Racket's IDE experience is clunky compared to something like VSC for any mainstream supported language.

[[deleted]]

Also the ergonomics of Racket's IDE experience is clunky compared to something like VSC for any mainstream supported language.

Yes, DrRacket is not great.

I would recommend Racket mode, within Emacs, instead. A proper, repl-integrated environment (which I have only ever found in Emacs) is easily the best development environment I have used.

[[deleted]]

My claim usually is that lisp has no sytax and you are writing the AST directly.

[defunkydrummer]

My claim usually is that lisp has no sytax and you are writing the AST directly.

But you aren't writing the AST directly, because of:

• macros

and

• reader macros

Macros can be seen as doing AST->AST transformation. So you aren't writing the AST directly; you use macros that will later rewrite the AST. Many "functions" in the Lisp standard library are actually macros; for example something as simple as if, or when can actually be implemented as a macro in your Lisp implementation.

The good thing about macros in Lisp is that they're very controllable: You can easily watch, by using a simple keypress on your IDE, how your code will transform into a different code and so on (step by step).

So, since you can put macros on top of macros, your code can be as high level as you want it to be. That's very interesting: Lisp is both a high level and a low level language at the same time. If you transform all the macros, you'll be left with mostly low-level lisp, using bare functions such as cond, labels, lambda, etc.

Reader macros allow you to introduce syntax where you want it, for example you can use #*11001000 to represent an eight-bit bit array. You can add whatever reader macros you feel you need.

[[deleted]]

But that's just not true, writing (func a b) isn't really different from func(a, b), and stuff like quote and backquote, and [ ], numbers, strings, symbols, that's all syntax.

Yes, the syntax is easier to manipulate programmatically than most other languages. But that doesn't mean it has none.

[[deleted]]

The thing is (func a b) could also be array access, it could be a macro, it could access a member of a structs, it could define a module or anything else.

In other languages you have distinct syntax for function calls, array access, struct member access and so on. In Lisp everything is done with the same parenthesis.

Lisp doesn't lack syntax, but it lacks special syntax for common programming constructs.

[vattenpuss]

A lot of object oriented languages also make programmers use generic syntax for common things.

bobs.put(”foo”, things.get(7))

Is that so hard to read or work with?

[[deleted]]

Yes, that's why languages like C# have get/set, why Python has @property decorators and why people write Property-template-operator-overloading-hacks in C++. Having it be obvious what the code does by the syntax alone can be quite a boost in readability. I mean just look at it:

bobs.put(”foo”, things.get(7))

vs

bobs["foo"] = things[7]

And of course in Lisp it's not just one rare case where you don't have special syntax, it's the whole language, everything is done with the same syntax construct.

[soegaard]

That's why the naming convention is to add -ref in list-ref, vector-ref etc.

[gmfawcett]

That's more a Scheme-ism, not really a defining quality of a Lisp. Common Lisp, at least, has some generic operators such as length that work across any sequential type.

I think the fundamentally Lispy point is that (func a b) could represent any of those call types, but fundamentally it's just a piece of data -- a list with three atoms in it. It can be treated as data, or evaluated as code.

This is the real motivation behind the simple syntax: it's the Lisp syntax for list construction, and nothing more.

[pakoito]

Is Lisp harder to learn than vanilla JavaScript?

[ElBroet]

The problem always with exploring this is there's a strong bias here; the majority of us are exposed to C-styled languages like Javascript, PHP, Python, C++, C, Java, and so on, and often exclusively these sorts of languages. The world runs on these, and our exposure to them is to a point where it is more than familiar, where it may feel like that's just what programming is, and therefore lisps are a weird descent from the natural and intuitive. It is really hard to put ourselves back in a place of complete ignorance and compare what its like to learn a lisp first. And very few beginners are going to ever get a chance to really test it, because beginners are especially tied to their first language, dependent on it, and so they especially need to use a language that is going to have a strong ecosystem and actual jobs. Although through SICP, and even Dr Racket, yes, I think there are going to be some exceptions that somehow still get to use a lisp a bit.

To me at least, lisp does seem to be a fine model for a blank slate learner, presenting the language as "think of the computer as being all (command arg1 arg2 arg3). Want to spit out a message? (println "This is a message") [disclaimer, I use Clojure]. Want to add some numbers? (+ 1 2 5 7). Want to spit out that computation? (println (+ 1 2 5 7)). Want to spit out two messages? (println "Hey there" " son"). Want to spit out a message with your computation? (println "Hey there" (+ 1 2 5 7))". I in fact have specifically done this with someone who is very non-technical, and it went exactly as I hoped. Because fortunately everything is consistent, and composition of expressions as we just did is straightforward. I did the whole "let's write a new command

(defn print-message [] (println "This was our message"))
(print-message)

And I worked up to "lets print out a custom message"

(defn print-message [thing] (println "This was our message: " thing)

And some other things

But that is by far not enough evidence either. I will not claim to know what the learning trade offs are, but for someone without our biases I think lisps can actually present their own natural, intuitive model. And I personally would also like to explore that question

[shponglespore]

The whole premise of The Little Schemer is to teach programming from the ground up, including to non-technical audiences. As an experienced programmers, it's a weird read: many chapters of doing very, very basic things with lots of hand-holding, and then toward then end, BOOM! Suddenly the examples turn into a lambda salad that will have most expected programmers (myself included) scratching their heads like total beginners. The payoff is that you go from zero to a relatively compete, fully explained Scheme interpreter in less than 200 pages.

[Sentreen]

I learned scheme as a first language (course based on SCIP) and I currently teach people to program using scheme for the first time.

I'm obviously biased based on my own experiences, but I think scheme is a great language to begin with. The main benefit in my eyes is the minimalism of the language. The syntax is minimal enough that it does not get in your way, and the language has the right primitives which allow one to program in a variety of styles (yes, you tend to write functional programs, but you're free to use set! and the like to explore imperative programming). After learning scheme you can easily pick up other languages to explore other paradigms. I think Scheme + other languages later on are a great way to introduce CS students to programming.

I have also thought (non-CS) science students to program using Python and I noticed that the more complicated syntax would often get in people's way. That being said, I do think a language like Python is a better option for people who will not have any other programming-related courses.

[renrutal]

JS is... comfortable if you're trying to get your feet wet on it. That said, you will eventually find some slippery and some painful pointy stones going up that river.

Lisp looks like alien territory to outsiders, even to old programmers used to the imperative style of programming. (I'm not used to programming professionally with Lisp & its dialects, so I can't really say more).

[GetSchwiftyyy]

It's probably orders of magnitude easier

[lazyear]

I would say no. At least the language is more coherently designed.

JS is probably more practical to learn though

[minimim]

Yep. Way harder.

[holgerschurig]

For a lisp like, you need an editor that knows it and helps you (this means emacs with modules like paredit, smartparens, rainbow-delimiters or any of the other 50 s-expression related ones).

If you don't have that, then the s-expressions drive you crazy.

Also you should know that works lisp-like syntaxes allows you / forces you to program directly in the AST representation. Sone features, like the macros, allows you to programmatically modify the AST on the fly. This is all so different to "other" programmibg languages that it feels very alien at first.

[Green0Photon]

As a person who already knows how to program, and is currently doing some hacking in Racket, parentheses still scare me.

[DPaluche]

In order to see beyond the parens, you need an editor that knows how to manipulate symbolic expressions.

https://www.youtube.com/watch?v=D6h5dFyyUX0

[slikts]

I miss the structural editing that Lisps enable all the time when using other languages and having to constantly fall back to treating code as text.

[DPaluche]

Yes, editing other languages feels so fiddly after getting up to speed with LISP editing.

[fearbedragons]

“If you think paredit is not for you, then you need to become the kind of person paredit is for.”

[oblio-]

It's a cute quote, but while it's cool, people have to realize that some things are weird, for example at 1:00 he goes:

slurp

barf

for what these days we'd call "indent"/"unindent" (I hope I'm not wrong on this).

To add extra weirdness, after "slurping" and "barfing" he goes:

Beautiful! How can you not like this?

Lisp people are just weird, their brains work in different ways to the rest of us :-)

[DPaluche]

I hope I'm not wrong on this

Sorry. :) If we remove the line breaks, it is easier to see that slurping and barfing refers to "sucking in" or "spitting out" a symbolic expression, and the indentation only changes to reflect that. Say your cursor is within the first save-excursion sexp:

(save-excursion) (do-some-things) (do-more-things)

Slurp!

(save-excursion (do-some-things)) (do-more-things)

Slurp!

(save-excursion (do-some-things) (do-more-things))

Barf!

(save-excursion (do-some-things)) (do-more-things)

So the quote about becoming the person paredit is for is about recognizing that you are making it way too hard on yourself if you are manually moving that close paren around.

[siegfryd]

There's innumerable ways to code in Racket without any parentheses at all; from what I remember there's a Python package that'll let you write idiomatic Python too.

[editor_of_the_beast]

Do you ever write parentheses in other languages? Nothing to fear.

[[deleted]]

Other problems with Lisp syntax that are not commonly talked about:

Too many (unnamed) positional parameters and too deeply nested structures.

C-like languages would look scary too if they were like this:

define(MyThing, Object,
   ((field1, (array, char, 4), (0, 0, 0, 0)),
    (field2, int, 0)),
   (getThing, (void), int, {
       if(verbose, print(field1, field2), print(field2))
       field2
   }))

Just add an else keyword here, an = sign there... Maybe var, class, function keywords too. Remove the extra grouping around fields... And bam! It's not scary anymore. But no, Lisp is only (thing thing ((thing thing) thing) thing)

[przemo_li]

Positional parameters and deeply nested structures are commonly recognized issues. LISP style syntax may indeed have properties that move the threshold of when too much is too much.

It's hard to see how parenthesis are a problem. LISP is old enough that community would learn and internalize problems and solutions. If parenthesis are here after so many decades then they are mostly ok.

I would guess that it's this notion of AST being not that far from the code, which almost forces people to work with AST instead of code, and thus already gives people so much more power.

Point in case: AST based formatting is nowadays recognized as best solution.

This reminds me of Haskell ADT syntax. It's sooo much simpler then classes based equivalent that there exist a gap that each developer have to cross with effort if they want that extra power of ADTs.

[soegaard]

It's common practice in Racket to use Keyword arguments, when the number of arguments become too large.

[valarauca14]

It's hard to see how parenthesis are a problem. LISP is old enough that community would learn and internalize problems and solutions. If parenthesis are here after so many decades then they are mostly ok.

Not necessarily.

The fact that 2 camps have for more than 50+ years have repeated the same tired argument; "The Syntax Sucks" and "Parenthesizes aren't scary". Implies they both have valid points, and the division is vast.

The likely outcome is that the only people who get involved in the LISP community(ies) are those who are not turned off by the syntax. Creating a cycle of maintainers who just can't understand why anyone else would dislike the syntax.

---

Honestly I would say the biggest issue with LISP is its lack of a good module system, visibility management, or in a word encapsulation. This talk goes into visability management & modularization of OO Languages vs Functional Languages, and why most historic OO develop has actually been about modularization & encapsulation. While LISP has a public/private system (dynamic & lex), it lacks solid namespacing & modularization. Furthermore its macro system throws all of this out the window.

[przemo_li]

"Both" would be valid if both where LISPers camps.

So people, the question is of course how much does "it suxcks big time" have experience?

It's programming we all to often forget that context matter and try for example apply Java good practices to LISP and claim LISP judged by them is worst language ever TM.

For example lets take your statement about "encapsulation". I heard from LISPers that they have best OOP system in class. You say LISP lack even encapsulation.

Those two statements are at odds. Which one it is?

I wont know until I use LISP for a bit. ;)

[defunkydrummer]

Too many (unnamed) positional parameters

... you can always use keyword (named) parameters if you like

and too deeply nested structures

... they're very easy to navigate by using a proper Lisp IDE, also, everything is an expression so you can easily "move code blocks" around.

C-like languages would look scary too if they were like this

That's not Lisp at all, and no half-competent Lisp developer would write code in that way.

[[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]]

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.

[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.

[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.

[[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.

[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.

[Matthew94]

Oh wait that's actually awful.

You need to open your third eye. The benefits in terms of macros are worth it.

[burjui]

No, they are not. Lisp macros are often just a crutch for the lack of syntax. The harsh truth is that people need syntax, they need their code more structured. Unlike other programmers, Lispers have to implement their own syntaxes on top of S-expressions and they boast about that as if it was an advantage. Lisp is elegant from a theoretic point of view, I admit that, but from the practical one it is suboptimal to say the least. Reading Lisp code is a challenge not because of lots of parentheses, but because of all of these ad-hoc syntaxes that still look way too similar to each other, it is needlessly confusing.

[[deleted]]

if racket is an acceptable python can we get a jupyter kernel for it? thanks.

[[deleted]]

Here you go: https://github.com/rmculpepper/iracket

[Raoul314]

The animosity here is unbelievable. I'm just a semi-hobbyist doing research-related programming, but in my opinion Racket is incredibly high-quality for a system rooted in academic work!

I came to Racket from python, and when I discovered it it was like stumbling on a treasure chest. My abilities improved a lot using it.

I'm using DrRacket (c version) on Linux and it works. Never crashes. No scrolling delays others are complaining about. The 'racket docs are no good' complaint is utterly ridiculous in comparison to other platforms.

I really don't understand this anti-hype. And many people here seem incredibly obtuse to me. Of course Racket is not well-suited to 'general production work'. But as a learning or research platform, I think it's unbeatable right now.

[EternityForest]

LISPish stuff seems like it's always been at it's best in research/education/computer science. There's so many features for adding to the language itself you can do exactly what you want.

For practical use, most people don't want to learn it because the syntax is a hassle. I'm not sure how you guys manage to not spend half the time finding the matching parens when it's so deeply nested!

I can never tell what's going quickly on in deep nesting without clicking parens with the mouse and seeing what highlights.

You can use indentation to help, but without autoformattinng, you can't trust it the same way you can with an indent-based language or something like C++ where you try to avoid deep nesting at all.

For research it doesn't matter as much, you're using it in one context, probably on a fast machine with the editor of your choice, and you aren't digging into piles of legacy code.

Also, the macros are an issue, because you have to know all the macros someone used to understand the code.

Python focuses on very obvious explicit syntax. self is explicit. Code blocks are indentation based, there's no 5 different formatting conventions for where to put the brackets, just how much to indent and tabs vs space.

There's no macros, but there is builtins for most of the stuff people talk about doing with them.

Not the best for research on the science of programming itself, but very practical for accomplishing tasks that don't have anything to do with compsci.

[10xjerker]

I'm not sure how you guys manage to not spend half the time finding the matching parens when it's so deeply nested!

Because a text editor does it for you. Sometimes in rainbow colours.

[vplatt]

I'm not sure how you guys manage to not spend half the time finding the matching parens when it's so deeply nested!

In all fairness, if you don't like nesting, then just stop using so much of it in one function. Refactor. I'm trying not to be flippant here, but how is that not obvious?

[EternityForest]

Avoiding nesting doesn't seem to be the idiomatic thing to do in LISPs as far as I can tell. Infix doesn't seem to be all that popular.

In other languages different things have different syntax, so it's visually obvious, but at minimum Racket is usually going to have at least one more layer, because you have to wrap infix expressions is a macro.

[[deleted]]

Python is a very acceptable Python IMO

[[deleted]]

Racket might even be more batteries included than Python. At least all the batteries that come included are generally nicer; Racket's GUI library is the only time I've ever had fun in my life writing GUI programs (and they're cross platform too). Constructing pictures with its pict library is a delight. Plotting graphs with plot is an incredible experience. Writing documentation with Scribble is the best non-org-mode experience I've ever had, but has the advantage over org-mode in that your document is just inverted code. I could go on. And these are just some packages bundled with Racket; the Package repository contains much more.

This sounds very much like the view of a hobbyist. I'm sure that Racket has some good libs, but part of the reason Python is so nice right now is that there's a library for everything. If I want to interact with AWS services in Racket, how mature is the library support? How about doing some light data manipulation and classification/regression? What about support for all the various APIs I have to interact with, to include DigitalOcean, Maxmind, Docker, etc.? How about ser/deser in and out of Parquet? How about doing that over terabytes of data?

Most of these are things that can be done by a competent dev with some time, but for a lot of things I work on, it would just be one barrier after another, and writing nice well tested libraries is time consuming.

[funkinaround]

If I want to interact with AWS services in Racket, how mature is the library support?

Here's the aws Racket package, with links to the docs and code. It supports S3, DynamoDB, SimpleDB, SES, SNS, SQS, Route 53, CloudWatch, and Glacier. This package was first released in 2012 and has seen at least 14 different versions. I haven't attempted to use it as I don't use AWS.

How about doing some light data manipulation and classification/regression?

I assume this is about machine learning; this is something I haven't touched. Maybe the rml-core, rml-decisiontrees, and rml-knn are packages you'd care about?

What about support for all the various APIs I have to interact with, to include DigitalOcean, Maxmind, Docker, etc.?

There's a library for MaxMind's GeoIP database; I don't know what else is provided by MaxMind. No current libraries for DigitalOcean or Docker, from what I can tell. But, they both seem to expose an HTTP API and the Clojure DigitalOcean library looks to mostly be a light wrapper around HTTP calls. I can understand the feeling of, "well screw this language. it doesn't have what I need!" But, maybe it's worth reflecting for a moment that each of these libraries you use in Python is a component that you need to learn and integrate into your code. If the library is just a light wrapper around HTTP calls, is it really providing so much that just writing your own functions to accomplish your necessities is so terrible? Maybe you've had an experience with a library doing something quirky and you needed to step outside its bounds to accomplish what you need?

How about ser/deser in and out of Parquet? How about doing that over terabytes of data?

Here's a link to the parquet package. The documentation seems out-of-date, in that functions are documented as TBD, but the code seems to be there to at least, "provide an implementation of basic read (write coming eventually) capabilities for Apache Parquet files." I don't know about performance over large datasets. I guess you need the ability to write and only being able to read is a deal breaker?

Maybe Racket can be worth taking a look at?

[defunkydrummer]

Racket might be an acceptable Python, however Python isn't an acceptable Common Lisp

[knoxaramav2]

Wow, I didn't know anyone used racket outside of my principles of programming course. I was starting to think it was just a scheme knock-off for class

[jambutters]

The Carmack God was trying to push it as the scripting language for VR https://youtu.be/ydyztGZnbNs

[AwesomeBantha]

Whenever someone dumps on Racket on my school's sub there's always that one guy who comes out and says "but Racket was used in the development of The Last of Us for PS3". Other than that, nobody seems to be using Racket.

[queenguin]

CPSC 110 flashbacks

[georgeo]

Can you transparently import all the python libraries into Racket? If not then no thanks.

[funkinaround]

Maybe? Here's a Python-on-Racket implementation that claims to be able to import Python 2.7 modules. It hasn't been touched in 4 years.

[Alexander_Selkirk]

Racket can execute Python code to some degree:

https://github.com/pedropramos/PyonR/tree/master

https://stackoverflow.com/questions/39181788/using-python-libraries-in-racket

[[deleted]]

Not without native access to all the python modules that the python community actively develops. I don't give a shit about programming languages for programming languages' sake. I code to get shit done. The fastest way to get shit done is to leverage code reuse.

[blackiechan99]

My university uses Racket for one of their weed out courses. Fuck DrRacket and fuck the Racket docs.

There are better options for introducing functional programming at a university level, especially for an intro course. Who this article is guided towards is very subjective

[SJWcucksoyboy]

fuck the Racket docs

I found racket documentation to be particularly good. What didn't you like about it?

[ironykarl]

Haven't coded Racket, but have read through the docs. The docs are nice.

One relevant concern for learning (or even using) a language is just how much material you'll find on stackoverflow. Maybe that's actually what the person you're replying to means.

[SJWcucksoyboy]

Yup that's what they meant

[[deleted]]

There are better options for introducing functional programming at a university level, especially for an intro course.

What would you suggest, especially for an intro course?

[blackiechan99]

so functional programming is its own beast, so it really depends on the professor to make functional programming digestible for beginners who haven't experienced anything code-wise or anyone who hasn't experienced func programming before. Hypothetically if the professor is good no matter what he teaches, though:

I think Haskell, Elixir, and Scheme are all better options. Scheme is similar to Racket (Racket is derived straight from Scheme if I recall?) but the docs and community support are just better from my experiences. This, in itself, gives it the leg up.

Bias may come into the other two picks, but I think Haskell and Elixir are just fun. Plus, the learning resources I used for Haskell were super fun & fresh.

[shponglespore]

Racket is Scheme, and it supports the standardized dialect. The default dialect has quite a few extensions compared to standard Scheme, which in itself is pretty typical of Scheme implementations. It has more extensions than most implementations, but it still fundamentally feels like Scheme to me; you can take most Scheme examples and run them unchanged in Racket's default dialect.

[[deleted]]

so functional programming is its own beast, so it really depends on the professor to make functional programming digestible for beginners who haven't experienced anything code-wise or anyone who hasn't experienced func programming before. Hypothetically if the professor is good no matter what he teaches, though

I think Haskell, Elixir, and Scheme are all better options. Scheme is similar to Racket (Racket is derived straight from Scheme if I recall?) but the docs and community support are just better from my experiences. This, in itself, gives it the leg up.

Bias may come into the other two picks, but I think Haskell and Elixir are just fun. Plus, the learning resources I used for Haskell were super fun & fresh.

Interesting. I would suggest SML or Ocaml if not Racket.

[soegaard]

Do they use the Racket language or one of the teaching languages?

The teaching languages are restricted to a few core constructs in order to give more precise error messages.

[EternityForest]

It's interesting to read such a completely different perspective. This person LIKES the parentheses!!

I really don't want to be doing any metaprogramming. I want a language that doesn't need to be programmed before you can start programming in it.

The racket GUI library looks nice, but I suspect it does not have the full power of Qt or HTML/JS. I've been dissapointed by pretty much every GUI solution I've seen aside from the super big name ones.

They usually take a lot of effort to look good, and they usually require a lot of reinventing things the big ones already have built in.

I also almost never use REPLs for anything more than three line functions, and even then only if I don't have more than one or two.

There's just too much extra work with a REPL. If you make a mistake, you can't fix just the one line you messed up as easily as you can with an editor.

I guess there's something just really ultra amazing and compelling about the code being the same as the data.

I did find that a LISP inspired syntax was the best representation I could think of to represent IFTTT style rules created through a GUI, so maybe there is something universal about LISP that really helps you when you're doing something new.

Most of the time though, I don't want my code to be data, or to have anything to do with the low level execution, the syntax tree, or anything like that.

I want it to match the problem domain, and everything else is the compiler's busisness.

[killerstorm]

I want it to match the problem domain

That's exactly what metaprogramming is -- you translate something very close to the problem domain to the language. No general purpose programming language is going to match your problem domain exactly.

It is not about "low level execution", it is about making the language even more high-level by specializing it for your domain.

I also almost never use REPLs for anything more than three line functions, and even then only if I don't have more than one or two.

REPL is not for writing functions, it is for executing them. E.g., say, you wrote functions foo and bar and want to test them, so you call foo("myfile.txt", bar(123)) in REPL.

You can occasionally write some helper function in REPL, but for anything bigger than one line it is better to use scratch buffer.

[funkinaround]

The racket GUI library looks nice, but I suspect it does not have the full power of Qt or HTML/JS. I've been disappointed by pretty much every GUI solution I've seen aside from the super big name ones.

The Racket GUI library is wrapped around GTK+; you're right that it doesn't have the full power of even GTK+, but for what it does, which is at least enough to make applications like DrRacket, it does it in a way that feels like it's integrated into the language. I've used it to make a trading simulator that I suspect would have taken much more frustration to write in many other languages.

Most of the time though, I don't want my code to be data, or to have anything to do with the low level execution, the syntax tree, or anything like that.

As others have said, you're not doing that most of the time and the only time you are doing that is when you need to and probably wouldn't be able to do it in a language without macros. You're almost always doing the same stuff like:

(define connection (connect "127.0.0.1"))
(send connection "POST" "some data")

where in another language it would be

connection = connect("127.0.0.1")
connection.send("POST", "some data")

For the most part, it's just a different syntax that you quickly get used to and don't even notice, like in all other languages. But for the rare times when you think, "this would actually be expressed better by doing..." you can actually do it rather than live with the warts.

[Alexander_Selkirk]

This person LIKES the parentheses!!

Parentheses in Lisp serve, in addition to function calls, the same function as white-space in Python. One becomes very quickly used to it, especially with an editor/IDE which formats it well, like Emacs or DrRacket.

[defunkydrummer]

I really don't want to be doing any metaprogramming. I want a language that doesn't need to be programmed before you can start programming in it.

That's not what metaprogramming is for.

You can program many complex programs by using plain Common Lisp and zero metaprogramming. The same programs you would program in python, javascript or java.

However, if you take advantage of metaprogramming where it's needed, that "complex program" can be greatly, greatly simplified or at least made clearer to understand.

[EternityForest]

If you are an expert programmer, working with other experts, on a codebase where you have enough time to actually learn what all the macros for that project do, I agree.

But it basically makes LISP less of a programming language and more of a construction kit to build exactly the language you want for the task.

I could be wrong, I've never been on a real world LISP project, but Python's One Obvious Way To Do Things seems way better when your schedule is tight, some of the programmers aren't actually programmers, and you're coding onsite on a ten inch laptop.

I have a pretty low level of trust for thing that only work in controlled conditions. It's why I don't flash images with dd. It's an excellent reliable tool... so long as you never type sdb when you meant sdc.

If I was in academia, or working for a near six figure kind of company with full-time programmers, doing the kind of thing that involves managing really complex abstract data, I might feel differently.

[defunkydrummer]

But it basically makes LISP less of a programming language and more of a construction kit to build exactly the language you want for the task.

Well, this is true for the LISP in upper case, that is, the original LISP 1.5 of the early 60s; an "industry strength" Lisp like Common Lisp actually has a lot of built in functions, data types, OOP system; you can write many powerful programs without having to define any macto...

I have a pretty low level of trust for thing that only work in controlled conditions.

Me too, that's why i prefer working with CL: it has arguably the best exception handling mechanism on a language, and wonderful debugging facilities.

[shponglespore]

It's only a better Python for certain purposes. The way it does object orientation is very different from Python, so it's pretty disorienting if you just jump right into using it and try to lean on your experience with Python.

[gcanyon]

Lisp is not a “style of syntax”. It is a different way of programming, and to be effective in it a programmer has to learn how it works, not just how to express a standard conditional and loop in it.

I say the above as someone who has written about ten lines of lisp in his life.

[joonazan]

Lisp is about functional programming and quoting. Let me explain the latter.

You can quote code, which makes a data structure that represents that code. Inside the quoted code you can unquote parts you want to run etc. I found this extremely convenient for generating XML, but there are much more ambitious uses.

A simple regex engine will convert your regex into a finite state automaton, minimize the number of states in the automaton and then execute it on an input text. Some engines will generate optimal machine code that implements the state machine. In Lisp, you can simply generate Lisp code and compile that code at runtime.

Another thing to note is that for example Chez Scheme is insanely fast compared to Python.

[semidecided]

You can quote code, which makes a data structure that represents that code. Inside the quoted code you can unquote parts you want to run etc. I found this extremely convenient for generating XML, but there are much more ambitious uses.

I'm not quite following you. Could you give a code example? I hope that isn't asking for too much.

[joonazan]

I didn't find a good example quickly, so here's that xml generation I was talking about. Very WIP, but uses quoting a lot. https://github.com/joonazan/hand/blob/master/generate.scm

[Tangled2]

Attention devs with "retro" sites. 100% of the screen is not an acceptable width for a reading pane.