"But in the last 60 years, simply grabbing these dissenters by the lapels and fumigating them with the stinky garlic breath of parenthesized S-expressions has not been a winning strategy. If Lisp partisans want different results in the next 60 years, we need to try something new."
You can reasonably make the argument (and I do) that the reason why mainstream programming culture hasn't adopted parenthesized s-expressions is not because they're inherently less readable, but because of massive bandwagon effects + inertia of C-style syntax due to the proliferation of...C-style languages, which trains peoples' minds to prefer said syntax, even if their steady-state characteristics are worse than that of s-expressions.
Most evidence based research into PL seems very inadequate, and I'm not sure we'll ever have good experiments. How do you measure the language over its level of mastery? Certain novice somewhat being more productive or making less bugs on trivial programs in beginner contexts doesn't tell you much.
Also, the very clear PL improvements have mostly been universally adopted. Lexical scopes for example, if/else conditionals, procedures, runtime types, GCs, dependency managers, unit and integ tests, etc.
It's only the insignificant details which are often debated. And for those, I think it becomes much more a decision to be made by masters, like your favourite chef knife, you pick what best fits your style and maximises your own productivity while minimizing your own weaknesses.
> I may be a visible user and fan of Racket—and even a teacher at Racket School—but I don’t have any influence on the direction of Racket. I think the Racket community is now big enough, however, that pulling off this kind of major change in Racket requires a stronger procedural foundation. The absence of this foundation is, in this fan’s opinion, a greater risk to the success of Racket2 than any technical hurdle.
I fully agree with the bits about transparency, and would add to that...
The best outcome I can imagine from the recent would be if the leadership articulates unambiguously what I've been calling the "top-level requirements" that guide everything else in Racket. (I have a pretty good guess at the top-level requirements thus far, based on history. I'm also pretty sure that much of the user community still has mistaken ideas about that. Another reason for articulating these top-level requirements is that they might be changing now, as it seems a few things are changing.)
After the top-level requirements, as a guide and to also let people know where they stand, then it would be good to have a well-considered model for whatever input (and possibly decision-making) is wanted from the non-leadership.
Given the rapid increase in programmers across the globe, I'd bet on there being more LISP programmers now than at any other time in human history. So why the obsession with popularity?
Now, you could say you are a startup and need the advantage. Good, you can do it, but you might have to supply more code to fill the gaps and deployment might require some extra knowledge (ecosystem problems). Its a value judgement as developer productivity isn't the only part of your development. Still, you can have a heck of an advantage. Look no further than the founder of this board, but remember the second part of the story. The Lisp got rewritten because it wasn't a comfortable choice for the new owners.
Perceived popularity means comfort and ecosystem.
I'd go more specific than startups, to narrow in on those who are doing something unusual, such that they know they'll have to implement nontrivial stuff from scratch, no matter what language and off-the-shelf libraries/frameworks they use. That's one of the places that Racket can be a win.
Related to that, I've also been trying to get people to stop saying "batteries included", because that's misleading, and sends the wrong message about what the actual relative strengths are.
In practice, I suspect the initial startup adoption will largely be chance/serendipity, until there's at least one great startup success story, to interest and inspire confidence in other startup efforts. (I have one great success story, which was due to such serendipity, but it's a non-public system, and I've been milking that one way too long already in promoting Racket.)
HN can be a weird place. There's a lot of good discussion to be had. But the passive-aggressiveness and walking-on-eggshells behaviour required to not be greyed out into oblivion can be a bit much. It reminds me of visiting my childhood friends that had super strict parents - can't watch the simpsons, in bed at 7, etc etc. Always wondering what they might be upset by.
I might go back to lurking. I'm a bad 'cultural fit'!
In the case of your comment, the downvotes can be traced to your use of the unnecessarily negative word "obsession". You implied that people who want Lisp to be more popular are mentally unbalanced, even though this is a quite understandable thing to want. And you must admit that your reasoning is, at the very least, quite arguable, and warranted a greater tone of humility. Insults derived from dubious reasoning are a surefire recipe for downvotes. If you had concluded your post with "so it doesn't appear all that important to me for Lisp to be popular in an absolute sense" I think you would have been fine.
Again, I'm a bad cultural fit. Not apportioning blame, I'm sure many here see me as a rude provocateur for my cavalier use of the word 'obsess'. That's life.
But, if you've such a thick skin, why obsess over downvotes? They mean nothing except that your post annoyed someone enough for them to click a little button. If you're so convinced it's HN and not you that's the problem, why should it bother you?
Did you not say essentially the same? Worded differently, but a comment to the same effect. Why hassle that commenter over different wordings of the same concept?
I think that there's a difference between a concern with popularity, which this article demonstrates, and an obsession with popularity, which may afflict parts of the Lisp community (not LISP any more, at least in most dialects) but isn't clearly demonstrated here.
If quantitative popularity is important at all, then surely it is percentages and not absolute numbers that are most important (e.g., in 2016, Hillary Clinton got more votes in Texas than in Delaware—15 times more!—but that's not the relevant number).
Even if quantitative popularity isn't important, surely some basic level of popularity is to be desired by fans of the language; and it must continually be renewed, not taken for granted. Note that more than the popularity of the language as a practical tool is at stake here; the article specifically talks about the declining popularity of Lisp as a teaching language, and, whatever language you use later in your hacking career, it's a shame to embark on that career not having been exposed to the ideas of Lisp (although, to be fair, those ideas have disseminated so much into the mainstream that many of them can be at least as easily found outside of Lisp as inside it).
One reason could be altruism. If you believe your tool is superior to the tools that most others are using you may be highly motivated to convince those people to upgrade.
Another reason could be that higher popularity leads to more jobs.
There's also adoption of their CS education programs, like HtDP, when clear industry relevance is one of the factors for some.
I suppose that attracting students to the professors' own universities, at least undergrads, might also be a factor, though I haven't heard anything about that one.
The truth seems to be closer to having to endure the constant pain of rewrites and reimplementions, imperfect abstractions and systems, that slowly etch us towards some shitty golden medium, something everyone hates but everyone agrees is the best we could come up with so far. The next iteration of that is most likely not gonna come from something completely different, genius, but from something just slightly different, slightly better.
they've already got that ability.
it just results in languages which can't interoperate. and it takes them a lot of effort to get a garbage result.
i suppose that "[it] does not work out well" is a reasonable description of the current situation. maybe you're actually arguing _for_ racket!
This should be live-streamed, with online Q&A:
That said, if you're going to get rid of parens, look at Haskell. It is actually a very Lisp-y language, where the parens are mostly optional.
Compare this to Ruby, which, while not super popular, has gained a respectable following after a period of hype. Ruby can trick people into thinking that it's a nice, normal scripting language that you can show your parents. And you can treat Ruby as a normal scripting language. Only after a period does Ruby reveal its insane metaprogramming and dynamic features.
What I'm saying is Racket needs a little more stupidity in it. It needs to project an image of a good ol' language that you can have a beer with. That you can write a web app in. If that requires removing s-expressions, then fine. If that requires removing conceptual purity, then fine.
Racket certainly still has potential. There's quite a lot of DSLs in modern programming. Whether it's the adhoc configuration based DSLs of Docker and DevOps in general (I hate Docker's weird pseudolanguage so so much), or GraphQL in web servers, there's definitely places for Racket to shine. It just needs to get sullied by the messy, imperfect, stupidity that is industry.
What does it mean to make the language stupider?
Ruby is popular because of rails. I don't think the making racket stupider or more familiar will create an analogous scenario to ruby and rails.
Next, start building good interops. If you can figure out a way to get Racket to interop with JS, then boom, you suddenly have access to all of the JS ecosystem. Does this potentially create issues in your type system? Yeah, probably. Does the JS ecosystem kinda suck? Yeah, but people use it. Right now Racket doesn't have a great package ecosystem, so stealing packages from other languages is probably the next best thing.
Ruby is popular because DHH was having enough fun in Ruby to build a web framework and get shit done with it. Do you think DHH could have done that in Racket? I'm not so sure.
Making a language worse just means killing your darlings. Language designers tend to be very smart and into very interesting, very powerful, but very hard to understand features. Which can be great in small doses. But if your language's idiomatic style relies on said interesting, very powerful but hard to understand features, you're a little screwed when you try to teach people cough monads. Making a language worse means moving off these really amazing features and onto slightly worse, but easier to understand features.
I suspect the first impression of DrRacket has been scaring off real developers since the start (as it initially did to me, ~18 years ago).
DrRacket was designed for students with no programming experience at all (and then some nice pro features were added atop that).
Put DrRacket first thing in HtDP, but be very careful about first impressions elsewhere. (And this doesn't mean adding an additional explanatory paragraph, or an additional manual about all your IDE/editor options. Racket already has a massive wall of documentation manuals, with the useful stuff scattered all over. People tend to not read stuff on the Web under even the best of conditions.)
Yes, DrRacket is the developer-suggested editor, but VS Code, Atom, Emacs, Vim, and Sublime Text all have Racket integration . More options for tooling is Not A Problem. In addition, you didn't even point out any problems you had with DrRacket in particular.
Interoperability is completely irrelevant to any problems of the language being "too smart" - FFI is a near-universally-desired feature that is only not present because the devs haven't gotten around to it yet.
Racket does not rely on monads, conceptually or otherwise, to do anything critical. What "very powerful but hard to understand features" are you referring to?
I don't have any problems with Dr. Racket itself. It's a very useful, very powerful IDE. But from a marketing perspective Dr. Racket just looks and feels bad to developers. It's a special IDE that you need to boot up, which is reminiscent of Matlab or worse, an educational language like Scratch. In fact, most people I talk to about Racket consider it a language for kids to learn how to code. Dr. Racket certainly doesn't help with that. Especially when the tutorials for Racket ask for you to download Dr. Racket. So yes, Dr. Racket Is A Problem.
Interop may be a problem that developers haven't gotten around to solving. However, I have a distinct memory of sitting in Racket School, hearing someone ask about features that Racket needs to be mainstream ready, and having the creators of Racket shrug and say "we're already mainstream ready". Perhaps they were exaggerating. Perhaps I misheard. But that's the impression I got having gone to Racket School
I'm sorry that I didn't spell out the "very powerful but hard to understand features" part. I mistakenly figured it was pretty clear if you understand Racket's paradigms. The very powerful but hard to understand feature is macros. Macros in Racket are more than a little tricky to understand. You have to get a mental model of syntax objects and compile time vs run time (this is actually harder than it sounds, cause iirc there's like 3 or 4 separate passes). You need to understand how to develop domain specific languages that are well designed and well scoped. You need to understand how to override function application and when that needs to happen. And so on.
I'm not saying get rid of macros. That'd be absurd. But step back from language oriented program and foster a more traditional form of development, while pitching language oriented programming to library developers (like Rails has it's own DSL essentially).
Some to look at: Racket, Guile, Gambit, Chicken, Bigloo, Scheme48 (and Scsh).
vyzo previously contributed to Racket (then called PLT Scheme): http://planet.racket-lang.org/display.ss?owner=vyzo
(PLaneT is the nice earlier package system. The current one is "https://pkgs.racket-lang.org/", but I think vyzo had left by then, or at that time. I should mention: I wouldn't read much into the Open Tickets on that page not having action -- tickets were a feature someone added without some prominent package authors even knowing about it, at a time when authors were expecting to be emailed, so it could be sadly counterproductive. Even if you did eventually learn it existed and people were posting tickets, but didn't want to keep checking and using a Web site (this was before current GitHub conventions), nor wind up with the situation of bug reporters you couldn't contact for more info, you couldn't turn if off.)