10 ms·
Racket2 Possibilities
- dreamcompiler 7y agoThe best way to kill a good Lisp is to remove the parentheses. The people who complain about parens are still going to ignore your language even after you remove the parens, and then the Lispers will ignore you too. See Dylan. This debate is exasperating. It's like hearing people say "I'm not interested in that Ferrari because it has a manual transmission." The only response to which is a silent, cold stare.
- mark_l_watson 7y agoIt is a great shame that I can only give you one upvote, you have it exactly correct. Removing parents ruins Lisp languages. That said, I consider Haskell to be a Lisp language. But, Haskell was designed from the ground up, from ML, to be as it is.
- dreamcompiler 7y agoCompletely agree. Haskell is IMO the only paren-free Lisp that works. As you said, it was designed that way from scratch, not as an afterthought from s-expr syntax. I also think automatic currying and pervasive laziness contribute a great deal to making the parens unnecessary, and most Lisps don't work that way.
- Oreb 7y ago> Haskell is IMO the only paren-free Lisp that works. Out of curiosity: Do you think Julia is not a Lisp, or that Julia doesn’t work?
- dreamcompiler 7y agoI know Julia was originally a Lisp and it incorporates a lot of Lisp ideas, but I've never used it so I have no opinion about how well it works. Lots of Lispers consider Javascript a (primitive) Lisp because it has lexical closures, but I think its syntax is horrible and thus (IMO) it doesn't "work."
- nudpiedo 7y agoWhy is Haskell a lisp? It is the first time I hear someone classifying Haskell in the “List Processing” family of languages, and although it does process lists I thought its main paradigma symbol and code representation goes in a complete different direction, more into pure function oriented programming.
- dreamcompiler 7y agoWhen people say something "is a Lisp" that usually has little to do with list processing. It's about whether it inherits more from lambda calculus than from Turing machines.
- lispm 7y agoLisp literally stands for 'List Processor'. To claim that it has little to do with it, is really really strange. One of the main reasons to create Lisp was being able to compute with 'symbolic expressions', represented as linked cons cells in the form of lists... McCarthy about Lisp: === As a programming language, LISP is characterized by the following ideas: computing with symbolic expressions rather than numbers, representation of symbolic expressions and other information by list structure in the memory of a computer, representation of information in external media mostly by multi-level lists and sometimes by S-expressions, a small set of selector and constructor operations expressed as functions, composition of functions as a tool for forming more complex functions, the use of conditional expressions for getting branching into function definitions, the recursive use of conditional expressions as a sufficient tool for building computable functions, the use of lambda-expressions for naming functions, the representation of LISP programs as LISP data, the conditional expression interpretation of Boolean connectives, the LISP function eval that serves both as a formal definition of the language and as an interpreter, and garbage collection as a means of handling the erasure problem. LISP statements are also used as a command language when LISP is used in a time-sharing environment. === http://jmc.stanford.edu/articles/lisp/lisp.pdf http://jmc.stanford.edu/articles/lisp/lisp.pdf 'lambda calculus' wasn't even explicitly mentioned. But he mentions s-expressions, list structure, multi-level lists, ...
- 7y ago
- dorfsmay 7y agoIsn't homoiconicity one of the requirements for a lisp? If so, that makes Julia a lisp, but not Haskell.
- lispm 7y ago> That said, I consider Haskell to be a Lisp language. Then Lisp (aka 'List processor') has lost its meaning. Haskell is at its core a lazy evaluated, statically typed, purely functional programming language. Lisp is none of that. The core of Lisp: an eager evaluated, dynamically typed, programming language supporting imperative, procedural and non-pure functional programming. > But, Haskell was designed from the ground up, from ML, to be as it is. Haskell was designed to have a common lazy language, instead of a dozen languages under development or in use (Miranda, Lazy ML, Clean, ...).
- lidHanteyk 7y agoYou are missing quite a bit of context on the history of Haskell. From https://www.microsoft.com/en-us/research/publication/a-history-of-haskell-being-lazy-with-class/ https://www.microsoft.com/en-us/research/publication/a-histo... , it seems that Haskell's design did not arise out of Lisp, but out of several languages in the early 80s which were lazy/non-strict and purely functional. Indeed, removing parents ruins the perception of Lisp languages as just another language family, and promotes Lisp into some sort of privileged position. Simultaneously, mistaking Haskell for a Lisp means mistakenly thinking that Haskell has special meaning for pairs over tuples or lists, that Lisps are statically typed or that Haskell is optionally typed, that Haskell has macros, that Haskell's juxtaposition-based application syntax is related to Lisp's parenthesis-based application syntax, and so on. Consider example Lisp memes: "Data is code; code is data," or "all structures are lists." Compare with example ML memes: "If it compiles, it works," or "well-typed programs don't go wrong." Or even better, with Haskell memes: "Laziness leads to purity," "monads are programmable semicolons," "show me your types." The only meme common to these communities is "lambda the ultimate", and you are ignoring decades of Lisp philosophy if you nominate this meme to carry the flag for all of Lisp. When I first read this comment tree, I wondered if everybody had forgotten about the Land of Lisp and the Republic of Haskell: http://www.lisperati.com/landoflisp/panel01.html http://www.lisperati.com/landoflisp/panel01.html I consider Haskell to be an ML, and even then, it's worth remembering that lazy/non-strict MLs have different behavior from the rest of the family.
- sansnomme 7y agoApple was not a unicorn that could single handedly force changes among developers then. Julia has plenty of funding and is pretty much a syntactic clone of Dylan (cleaned up somewhat) and it's trending on HN every other day.
- User23 7y agoI hope there isn't an AI Winter 2.0 that strangles Julia as the first go around did Common Lisp.
- ddragon 7y agoJulia isn't that much positioned as an AI language, it's more of a numerical analysis and scientific computing language at this point competing with matlab, which is something that doesn't go through hype cycles. The fact that it's so well positioned for AI research is the result of that focus (high performance, expressive, interactive and math focused) plus being heavily inspired in Common Lisp, which means the language can be easily extended for new purposes (and CLOS was a brilliant system that didn't get the attention it deserved in the mainstream). Python is the AI language, and it's already more than large enough to survive many AI winters (plus "AI" is more powerful and useful every winter).
- pjmlp 7y agoPython is the AI glue language. And it remains to be seen for how long, given C++20, Julia, ML.NET, Swift for Tensorflow and other approaches using the same underlying native libs.
- rrdharan 7y agoThis is a weird analogy given that Ferrari no longer offers manual transmissions: https://www.bloomberg.com/news/articles/2016-06-17/why-can-t-you-get-your-300-000-supercar-with-a-stick-shift https://www.bloomberg.com/news/articles/2016-06-17/why-can-t... Or perhaps it’s entirely apt.
- dreamcompiler 7y agoI know. Likewise the German cars (at least in the US). And we are poorer for it.
- jjtheblunt 7y ago"See Dylan" : so well said!
- jplayer01 7y agoI don't understand the deal with parens. Or significant whitespace. Or other similar "issues". Surely people have bigger issues when writing applications than where you put your god damned brackets or if they're curved or braces or whatever else.
- jhbadger 7y agoParticularly when the "solution" to parens always seems to be significant whitespace, which is disliked by many as much as parens are by others. Both are just conventions that people get used to. I didn't care for significant whitespace when I first learned Python, but eventually I stopped seeing the problem, just as I stopped seeing the issue with parens in Lisps.
- breck 7y agoFor me the obsession is with simplicity and theory, perhaps as much as the pragmatic effects. Things become a little bit simpler (fewer pieces), with indentation syntax. I find that really beautiful. As far as I can tell it can’t get any simpler than that. https://github.com/breck7/jtree/blob/master/papers/paper3/countingComplexity.pdf https://github.com/breck7/jtree/blob/master/papers/paper3/co...
- jplayer01 7y agoSorry, I meant I don't get why people complain about them so much.
- pjmlp 7y agoDylan was a victim of political wars with the competing C++ group at Apple. The team even implemented Newton OS ahead of the C++ team just to prove a point, even knowing that they would be out anyway. Search for entries from wrs and mikelevins. https://news.ycombinator.com/item?id=15106802 https://news.ycombinator.com/item?id=15106802
- albanread 7y agoI also thought about Dylan when I heard of this racket direction; and took another look at it; Open Dylan has tremendous documentation (a very enjoyable read.) The compiler has been updated relatively recently to use LLVM; the command line programs run fine on Linux; I ran it on WSL2 and it seemed to work well there; it is a very nice and interesting language. I suspect luck, timing and fashion have a lot to do with language adoption; perhaps more than technical merit.
- pjmlp 7y agoThanks for the heads up, I thought that the effort to re-birth Dylan had died.
- schpaencoder 7y agoI agree, and Data and code is the same in a lisp.
- slaymaker1907 7y agoI was at Racketcon when Matthew first brought this up publicly. While it is a good way to kill a LISP, it is important to keep in mind that Racket is really an amazing workbench for creating new languages which interact with each other and being a LISP is mostly for the sake of making this easier. In addition to that goal, Racket was originally created as a teaching language and continues to be used as such. Some people in the community see the odd syntax of LISP as a barrier to entry and would like to see if it would be possible to use a more Algol-like syntax for ease of learning while also preserving the properties which make it easy to extend and define new languages in. Currently, there is already a distinction between parsing into s-exp and module-begin (i.e. all the interesting parts of your language) and this tech is already used to support languages which are based on s-exp and those which do fancier parsing such as the Datalog language. Personally, I would rather keep Racket with s-exp and focus on cleaning up the weird stuff that is a holdover from scheme such as not having a consistent interface for comparators like there is for equal?, adding in growable arrays as part of the standard library, and not insisting upon an enormous block of end parents all on the same line (this is largely a product of the API for extending DrRacket being somewhat obtuse for indentation).
- neilv 7y agoRegarding Racket being a teaching language, I'd like to make what I think is an important distinction... I don't consider Racket a teaching language. It was created (when it was called PLT Scheme) as a very practical and powerful implementation of Scheme, for at least 3 purposes: * implement multiple teaching languages (for incrementally introducing language complexity as a beginner learns); * implement an in-some-ways powerful IDE that would run on all desktop/laptop computers students might have access to; * be a programming languages research platform. I have an interest in education, but am not interested in using educational languages myself. I've always used Racket as a practical language, for industry production, university research, and personal techie learning/experimenting.
- darkpuma 7y ago> "From a community perspective, the rub is that the "many people" for Racket syntax is a barrier are mostly people outside the community. It's fair to ask who would benefit. It's difficult to ask a community to tackle a problem whose solution targets a different community." Yeah no shit, alienating the 1% of the general population who uses your tool to appease to the 99% who don't currently use it might work sometimes, but you could just as easily lose that 1% and pick up jack shit, because the grassroots advocates for your language just evaporated. Dropping s-expressions from the primary lang would likely prove to be the kick in the ass I need to switch to CL. (Other proposals listed sound a lot better. This syntax matter is my one serious grievance here.) Edit: > "From what I've seen there is no advantage that editors can give you with parens, that they can't do better without parens, given that you've written loads of tests and done the grunt work to make that happen." This seems like one of those cases where lack of editor diversity among a lisp community once again threatens to cause trouble for anybody who doesn't use emacs (see also: terrible default REPL experiences because the devs all use racket-mode or geiser-mode.) What am I meant to replace the % command with when using vim or evil-mode? I don't want to do "loads of gruntwork", nor do I wish to rely on editor extensions for a matter that should be so straight forward. I want to press % and jump to the matching paren.
- eggy 7y agoI am not a fervent Lisper, but dropping the parentheses will take me away from the times I do go to Racket, and just go back to SBCL or Gambit or Chicken Scheme. The article admits it is to try and win more share of users, but that is not a good reason for a predominantly academic language. I would even go to Haskell, which avoids success at all costs ;)
- seisvelas 7y agoIronically, I think most of Racket's popularity is driven by its Lispiness. People want to get into this 'Lisp' stuff and everyone recommends Racket. I personally learned Racket because as a dumb teen Googled "how to become a hacker". The first result was Eric Raymond's article How To Become A Hacker, which recommended learning Lisp. I looked into Lisps and ran into the book How to Design Programs which recommended the IDE DrRacket.
- dTal 7y agoThey're not dropping anything. You will still be able to use the parentheses. This is essentially a proposal for an official alternate syntax.
- jchw 7y agoFWIW, the angry negative responses to removing parenthesis from the community would be a much bigger obstacle to adoption than the parenthesis. Nothing is going to turn me away from a technology faster than a hostile community, especially for a programming language, where the ecosystem is both an important asset and an investment you make when you choose a language to write in. And I’m serious: I adopted Go early on for it’s ecosystem and community. Rust was harder in part due to its early negative reputation for overzealous fanatics, which thankfully no longer feels like an issue (and the ecosystem is getting there, too.)
- darkpuma 7y agoI'm not angry yet, I'm just concerned. If it actually happens, then I'll be angry.
- laughinghan 7y agoOther comments make it sound like dropping parentheses is just a craven attempt to make Racket more popular. To me, this epitomizes the distinction that the maintainer drew between trying to get more popular, and lowering barriers of entry. If Racket 2 is no more popular (it loses as many community members as it gains), but the new community members had an easier time joining the community yet still love Racket 2 just as much as the old community loved Racket 1, isn't that still a win? Conversely, if it turns out that everyone loved Racket 1 not because of the design elements that the maintainer put so much blood, sweat, and tears into, but because of the high barrier of entry due to the parentheses (the one thing that the maintainer didn't put effort into), how is that at all motivating to the maintainer? I'm less of a community member and more of an admirer of Racket from a distance (and I don't mind parentheses, really, I've used Clojure professionally and it was great), but I look forward to seeing how this initiative turns out.
- anaphor 7y agoFrom some of the comments it feels like this is also intended as a way to research different ways of doing Lisp surface syntax without sacrificing the features of the macro system. I'm not sure if it's possible to do both at the same time.
- laughinghan 7y agoDid you miss the "How?" section of the post? He wrote a research paper showing it was possible in 2012, "Honu: Syntactic Extension for Algebraic Notation through Enforestation".
- anaphor 7y agoYes I read the paper, but he also makes it clear that there's still lots of work to do (e.g. how to make it work better with macros)
- deleted 7y ago[deleted]
- brisance 7y agoSurprised that he proposed infix operators since that is kind of contradictory to his stated goal of improving consistency within the language.
- skybrian 7y agoRather than discussing "not lisp syntax" I suggest reading the Honu paper, which is pretty neat: https://pdfs.semanticscholar.org/812b/92f2fa587ff78d727c749528f5a6411ac0e2.pdf https://pdfs.semanticscholar.org/812b/92f2fa587ff78d727c7495...
- neilv 7y agoThis one worked better for me: https://www.cs.utah.edu/~rafkind/papers/honu-2012.pdf https://www.cs.utah.edu/~rafkind/papers/honu-2012.pdf
- satya71 7y agoCadence had a Lisp/Scheme with infix operators a long time ago. See https://community.cadence.com/cadence_blogs_8/b/cic/posts/skill-for-the-skilled-what-is-skill https://community.cadence.com/cadence_blogs_8/b/cic/posts/sk...
- skybrian 7y agoDid you mean to link to another page? I don't see anything about infix operators on that one.
- deleted 7y ago[deleted]
- breck 7y agoDisclaimer: I work on Tree Notation (http://treenotation.org/ http://treenotation.org/), (https://twitter.com/breckyunits/status/1153016840769007616 https://twitter.com/breckyunits/status/1153016840769007616). Prediction: In 10 years the most popular programming languages in the world will not use the current BNF or () style syntaxes but instead will use Tree Notation (with Racket like "Language Oriented Programming" on top), OR will use some other "black swan" syntax that I haven't seen, that is even better than Tree Notation... I think we're all going to learn that syntax does indeed matter, once machines are writing most of the code. I'm willing to give even odds for that bet, if there is some type of charity betting site that supports that sort of thing, if anyone disagrees. (Even if you don't disagree, it would be silly to not take that bet for even odds, given fewer than 500 people are actively using Tree Notation today).
- throwaway-d81 7y agoYou can try posting your bet here: http://longbets.org/ http://longbets.org/ Disclaimer: I only know of it because I was looking for something similar once.
- breck 7y agoOh, neat! I did not know longbets was an open platform. I'll post something on there. It will actually be a good exercise, because I should clarify things like "no, I'm not predicting this will be more popular than Excel", which I would agree is a programming language. Thanks!
- boulos 7y agoPlease do and link it here! (For posterity). Fwiw, unless you mean something much narrower than I interpreted your statement to mean, I’m taking the other side of your bet :).
- skybrian 7y agoI'm interested in this kind of thing and followed the links, but I didn't learn enough to decide whether I like your tree notation or not. It might help to write a tutorial just explaining informally what the notation is and what the rules are for using it?
- anaphor 7y agoI quite liked this proposal from a while ago: http://shriram.github.io/p4p/ http://shriram.github.io/p4p/ The idea is basically to remove implicit `(begin ...)` and then remove the trailing parentheses from many things. For example: ``` (define (f x y) (* x y)) ``` vs. ``` define (f x y) (* x y) ``` It works because now you can only have a single expression as the body. Similarly you get the same kind of thing with many other forms that have `begin`. It also proposes adding some new syntax for various things, replacing `begin` with `do` and a bunch of other stuff related to indentation. You can easily pick and choose which parts you like though and still get some benefit, which is what I like. And it is still homoiconic. If I wanted a quick and dirty way of making lisp "more readable", then this is what I'd do. I even created my own half-assed implementation[1] of this idea years ago (In JavaScript). Disclaimer, it's really messy and incomplete code from when I was just learning how to write parsers/lexers/etc. One other idea I implemented was the ability to mix infix and prefix expressions. I'm not sure if I still think it's a good idea, but it worked (it had to know whether a token could be interpreted as a binary operator ahead of time and it was a bit janky, but you could even add your own custom operators) [1] https://github.com/weskerfoot/JLambda/blob/7508af2c9dcc4db0214853036201211d8fbd09cb/server/fib.jl#L1-L8 https://github.com/weskerfoot/JLambda/blob/7508af2c9dcc4db02...
- didibus 7y agoIgnorant question: What's Racket's value proposition beyond being a well maintained Lisp? What's this Language of Language thing, and is it so awesome that I'd be tempted to learn Racket only for it? Since otherwise its syntax and semantics might be too similar to say Python? (Assuming it drops all the Lispy stuff)
- nudpiedo 7y agoI look a few times to racket in the past. It's distinctive features are: - Pedagogy first: easy to learn, cute visual tutorial with support for desktop UIs, nice tutorials on the language itself and how to learn several aspects of programming such as sockets etc. - Very Easy to write a programming language on top of it by creating a new lisp reader (#lang) which transforms the given code and makes the access to the rest of racket's ecosystem very easy. It is not industry-focused, therefore you might end up frustrated if your main/only goal is to write single web applications or you need good support for commercial libraries, databases etc. On the other hand in software everything is possible so you could always find your way to access those libraries and leverage the existing ecosyste,
- slaymaker1907 7y agoReact is a perfect example of a lot of Racket’s value proposition. JSX is a mini-language created as a way to write XML which interacts bidirectionally with JS in a seamless way. While it takes quite a bit of effort in JS to create all the tooling for this DSL including not only compilation but also making sure it stays editor friendly, creating something equivalent would take an afternoon in Racket including having sensible error messages and syntax highlighting. I chose JSX in particular since it really highlights how useful it can be to have seamless interop between languages. Another really interesting #lang for Racket is Rosette which is IMO the easiest to use interface for SMT solvers out there since the code you write is regular racket (it even supports recursion via symbolic execution).
- tgbugs 7y agoHaving followed this fairly closely, I will drop a though here while it is in my head. Surely there would be no obstacle to supporting s-expression syntax and allowing additional syntax around it. Everyone seems to see this as either-or, but is it really truly impossible to have a set of rules that say "you can't start a valid sexp with `(4` so this must be the start of an infix expression" and "you can start an sexp with `(add1` so I'll keep going"? Yes there will be a cost in the reader, but moving away from sexps is already going to be costly in that sense. Further, if we are going to incur the cost of a major complication of the parsing implementation, then why not go all out and allow interleaved expressions? What are the ambiguous cases that make this impossible?
- a_lieb 7y agoI've always wondered if a good way to do infix would be to simply have the ability to mark an item with a character that means "move this to the front of the expression." Let's say the char is ":". Then this: (1 :+ 2) Would be converted to this: (+ 1 2) It would also allow for arbitrary placement, so you can do goofy stuff like pretend to be Forth without writing custom macros for the situation: (1 2 3 4 5 :+) Whether or not that part is an advantage is another story ;) This doesn't solve the "too many parens" problem, because you still have parens, but it does solve the "prefix math looks weird" problem. It's quite a bit simpler than what Dylan does, in that there's no special concept of "binary operators" and it's obvious at a glance how everything converts to sexps.
- hyperion2010 7y agoRacket currently has something like this for certain operators. `. -> . ` will allow the arrow to sit in between inputs and outputs in contracts.
- darkpuma 7y ago> for certain operators AFAIK it works for any operator that takes two operands (or more, but it makes less sense to be using it with three or more operands.) e.g: > '(arg0 . operator . arg1 arg2) '(operator arg0 arg1 arg2)
- a_lieb 7y agoForgive me if the answer to this is already widely-known, but at this point is Racket making a play to be a general-purpose, "batteries included" Lisp, rather than a stripped down tool for PLT stuff and making languages? It seems like there's room in the market for something like that. A bit like Clojure, but without all of the big design commitments that Clojure makes, like the deep integration with Java and focus on immutability.
- darkpuma 7y agoI'm not sure, but that's how I've been using it. For me it replaced python for fun and casual programming.
- 59nadir 7y agoIt's already been positioned as a batteries included lisp and arguably has had the best standard library offering + documentation for it of any lisp out there. This move has nothing to do with that, but rather the possibility of having less (to some) off-putting syntax.
- fulafel 7y agoI think Clojure commits to being a hosted language with a pragmatic attitude to the underlying platform, rather than committing to Java. It keeps the JVM / JS / .Net layer accessible. Sorry for the nitpick but I think it's an important nuance. A Racket or SBCL hosted Clojure might be pretty cool.
- gus_massa 7y agoYou may like Rackjure "Provide a few Clojure-inspired ideas in Racket. Where Racket and Clojure conflict, prefer Racket." https://github.com/greghendershott/rackjure https://github.com/greghendershott/rackjure It runs inside racket and can interoperate with other racket modules, and is straightforward to add to a racket installation.
- namelosw 7y agoI'm not totally against Racket without parens, but to gain popularity this seems not to be the first action should be taken. Like IDE, tooling, libraries/ecosystem improvements. For example, the documentation is really great, but Drracket is only good, not great. Probably good VSCode integration would help a lot, since not everyone is using Emacs for serious work.
- galfarragem 7y agoInstead of moving to a new market, with more potential users - but also with fierce competition - it makes more sense to stay where they are and invest in "being so good that they can't ignore you" by investing in quality, and that means outstanding tooling and ecosystem. Recently somebody in HN also noticed the need for a "browser scheme" to take advantage of code and data being the same. That might be also an interesting path.
- User23 7y agoDijkstra's last published thoughts on the merits of infix notation for associative operators come to mind[1]: "It made me realize why I like it so much for associative operators: it allows us to write p+q+r without being forced to choose between (p+q)+r and p+(q+r); in prefix notation, the choice between ++pqr and +p+qr would have been unavoidable." This show the obvious merit of parenthesis for prefix notation, since then one can write (+ p q r). In essence, the + operator distributes over the operands. [1] https://www.cs.utexas.edu/users/EWD/transcriptions/EWD13xx/EWD1300.html https://www.cs.utexas.edu/users/EWD/transcriptions/EWD13xx/E...
- agumonkey 7y agoI trust M. Flatt to know what he's talking about but really the 'potential users 'argument has always been weak to my eyes (both in breadth and depth). prefix nested parens are ultra generic, I bet those who don't like that won't like the genericity of the paradigm and idioms either, no matter how mainstream the syntax
- badtuple 7y agoSerious question: Why do parens matter so much? I read the post and all the comments here, where people are very adamant about their opinions on parens. It seems to me that while syntax is important, parens in this context is about as close to "just syntax" as we can get. Racket-sans-parens would still be Racket. Am I missing something fundamental?
- breck 7y agoThe semantics are much, much, more important for sure. I think the “language oriented programming” semantics of Racket are brilliant. I’ve been working on this syntax question for 7 years, now full time at the Tree Notation Lab. I think there is a better way to do the syntax, which over time will have strong network effects, which will allow us to code faster and have more reliable code. But you are right, perhaps this will just lead to a 20% across the board improvement in programmer productivity—-the bigger improvements will always come in the semantic realm. I think the thing to keep in mind is that only a tiny amount of people are focused on the syntax issues, they just like to shout at each other.
- darkpuma 7y agoFrom a practical standpoint, basing everything off balanced parens (or square brackets, that makes no difference to me) makes the language much easier to write in. Being able to jump to the matching paren makes it trivial to copy/paste blocks of code, delete code, replace code, etc. It's so much easier than with things like Python. For instance, from the first line of a block of racket, copying that block in vim (not an editor known for being well suited for lisp) is as simple as %y. How do you do that in Python? If you know you're after 5 lines you could do 5Y, but that requires you to count how many lines you're after. You could use visual selection mode with V and then highlight the relevant lines, but that is more keystrokes than %y. You can get extensions for vim that create concise movements for dealing with indented blocks of python code, but with lisp no such extension is necessary. Even in vi-compat mode or things like Busybox's vi implementation that has no extension support, % works. What's it like for C? A little bit better than python, but worse than lisp. Consider this block of code: if (foo) { ... } How can I yank that entire thing, if my cursor is on the first character of the first line? The obvious answer to me is v$%y, which is pretty convenient, it doesn't require counting, but it's also fragile. What if that opening squiggly brace was on a new line? Then I'd have to do something like vj%y As far as I'm concerned, despite vim being considered a second rate editor at best for lisp, lisp is arguably still the language vim is best suited for, and that's entirely a consequence of the fundamental usefulness of s-expressions.
- kamaal 7y agoThis just now settles that anyone wanting to use Lisp to do anything practical has only one option: Clojure. It's a shame, because Racket had the promise to be something really useful. Also throwing your dedicated 1% users under the bus, to attract 99% users who won't use your tool no matter what, is bad idea from a product management perspective. I honestly feel f# has won the ML family language wars, and you won't be able to do much there. Even if you have decent ideas, you still have to solve the library problem. And yeah, given how scanty your user base is going to be, not many are going to write books either. The fact that they even consider this idea seems shocking to me, let alone announce such a thing on a mailing list.
- dTal 7y agoCalm down. They're not throwing anyone under the bus. The post starts with "No matter how Racket evolves, the community is committed to preserving what we have achieved: today's `#lang racket` programs will run in the future, and today's `#lang racket` modules can be used in future Racket programs". Also, basically the point of Racket is solving "the library problem". Every fancy new language you make in Racket has access to every library ever made with Racket.
- kamaal 7y ago>>"No matter how Racket evolves, the community is committed to preserving what we have achieved: today's `#lang racket` programs will run in the future So to put it clearly, the current programs would run, but no new features, fixes and enhancements. Basically you can't use it for anything production. >>Every fancy new language you make in Racket has access to every library ever made with Racket. Libraries, means more number of libraries for the same language. Not same number of libraries for more languages.
- dTal 7y agoIn Racket, it's the same thing. Racket #langs are interoperable. Which is why it's untrue to say "no new features, fixes and enhancements". Any improvements to the semantics of the language will be usable from both #lang racket and #lang racket2; any libraries written in #lang racket2 will be usable in #lang racket. This is merely a proposal for an official alternate syntax, which you are entirely free to ignore. It doesn't take anything away from Racket to have this. Bear in mind that Racket already comes with a plethora of officially supported #langs, many of them with highly non-lispy syntax. The ability to do this is a major part of Racket's unique value proposition in the first place.
- tosh 7y agoI think there are lessons to be learned from Python, Perl and Osborne [0]. New and arguably better things aren't created in a vacuum. They are perceived and judged in their context. Irritating users of A with A' can handicap the env of A as well as the env of A'. I think this is often not thought about well enough. [0] https://en.wikipedia.org/wiki/Osborne_effect https://en.wikipedia.org/wiki/Osborne_effect
- tosh 7y agorelated: https://en.wikipedia.org/wiki/Path_dependence https://en.wikipedia.org/wiki/Path_dependence The evolution of projects and their environments is a difficult endeavor.
- tosh 7y agoRacketCon 2019 talk "State of Racket" by Matthew Flatt https://www.youtube.com/watch?v=dnz6y5U0tFs&t=390 https://www.youtube.com/watch?v=dnz6y5U0tFs&t=390