1. 16

    Rewrite the whole Unix tool space to emit and accept ND-JSON instead of idiosyncratic formats.

    1. 5

      I’m a HUGE fan of libucl. It supports several constructs, including JSON.

      1. 3

        I was thinking YAML in that it’s still human readable at the console but also obviously processable, and JSON is a subset.

        1. 7

          YAML is a terrible format that should literally never be used. :-) There’s always a better choice than YAML.

          1. 3

            Strict yaml, without the stupid gotchas

            1. 2

              I don’t think yaml is the best choice for this. Most of the time user’s will want to see tables rather than a nested format like yaml. I guess it is a bit nicer to debug than JSON but ideally the user would never see it. If it was going to hit your terminal it would be rendered for human viewing.

              Yaml is also super complex and has a lot of extensions that are sparsely supported. JSON is a much better format for interop.

              On the other hand the possibility of passing graphs between programs is both intriguing and terrifying.

              1. 3

                I was recently trying to figure out how, from inside a CLI tool I’m building, to determine whether a program was outputting to a screen for a user to view, or a pipe, for another program to consume… Turns out it’s not as straightforward as I thought. I do believe the modern rust version of cat, bat can do this. Because my thought is…. why not both?

            2. 1

              this is a good idea and wouldn’t even be that much work

            1. 4

              Just grabbed a copy to replace my 1st edition, thanks!

              1. 2

                Hopefully the new content is gonna prove useful. :)

                1. 2

                  I bought it a fairly long time ago to help me get started on a personal project but ended up not having enough free time to work on it, so now I’ll be swinging back around and I’m sure it will help. Just gotta’ set aside some time to get back into personal projects.

              1. 16

                I use what the Romans do, mostly (I have an Exchange mailbox, so that does make things more difficult.):

                • On Windows, I use Outlook.
                  • Filtering is fairly powerful, and can be punted to the Exchange server when possible
                  • Threading is flattened AFAIK, at least by default. That is, a thread is grouped into one clump, and you can expand to pick messages in the thread.
                • On Mac, I use Mail.app.
                  • I don’t use filtering here, no idea.
                  • Threading is messages are grouped together by default, right pane shows them linearly, can be expanded in mailbox view.
                • On Linux, I use Evolution.
                  • I don’t use filtering here.
                  • Threading is nested, up to a certain point where it becomes flattened because the diagonal line going too far would be too much.

                Fair warning: I generally use HTML email, top post, etc, because it’s what people in the real world (i.e. my clients) do, not what people who talk about email do.

                I haven’t heard of a simple HTML view or use external editors, so I can’t speak for that. The crashing you’re having with mail clients is really unusual though.

                In general I’m mostly satisfied with all of them, but Evolution does have infuriating bugs with synchronization message state with IMAP (i.e move a lot of messages at once to a folder, watch random messages in your current mailbox have random read/unread for a second until it updates).

                1. 3

                  Fair warning: I generally use HTML email, top post, etc, because it’s what people in the real world (i.e. my clients) do, not what people who talk about email do.

                  As far as I know there aren’t really any downside to using plain text when mailing with people who use HTML, right? Or are there email clients who render this in a weird way?

                  1. 7

                    Replying to an HTML thread in plain text can make the quoting render very poorly. I’m not sure whether this is down to the MUA doing the quoting or to the ones rendering the reply, but it gets pretty hard to read. If I’m replying to a large group on a thread that’s seen more than one HTML message, I prefer to do so in HTML.

                    1. 2

                      Some plain text renderers default to proportional fonts and mangle line endings and extra blank lines. (Notably, Gmail.) If you want your recipient to see the email the same way you intended, you should take this into consideration.

                      1. 1

                        I write emails in proportional font anyway, so that’s not really an issue.

                        I dusted off my gmail account, and it seems alright from a quick test, at least in gmail (CC @hoistbypetard)

                        I don’t really mind HTML email as such and I’m hardly some sort of plain-text purist (I just use the FastMail web UI); I mostly just dislike all the silly font stuff people do with it: weird fonts, weird colours (does Outlook still do that stupid blue text thing?), etc. so I prefer to read emails in the plain text version.

                        Although it seems I can set writing to “rich” and reading to “plain text”, and this will put the HTML in the quoted version – so that might be a happy in-between.

                      2. 1

                        I saw a HN comment suggesting plain text was negatively effecting their deliverability. This was anecdotal of course, but could be something to it. The proposed reasoning, was maybe more spam is sent as plain text. Whole bunch of maybes, but it could be some truth in there.

                        1. 3

                          Anecdotally, almost all of the spam I see is either:

                          • HTML mail
                          • A short ‘Hi {person}, {URL}’ plain-text thing

                          It’s possible that if you’re sending emails that look like:

                          Hi ryanford,

                          Did you see this post? https://lobste.rs/s/0c0tvx/what_email_client_do_you_use#c_2awrcf

                          They’d match a pattern of spam. It’s also worth noting that spam filters tend to be tuned per person and if you’re someone how only corresponds with people who use HTML mail then your filters will probably learn that all legitimate mail comes with an HTML MIME type section.

                      3. 2

                        Fair warning: I generally use HTML email, top post, etc, because it’s what people in the real world (i.e. my clients) do, not what people who talk about email do.

                        I need to correspond with a mix of those “people in the real world” and people who talk about email.

                        When I’m interacting with people who top post and use HTML email, I either use webmail or fire up a Win 10 VM and use Outlook.

                        When I’m interacting with people who react angrily to top posting and HTML email, I use mutt. I’ve been experimenting with aerc and like it quite a bit when it’s stable. Especially for reviewing patchsets that come in over email. For reading most email, these are my preferred clients, and both can just use a maildir so it’s easy to switch back and forth on a whim.

                        1. 2

                          All the clients I use (even Outlook) can be switched to plain text; Evolution has the best implementation because it auto-reflows to wrap and tries to map HTML formatting options to plain-textified ones. Every project I work with has a forge, so it’s trivial for me to just use plain text only for lists. (I’ve received Python scripts in Excel files more than I have diff format, so…. You haven’t lived until you had to switch the Excel worksheet to view a .bash_profile.)

                          1. 1

                            I like switching MUAs better than flipping the setting back to HTML when I need it in a reply. Mostly because I have found that if you keep your default format as plain text, then switch to HTML just when you need it in a reply, quoting gets messed up.

                            So the dance becomes: read a message where I want to reply with HTML -> go to settings and change how I compose email -> go back to the message and hit reply.

                            I’ve observed that in Outlook and Thunderbird. Evolution’s S/MIME bugs prevented me from using it for so long that I got out of the habit of even trying it.

                            But this:

                            You haven’t lived until you had to switch the Excel worksheet to view a .bash_profile.)

                            Damn. That is special.

                            1. 4

                              Apple Mail has a reply in kind setting where it chooses plain/HTML based on what the other person sent you. I feel like other email clients should have something similar? It seems like an obvious feature.

                              1. 1

                                Does it suppress HTML if the other person didn’t send you that?

                                When you’re composing a new message, not replying, the iPhone/iPad version (at least) does not let you prevent it from sending HTML. So as far as I have found, there is not a way to say “always send plaintext only when I write email to this mailing list”. If it could do that, the reply in kind setting would probably make it work well for me all the time.

                                1. 2

                                  NSTextView has different modes for plain and rich-text editing. When rich text editing is not used, you can’t paste styled text into it and none of the style-related menu options work. Mail.app uses this directly[1] and so when you’re in plain-text mode, you’re in plain-text mode. As I recall, the same shortcut as TextExit can be used for switching the two modes.

                                  Outlook, in contrast, uses the RichText control for editing and then strips the rich text. This is really annoying in some cases, most notably in a Teams Meeting invitation. If you send a Teams Meeting invitation as plain text, all of the links stop working. This is fine if the recipient is on Exchange because it also sets some metadata that Teams can use and so you can still connect, but if you send it to an external person they get something that says ‘click here to join’ and isn’t a link. There’s no warning in the UI about this. I filed a bug about this a couple of years ago.

                                  [1] I believe newer versions may use a slightly tweaked / subclassed version, because they do draw coloured lines down the side for sequences of quoted text, but that’s all.

                                  1. 1

                                    Yes. It replies fully plain text to email received plain text.

                                    I set it to plain text by default, and reply in kind to HTML.

                        1. 10

                          Why have I never seen… […] …a Lisp that can drop nested parentheses when the meaning is clear from context?

                          Well, doesn’t Scheme already have “I-Expressions”?

                          This SRFI descibes a new syntax for Scheme, called I-expressions, whith equal descriptive power as S-expressions. The syntax uses indentation to group expressions, and has no special cases for semantic constructs of the language. It can be used both for program and data input.

                          Not the same thing as he details, but it does show that parens aren’t necessary, for anyone curious.

                          Oh, and as an alternative, there’s also “Sweet Expressions”, which are a funky hybrid.

                          1. 2

                            Indentation syntax is close but not quite the same thing. It has a lot of weird edge cases. I do think Sweet-Expressions are cool and underused, though. I’m definitely planning to include them in Tangled Scheme (unpublished WIP Scheme dialect), whenever I get around to finishing it.

                          1. 12

                            This is an advertisement for their git commit-based metrics service, which is about as awful as one can get.

                            I get these emails constantly as I have an admin account on our enterprise Pluralsight account, and I manage a developer team, and honestly this idea of “let’s use commit metrics to judge your developers” is not something I think anyone would welcome. Let me share a recent email they sent:

                            Hey Adam,

                            You can’t lead to what you can’t measure, and every day Engineers create troves of data that are currently unused.

                            Sales, marketing, and finance use data daily to refine their processes.

                            However, your engineering team’s git history is an untapped goldmine of data that can help you manage your teams and communicate with external stakeholders. There’s almost limitless data in your Git history waiting to be used.

                            Ready to advocate for your team with concrete metrics?

                            I have some availability this week to connect, when works for you?

                            Thanks,

                            1. 5

                              This reads like a horoscope. And within it are really questionable assertions. “A developer in the zone produces evenly spaced, similarly sized pull requests”. Do people actually believe this?

                              1. 2

                                If the opposite means giving devs an hour between each meeting to complete their work, being in the zone is a wonderful thing.

                              2. 3

                                Well, I do think there is valuable data in the git history but not to judge developers. For example, the files with the most commits or the most authors are hot spots and a refactoring should be considered.

                                1. 1

                                  this idea of “let’s use commit metrics to judge your developers” is not something I think anyone would welcome

                                  Maybe welcomed by the ones doing the judging; the ones being judged, not so much. :)

                                  1. 1

                                    I flirted with Codermetrics[1] after reading the O’Reilly book back in the day. I think it could genuinely be useful as a tool for self-improvement. Inevitably, though, it would be turned into a performance management tool and thence gamed or otherwise take on a life of its own.

                                    [1] https://codermetrics.org/

                                  1. 3

                                    This makes me lament the fall of CouchDB, which by design, was itself a web API, fronting a document store instead.

                                    And unlike MongoDB’s fallback onto SQL style declarative queries and joins, it instead embraced documents through map-reduce functions and caching map() output as indexed views of data, saving you the hassle of managing multi-collection Mongo schemas and indexes and reference IDs.

                                    I’m still going to try and use it and PouchDB for my next project, but it’s a shame that it “lost” to Mongo in the long run, and now proprietary databases offered by Amazon, Google, etc.

                                    1. 2

                                      I similarly regret its failure as an early proponent. I periodically check on the project and was surprised to see that the Mango query language had been added as well as a few other useful features. Very impressive piece of software, still.

                                      Have you used PouchDB yet? I hear very good things!

                                      1. 1

                                        Not yet, but it seems like the perfect solution for offline-capable PWAs, which is one of my projects.

                                    1. 2

                                      If this history is new to you, I strongly encourage you to go read up on the ways this person leveraged their success and wealth to punch down in local politics. It’s not technical content, but it’s important for getting a more rounded view of their flaws, in case you feel a wave of hero worship coming on.

                                      1. 1

                                        TLDR: He’s a homophobe and bigot.

                                        The video is extremely interesting, and he’s almost likable, but given his past, I just grit my teeth and watched it for the pure tech lore. I already knew much of it, minus some details, which made this video worth watching.

                                        1. 2

                                          Is there any possibility he might have changed?

                                          1. 2

                                            A quick duckduckgo returned nothing but a Reddit thread of people talking about him in varying tones, some mildly negative, and a (very angry) “rundown” which may, for all I know, be a correct read on his personality, but nothing about bigotry.

                                            Where can one read up on his homophobia and bigotry?

                                            1. 3

                                              The search terms you want are “marriage equality” and “why kicked out Mozilla”.

                                              1. 1

                                                Phunny thing there; I had no idea about Eich, and didn’t even think of him, so I tried to see what scandals Fridman might have got into. Nothing as big as Eich, obviously ;)

                                        1. 2

                                          More like Git for MySQL, but alright, seems cool.

                                          1. 1

                                            A non-negotiable criteria for laptops for me is a half-decent keyboard, and this really doesn’t look like it. It just looks like a recreation of the old MacBook keyboards with flat keytops. (Touch typing keyboard design requirements is an entire separate digression…)

                                            What strikes me though, is the fact that the port “modules” are literally just proprietary dongles that slide into the body and communicate through USB-C. How is this honestly an improvement over using a dongle or two? It’s certainly not relevant if you’re using a USB-C dock. This modular port feature seems more a gimmick than anything useful.

                                            Also, the repairability angle is neat, but the fact that batteries are not swappable without a screwdriver and removing the entire underside, is a major detraction. One of the benefits of having hot-swappable batteries in a ThinkPad (due to the internal 2-cell battery) means you’re truly wireless 24/7 as one battery charges while the other is in use.

                                            So, why would I honestly buy one of these over a ThinkPad?

                                            1. 1

                                              dongles

                                              Having a different and larger cut-out in the chassis means that you could keep using the chassis and have useful ports even if the USB-C form-factor becomes obsolete. I think it’s a bit nicer to have your dongles actually inside the laptop, too.

                                              I would consider this over a thinkpad if it were more sustainable and/or I could get an ortholinear keyboard with trackpoint on it.

                                              1. 1

                                                If the form factor becomes obsolete, the signalling likely will too.

                                                1. 1

                                                  Yep, but keeping the chassis and replacing your dongles and mainboard is better than replacing all three.

                                            1. 11

                                              Agile is a manifesto, a movement. The movement created/adopted/popularized a pile of tools from standups to storyboarding to kanban. You’re meant to pick and choose what fits your needs to help you get in sync with your clients/customers – and change your choices if they need change, when the goals change! That’s agility.

                                              Scrum is prescriptivist management that takes on the facade of Agile. It’s rigid, conformist, and designed for managers to have control over the processes and output. The absolute opposite of agility.

                                              1. 10

                                                You can’t have it both ways. Either Agile is a prescriptive system that can be implemented, described, analyzed and criticized.

                                                Or it’s a lofty goal, like “balance”, “correctness” or “wealth”, that by itself doesn’t give you any meaningful guidance on how to get there.

                                                Agile proponents seem to be perfectly fine talking about their pet system as a panacea that will Rid us of Bureaucracy and Bad Decisions, but when criticism comes, they quickly turn the tables and shout YOU WERE DOING IT WRONG.

                                                1. 4

                                                  Scrum can be implemented well IMO, but it’s rare. Often it’s a top-down mandate from management seen as a silver bullet to solve their productivity problems (hint: it’s not a solution, it may even make things worse). I’m at a small startup and we’re using a very loose version of scrum (2 weeks sprints, story pointing, etc.). It wasn’t mandated, we decided it was a decent rough framework to keep track of our productivity and plan out milestones and we don’t follow it to a T if it’s not working for us.

                                                  1. 7

                                                    I tend to think of this as “Scrum can be agile, in spite of itself, but it’s rare.”

                                                  2. 2

                                                    There is even a church about Agile: http://www.thechurchofagile.org/

                                                  1. 2

                                                    What would you do with such a device connected to your computer? What information would you find useful? I’d love to gain some more inspiration for this!

                                                    My Zoom mute status, and my Discord mute status.

                                                    I don’t like the Discord overlays and I hate how I can never keep track of my mute status without hovering over the main Zoom UI, or having to set the zoom UI to always visible. Even better if you combine this with a small macro pad to activate stuff.

                                                    1. 14

                                                      The chapter on naming things from Elements of Clojure does a great job digging into how to think about naming things. I strongly recommend junior devs read it when I discuss naming practices with them.

                                                      1. 4

                                                        That remains one of the most cogent discussions of naming I’ve ever read. Applies way beyond Clojure!

                                                        1. 1

                                                          I would like to add that, no other profession, I think, creates so many new names for so many abstract things.

                                                          We create names on a daily basis, and it’s a skill/subject glossed over by schools and everyone, while names are a central form of communication we developers use and consume every moment. It’s wild that naming doesn’t get enough attention and we don’t even have a book dedicated to it, as I think we should.

                                                        1. 2

                                                          Enjoyed the talk. Especially some of the history I didn’t know about Oberon.

                                                          Just not sure why the suggestion after Smalltalk was Dylan, a Lisp that looks nothing like a Lisp and is less popular than every other other Lisp. There’s already great interest in a Lisp OS (other than Emacs) so it just seems like pet favorites here or a dislike for Lisp syntax, but alright.

                                                          I generally agree with moving back to environments that integrate a programming language, though. Have you by chance considered the Web?

                                                          I mean a realistic approach would be fusing a Blink runtime to Linux, or using ChromiumOS as a base, and having JS as a mutable, dynamic language + WebAssembly system.

                                                          We’re already heading that way, although we’d need to embrace open ECMAScript Modules and Web Components as the building blocks instead of minified bundles, and we’d need to stop abusing the semantics of the web, treating HTML and CSS as purely build artifacts (things that are hard to read and extend).

                                                          1. 1

                                                            Enjoyed the talk. Especially some of the history I didn’t know about Oberon.

                                                            Thanks!

                                                            Just not sure why the suggestion after Smalltalk was Dylan

                                                            Part of the plan is to make something that is easy and fun. It will be limited at first compared to the insane incomprehensible unfathomable richness of a modern *nix or Windows OS. Very limited. So if it is limited, then I think it has to be fun and accessible and easy and comprehensible to have any hope of winning people over.

                                                            Lisp is hard. It may be the ultimate programming language, the only programmable programming language, but the syntax is not merely offputting, it is profoundly inaccessible for a lot of ordinary mortals. Just learning an Algol-like language is not hard. BASIC was fun and accessible. The right languages are toys for children, and that’s good.

                                                            Today, I have met multiple professional Java programmers who have next to no grasp of the theory, or of algorithms or any comp-sci basic principles… but they can bolt together existing modules just fine and make useful systems.

                                                            Note: I am not saying that this is a good way to build business logic, but it is how a lot of organizations do it.

                                                            There is a ton of extra logic that one must internalize to make Lisp comprehensible. I suspect that there is a certain type of mind for whom this stuff is accessible, easily acquired, and then they find it intuitive and obvious and very useful.

                                                            But I think that that kind of mind is fairly rare, and I do not think that this kind of language – code composed of lists, containing naked ASTs – will ever be a mass-market proposition.

                                                            Dylan, OTOH, did what McCarthy originally intended. It wrapped the bare lists in something accessible, and they demonstrated this by building an exceptionally visual, colourful, friendly graphical programming language in it. It was not intended for building enterprise servers; it was built to power an all-graphical pocket digital assistant, with a few meg of RAM and no filesystem.

                                                            Friendly and fun, remember. Accessible, easy, simple above all else. Expressly not intended to be “big and professional like GNU.”

                                                            But underneath Dylan’s friendly face is the raw power of Lisp.

                                                            So the idea is that it gives you the best of both worlds, in principle. For mortals, there’s an easy, colourful, fun toy. But one you can build real useful apps in.

                                                            And underneath that, interchangeable and interoperable with it, is the power of Lisp – but you don’t need to see it or interact with it if you don’t want to.

                                                            And beneath that is Oberon, which lets you twiddle bits if you need to in order to write a device driver or a network stack for a new protocol. Or create a VM and launch it, so you can have a window with Firefox in it.

                                                            Have you by chance considered the Web?

                                                            Oh dear gods, no!

                                                            There is an old saying in comp sci, attributed to David Wheeler: “We can solve any problem by introducing an extra level of indirection.”

                                                            It is often attributed to Butler Lampson, one of the people at PARC who designed and built the Xerox Alto, Dolphin and Dorado machines. He is also said to have added a rider: “…except for the problem of too many layers of indirection.”

                                                            The idea here is to strip away a dozen layers of indirection and simplify it down to the minimum number of layers that can provide a rich, programmable, high-level environment that does not require users to learn arcane historical concepts such as “disks” or “directories” or “files”, or “binaries” and “compilers” and “linkers”. All that is ancient history, implementation baggage from 50 years of Unix.

                                                            The WWW was a quick’n’dirty, kludgy implementation of hypertext on Unix, put together using NeXTstations. The real idea of hypertext came from Ted Nelson’s Xanadu.

                                                            The web is half a dozen layers of crap – a protocol [1] that carries composite documents [2] built from Unix text files [3] and rendered by a now massively complex engine [4] whose operation can be modified by a clunky text-based scripting language [5] which needed to be JITted and accelerated by a runtime environment [6]. It is a mess.

                                                            It is more or less exactly what I am trying to get away from. The idea of implementing a new OS in a minimal 2 layers, replacing a dozen layers, and then implementing that elegant little design by embedding it inside a clunky half-dozen layers hosted on top of half a dozen layers of Unix… I recoil in disgust, TBH. It is not merely inefficient, it’s profane, a desecration of the concept.

                                                            Look, I am not a Christian, but I was vaguely raised as one. There are a few nuggets of wisdom in the Christian bible.

                                                            Matthew 7:24-27 applies.

                                                            “Therefore, whosoever heareth these sayings of Mine and doeth them, I will liken him unto a wise man, who built his house upon a rock. And the rain descended and the floods came, and the winds blew and beat upon that house; and it fell not, for it was founded upon a rock. And every one that heareth these sayings of Mine and doeth them not, shall be likened unto a foolish man, who built his house upon the sand; and the rain descended, and the floods came, and the winds blew, and beat upon that house; and it fell, and great was the fall of it.”

                                                            Unix is the sand here. An ever-shifting, impermanent base. Put more layers of silt and gravel and mud on top, and it’s still sand.

                                                            I’m saying we take bare x86 or ARM or RISC-V. We put Oberon on that, then Smalltalk or Lisp on Oberon, and done. Two layers, one of them portable. The user doesn’t even need to know what they’re running on, because they don’t have a compiler or anything like that.

                                                            You’re used to sand. You like sand. I can see that. But more sand is not the answer here. The answer is a high-pressure host that sweeps away all the sand.

                                                            1. 2

                                                              Hey, I appreciate the detailed response. I generally agree with your thesis, but I’m going to touch on some of your points.

                                                              [Lisp syntax] it is profoundly inaccessible for a lot of ordinary mortals.

                                                              I am going to have to strongly disagree here (unless we’re talking dense Common Lisp with its decades of quirky features). The Lisp syntax has few rules to learn (if not the least of any language other than Forth), is educationally friendly with tools like Dr Racket, and is one of the easiest to teach first-time programmers due to its obvious evaluation flow.

                                                              All one needs to know is how parenthesis work in mathematics. All one has to understand “how the data flows” is to look at the position in the expression and perform substitution of values as they’d learn in grade school.

                                                              (a  (b  c)
                                                                  (d  f))
                                                              

                                                              It is visually a sideways tree one can see of words and indentations. And thus can be visually rendered using a colorful friendly tree-collapsing UI if need be with drag and drop expressions. No other language can have such an interaction model with their complex syntax rules.

                                                              Carmack, for example, chose to teach his son programming with Racket: https://twitter.com/id_aa_carmack/status/569688211158511616?lang=en

                                                              Colleges have been teaching Scheme as a first programming language for years with SICP.

                                                              Really the discussion of Lisp syntax is one done to death; this is me beating a horse fossil at this point. There’s the value in the ease of understanding syntax, and the less obvious value of meta-programming, so the only other thing I’d add is that, we could just build a Lisp OS, and create Smalltalk as a Racket style #lang on top of it. You’re not going to find a better language to let people have their pet favorite syntax than a Lisp that will let you create that syntax.

                                                              Dylan could also just be implemented as a Racket-like #lang. (I’m not saying though that Racket is the ideal language, just that a meta-programmable language is an ideal, low level, substrate, to build things upon.)

                                                              But I think that that kind of mind is fairly rare, and I do not think that this kind of language – code composed of lists, containing naked ASTs – will ever be a mass-market proposition.

                                                              This is, of course, why DSLs exist, and why Racket has entire language abstractions on top of it, as I mentioned with Smalltalk and Dylan. Good Lisp designs actually scales better when you create powerful abstractions on top of it, making a complicated system accessible to “mere mortals”. Non-meta languages simply cannot scale.

                                                              It is more or less exactly what I am trying to get away from. The idea of implementing a new OS in a minimal 2 layers, replacing a dozen layers, and then implementing that elegant little design

                                                              Yes, but, this is a tremendous undertaking. The web, for better or worse, is literally the closest thing we have today to a Smalltalk-y dynamic user-editable/configurable/extensible system. ChromiumOS is the closest we have to that being a full OS a user can just play with out of the box. What other system today can you just press F12 and hack to pieces?

                                                              I myself got into programming in the 90s by just clicking “View Source” and discovering the funky syntax required to make websites. I’ve mentored and assisted many kids today doing just the same. The web is the closest we have to this expression.

                                                              Now, I’m not disagreeing that we shouldn’t try to create that awesome minimal rebirth of systems. It’s one of my personal desires to see it happen, which is why I’m replying and was so interested in the talk. We’ve absolutely cornered ourselves with complicated designs, I absolutely agree. I was mostly just pointing out we have a path towards at least something that gives us a shard of the benefits of such a system with the web.

                                                              The rest thought, I agree at a high level, so I’ll leave things at that.

                                                              1. 1

                                                                Hey, you’re welcome. I’m delighted when anyone wants to engage. :-)

                                                                But a serious answer deserved a serious response, so I slept on it, and, well, as you can see, it took some time. I don’t even the excuse that “Je n’ai fait celle-ci plus longue que parce que je n’ai pas eu le loisir de la faire plus courte.”

                                                                If you are curious to do so, you might be amused to look through my older tech-blog posts – for example this or this.

                                                                The research project that led to these 3 FOSDEM talks started over a decade ago when I persuaded my editor that retrocomputing articles were popular & I went looking for something obscure that nobody else was writing about.

                                                                I looked at various interesting long-gone platforms or technologies – some of the fun ones were Apollo Aegis & DomainOS, SunDew/NeWS, the Three Rivers PERQ etc. – that had or did stuff nothing else did. All were either too obscure, or had little to no lasting impact or influence.

                                                                What I found, in time, were Lisp Machines. A little pointy lump in the soil, which as I kept digging turned into the entire Temple of Damanhur. (Anyone who’s never heard of that should definitely look it up.) And then as I kept digging, the entire war for the workstation, between whole-dynamic-environment languages (Lisp & Smalltalk, but there are others) and the reverse, the Unix way, the easy-but-somehow-sad environment of code written in a unsafe, hacky language, compiled to binaries, and run on an OS whose raison d’être is to “keep ‘em separated”: to turn a computer into a pile of little isolate execution contexts, which can only pass info to one another via plain text files. An ugly, lowest-common-denominator sort of OS but which succeeded and thrived because it was small, simple, easy to implement and to port, relatively versatile, and didn’t require fancy hardware.

                                                                That at one time, there were these two schools – that of the maximally capable, powerful language, running on expensive bespoke hardware but delivering astonishing abilities… versus a cheap, simple, hack of a system that everyone could clone, which ran on cheap old minicomputers, then workstations with COTS 68K chips, then on RISC chips.

                                                                (The Unix Haters Handbook was particularly instructive. Also recommended to everyone; it’s informative, it’s free and it’s funny.)

                                                                For a while, I was a sort of Lisp zealot or evangelist – without ever having mastered it myself, mind. It breaks my brain. “The Little Lisper” is the most impenetrable computer publication I’ve ever tried, and failed, to read.

                                                                A lot of my friends are jaded old Unix pros, like me having gone through multiple proprietary flavours before coming to Linux. Or possibly a BSD. I won serious kudos from my first editor when I knew how to properly shutdown a Tadpole SPARCbook with:

                                                                sync
                                                                sync
                                                                sync
                                                                halt
                                                                

                                                                “What I tell you three times is true!” he crowed.

                                                                Very old Unix hands remember LispMs. They’ve certainly met lots of Lisp evangelists. They got very tired of me banging on about it. Example – a mate of mine said on Twitter:

                                                                « A few years ago it was lisp is the true path. Before that is was touchscreens will kill the keyboard. »

                                                                The thing is, while going on about it, I kept digging, kept researching. There’s more to life than Paul Graham essays. Yes, the old LispM fans were onto something; yes, the world lost something important when they were out-competed into extinction by Unix boxes; yes, in the right hands, it achieves undreamed-of levels of productivity and capability; yes, the famous bipolar Lisp programmer essay.

                                                                But there are other systems which people say the same sorts of things about. Not many. APL, but even APL fans recognise it has a niche. Forth, mainly for people who disdain OSes as unnecessary bloat and roll their own. Smalltalk. A handful of others. The “Languages of the Gods”.

                                                                Another thing I found is people who’d bounced off Lisp. Some tried hard but didn’t get it. Some learned it, maybe even implemented their own, but were unmoved by it and drifted off. A lot of people deride it – L.I.S.P. = Lotsa Insignificant Stupid Parentheses, etc. – but some of them do so with reason.

                                                                I do not know why this. It may be a cultural thing, it may be one of what forms of logic and of reasoning feel natural to different people. I had a hard time grasping algebra as a schoolchild. (Your comment about “grade school” stuff is impenetrable to me. I’m not American so I don’t know what “grade school” is, I cannot parse your example, and I don’t know what level it is aimed at – but I suspect it’s above mine. I failed ‘O’ level maths and had to resit it. The single most depressing moment of my biology degree was when the lecturer for “Intro to Statistics” said he knew we were all scared, but it was fine; for science undergraduates like us, it would just be revision of our maths ‘A’ level. If I tried, I’d never even have got good enough exam scores to be rejected for a maths ‘A’ level.)

                                                                When I finally understood algebra, I “got” it and it made sense and became a useful tool, but I have only a weak handle on it. I used to know how to solve a quadratic equation but I couldn’t do it now.

                                                                I never got as far as integration or differentiation. I only grasped them at all when trying to help a member of staff with her comp-studies homework. It’s true: the best way to learn something is to teach it.

                                                                Edsger Dijkstra was a grumpy git, but when he said:

                                                                “It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration”

                                                                … and…

                                                                “The use of COBOL cripples the mind; its teaching should, therefore, be regarded as a criminal offence.”

                                                                … I kind of know what he meant. I disagree, obviously, and I am not alone, but he did have a core point.

                                                                I think possibly that if someone learned Algol-style infix notation when they were young, and it’s all they’ve ever known, if someone comes along and tells them that it’s all wrong, to throw it away, and do it like this – or possibly (this(like(do(it)))) – instead, it is perfectly reasonable to reject it.

                                                                Recently I used the expression A <> B to someone online and they didn’t understand. I was taken aback. This is BASIC syntax and was universal when I was under 35. No longer. I rephrased it as A != B and they understood immediately.

                                                                Today, C syntax is just obvious and intuitive. As Stephen Diehl said:

                                                                « C syntax is magical programmer catnip. You sprinkle it on anything and it suddenly becomes “practical” and “readable”. »

                                                                I submit that there are some people who cannot intuitively grasp the syntaxless list syntax of Lisp. And others who can handle it fine but dislike it, just as many love Python indentation and others despise it. And others who maybe could but with vast effort and it will forever hinder them.

                                                                Comparison: I am 53 years old, I emigrated to the Czech Republic 7 years ago and I now have a family here and will probably stay. I like it here. There are good reasons people still talk about the Bohemian lifestyle.

                                                                But the language is terrifying: 4 genders, 7 cases, all nouns have 2 plurals (2-4 & >=5), a special set of future tenses for verbs of motion, & two entire sets of tenses – verb “aspects”, very broadly one for things that are happening in the past/present/future but are incomplete, and one for things in the past or present that are complete.

                                                                After 6 years of study, I am an advanced beginner. I cannot read a headline.

                                                                Now, context: I speak German, poorly. I learned it in 3 days of hard work travelling thence on a bus. I speak passable French after a few years of it at school. I can get by in Spanish, Norwegian and Swedish from a few weeks each.

                                                                I am not bad at languages, and I’m definitely not intimidated by them. But learning your first Slavic language in your 40s is like climbing Everest with 2 broken legs.

                                                                No matter how hard I try, I will never be fluent. I won’t live long enough.

                                                                Maybe if I started Russian at 7 instead of French, I’d be fine, but I didn’t. But 400 million people speak Slavic languages and have no problems with this stuff.

                                                                I am determined. I will get to some useful level if it kills me. But I’ll never be any good and I doubt I’ll ever read a novel in it.

                                                                I put it to you that Lisp is the same thing. That depending on aptitude or personality or mindset or background, for some people it will be easy, for some hard, and for some either impossible or simply not worth the bother. I know many Anglophones (and other first-language speakers) who live in Czechia who just gave up on Czech. For a lot of people, it’s just too hard as an adult. My first course started with 15 students and ended with 3. This is on the low side of normal; 60% of students quit in the first 3 months, after paying in full.

                                                                And when people say that “look, really, f(a,b) is the same thing as (f a,b)” or tell us that we’ll just stop seeing the parentheses after a while (see slides 6 & 7 ) IT DOES NOT HELP. In fact, it’s profoundly offputting.

                                                                I am regarded as a Lisp evangelist among some groups of friends. I completely buy and believe, from my research, that it probably is the most powerful programming language there’s ever been.

                                                                But the barrier to entry is very, very high, and it would better serve the Lisp world to recognise and acknowledge this than to continue 6 decades of denialism.

                                                                Before this talk, I conferred with 2 very smart programmer friends of mine about the infix/prefix notation issue. ISTM that it should be possible to have a smart editor that could convert between the two, or even round-trip convert a subset of them.

                                                                This is why I proposed Dylan on top of Lisp, not just Lisp. Because Lisp frightens people and puts them off, and that is not their fault or failing. There was always meant to be an easier, more accessible form for the non-specialists. Some of my favourite attempts were CGOL and Lisp wizard David A. Moon’s PLOT. If Moon thinks it’s worth doing, we should listen. You might have heard of this editor he wrote? It’s called “Emacs”. I hear it’s quite something.

                                                                1. 2

                                                                  it took some time

                                                                  Oh boy, I really don’t want to take up your time.

                                                                  For a while, I was a sort of Lisp zealot or evangelist – without ever having mastered it myself, mind.

                                                                  I myself am no Common Lisp expert. It’s an old language with odd behavior and too many macros. I personally use Clojure and find it extremely ergonomic for application development. I find modern Schemes in general to be fairly ergonomic as well, but maybe a bit too too many parens compared to Clojure.

                                                                  Clojure does a good job of limiting parens, and introducing reader macros of [] for vectors and {} for hash-maps and it works out exceedingly well. The positional assumptions it makes limit parens and it really isn’t hard to read. It’s like executable JSON, only way easier to read. It isn’t far from the type of JS and Ruby I write anyway.

                                                                  There’s more to life than Paul Graham essays.

                                                                  The only real PG thing worth reading is Roots of Lisp, which breaks down Lisp into its axiomatic special forms. You can see how one can start from lambda calculus, add some special forms, and end up with the kernel for a language that can do anything. Purely as an educational read.

                                                                  “The use of COBOL cripples the mind; its teaching should, therefore, be regarded as a criminal offence.”

                                                                  Today, this is Java. I’m sure you’d agree. Its pervasive use of non-message-passing OO has crippled two entire generations of programmers, unable to grasp first class functions and simple data flow. They cobble together things with hundreds of nouns, leaving the logic opaque and dispersed throughout these nouns and their verby interactions. Tremendeous effort is required just to track down where anything happens.

                                                                  Today, C syntax is just obvious and intuitive.

                                                                  This is only true of people with prior experience with C syntax languages. Exposure to a C style language first seats it as a norm within the brain, just as one’s first spoken language. I wouldn’t say C is intuitive to someone who has never programmed before.

                                                                  But the [Czech] language is terrifying

                                                                  I speak Polish, so I can very much relate to Czech and other Slavic languages. In fact, Polish is often considered the hardest language to learn.

                                                                  I put it to you that Lisp is the same thing. That depending on aptitude or personality or mindset or background, for some people it will be easy, for some hard, and for some either impossible or simply not worth the bother.

                                                                  I still strongly disagree.

                                                                  I am a visual-spatial person, and visualizing the trees and expressions is extremely easy for me. I have never felt more at home than I do with Clojure. It was an immediately overwhelmingly positive experience and I’m not sure any language will ever have a syntax or software model that is more matching my thought processes. (Prototypal languages like JavaScript and Lua come in a close second, because then I’m thinking in trees made of hash-maps instead.)

                                                                  see slides 6 & 7

                                                                  Actually, slide 7 is all I see (the words), and honestly, the default syntax highlighting for Lisps shouldn’t be rainbow braces, but muted and almost invisible braces like in said slide. Just indented nouns – like Python!

                                                                  I’ve adapted to many language with all sorts of funky syntaxes (WebFOCUS comes to mind) and I can’t say any was hard for me to get comfortable with after enough exposure. But the key to readability is finding the literal “shapes” on the screen and their patterns. My eyes can just scan them. (Python is the most readily readable in that regard.) But, if one does not write Clojure in idiomatic style, it does truly become hard to read.

                                                                  Lisp syntax lives or dies by how you horizontally indent braces. If you do not practice “semantic indentation” then you can truly be lost in a sea of meaningless parens, trying to find how the words relate to each other. That indentation visually shows the relationship. A visual tree.

                                                                  But the barrier to entry is very, very high, and it would better serve the Lisp world to recognise and acknowledge this than to continue 6 decades of denialism.

                                                                  I have introduced many people to Clojure and they’ve never found the syntax to be a barrier to entry. As a functional programmer, I find that C syntax gets in the way of Functional patterns and its syntax is a barrier to entry in learning Functional Programming.

                                                                  Let me dig up some examples:

                                                                  A C# functional approach to database return value transforms and validation: https://gist.github.com/Slackwise/965ac1947b69c60e21aa030be96b657b

                                                                  I am certain the Clojure equivalent would be shorter and much easier to read. Notice it looks fairly lispy on its own, in idiomatic Functional C# style. That is the nature of a Functional approach, be it C like syntax, or Lispy syntax.

                                                                  A more recent toy example was a technical challenge posited to me to write a palindrome function, which I decided to write functionally in both JavaScript (as a singular pure expression) and Clojure for comparison:

                                                                  const isPalindrome = (
                                                                    string,
                                                                    trimSameEnds = (
                                                                      [first, ...rest],
                                                                      last = rest.slice(-1),
                                                                      leftovers = rest.slice(0, -1)
                                                                    ) => first == last
                                                                           ? trimSameEnds(leftovers)
                                                                           : rest
                                                                  ) => trimSameEnds(string).length <= 1;
                                                                  
                                                                  (defn palindrome? [s]
                                                                    (<= 1 
                                                                        (count (loop [[first & rest] s]
                                                                                 (let [last (last rest)
                                                                                       leftovers (drop-last rest)]
                                                                                   (if (= first last)
                                                                                       (recur leftovers)
                                                                                       rest))))))
                                                                  

                                                                  Is the JavaScript form any easier to read? I would say the Clojure form is slightly easier as long as you understand semantic indentation. (Obviously you need to understand both languages as well as be somewhat versed in Functional Programming to make heads or tails of this FP voodoo.)

                                                                  I would say that familiarity is key, but moreso: consistent style.

                                                                  Any language written in a funky style that is not idiomatic is going to be immediately hard to read. I guarantee I can take any language and make it harder to read simply by changing the style. I personally find it harder to read something even if someone makes a minor lazy mistake like writing 1+2 instead of 1 + 2. It throws off the expected “shape” of the code and impedes readability.

                                                                  This is why I proposed Dylan on top of Lisp, not just Lisp.

                                                                  If by Dylan implemented as a reader macro in Lisp as an option, I’m for it, for those who have hangups over syntax. But also, any language they might prefer might as well be a reader macro option. I do think though, simply building good DSLs would go a long way in building an entire OS out of one language, without having to reach for C-ish syntax.

                                                                  1. 1

                                                                    Oh boy, I really don’t want to take up your time.

                                                                    No no, it’s fine, I am learning all the while here.

                                                                    I myself am no Common Lisp expert. It’s an old language with odd behavior and too many macros. I personally use Clojure and find it extremely ergonomic for application development. I find modern Schemes in general to be fairly ergonomic as well, but maybe a bit too too many parens compared to Clojure.

                                                                    Interesting. Noted.

                                                                    Clojure does a good job of limiting parens, and introducing reader macros of [] for vectors and {} for hash-maps and it works out exceedingly well. The positional assumptions it makes limit parens and it really isn’t hard to read. It’s like executable JSON, only way easier to read. It isn’t far from the type of JS and Ruby I write anyway.

                                                                    I have a suspicion that this may be the kind of improvement that is only helpful to those who have achieved a certain level of proficiency already. In other words, that it doesn’t help beginners much; maybe it reduces the steepness of part of the learning curve later on, but not at the beginning – and the beginning is possibly the most important part.

                                                                    The only real PG thing worth reading is Roots of Lisp, which breaks down Lisp into its axiomatic special forms. You can see how one can start from lambda calculus, add some special forms, and end up with the kernel for a language that can do anything. Purely as an educational read.

                                                                    Interesting.

                                                                    I found his essays very persuasive at first. I have grown a little more sceptical over time.

                                                                    Today, this is Java. I’m sure you’d agree.

                                                                    Hmmm. Up to a point, perhaps yes.

                                                                    I’d probably say C and C++ in more general, actually.

                                                                    I have read a lot of loper-os.org, and it pointed me at an essay of Mark Tarver’s “The Bipolar Lisp Programmer”. a A comment of his really struck me:

                                                                    « Now in contrast, the C/C++ approach is quite different. It’s so damn hard to do anything with tweezers and glue that anything significant you do will be a real achievement. You want to document it. Also you’re liable to need help in any C project of significant size; so you’re liable to be social and work with others. You need to, just to get somewhere. » http://marktarver.com/bipolar.html

                                                                    Its pervasive use of non-message-passing OO has crippled two entire generations of programmers, unable to grasp first class functions and simple data flow. They cobble together things with hundreds of nouns, leaving the logic opaque and dispersed throughout these nouns and their verby interactions. Tremendeous effort is required just to track down where anything happens.

                                                                    I really don’t know. I have never mastered an OO language. I am currently reading up about Smalltalk in some detail, rather than theoretical overviews. To my pleased surprise, the Squeak community have been quite receptive to the ideas in my talk.

                                                                    Today, C syntax is just obvious and intuitive.

                                                                    This is only true of people with prior experience with C syntax languages. Exposure to a C style language first seats it as a norm within the brain, just as one’s first spoken language. I wouldn’t say C is intuitive to someone who has never programmed before.

                                                                    For clarity: I was being somewhat sardonic here. I am not saying that I personally believe this to be true, but that it is common, widely-held received wisdom.

                                                                    I speak Polish, so I can very much relate to Czech and other Slavic languages. In fact, Polish is often considered the hardest language to learn.

                                                                    :-) I can well believe that!

                                                                    I put it to you that Lisp is the same thing. That depending on aptitude or personality or mindset or background, for some people it will be easy, for some hard, and for some either impossible or simply not worth the bother.

                                                                    I still strongly disagree.

                                                                    I thought you might, and this response did sadden me, because I am failing to get my point across at all, clearly. :-(

                                                                    Actually, slide 7 is all I see (the words), and honestly, the default syntax highlighting for Lisps shouldn’t be rainbow braces, but muted and almost invisible braces like in said slide. Just indented nouns – like Python!

                                                                    This is sort of my point. (And don’t get me wrong; I am not a Python enthusiast. I’ve been failing to learn it since v1 was current.

                                                                    The thing I think is instructive about Python is the way that experienced programmers react to it. It polarises people. Some love it, some hate it.

                                                                    Even rookie programmers like me know that different people feel different indentation patterns are right and good. There’s a quote in your link:

                                                                    « Nearly everybody is convinced that every style but their own is ugly and unreadable. Leave out the “but their own” and they’re probably right…​ »

                                                                    Python forces everyone to adhere to the same indentation pattern, by making it meaninful. The people that hate Python are probably people that have horribly idiosyncratic indentation styles, and thus would probably benefit the most from being forced into one that makes sense to others, if their code is ever to be read or maintained by anyone else.

                                                                    Thus, I suspect that strenuous objections to Python tell you something far more valuable about the person making the objections, than anything the objections themselves could ever tell you about Python.

                                                                    I’ve adapted to many language with all sorts of funky syntaxes (WebFOCUS comes to mind) and I can’t say any was hard for me to get comfortable with after enough exposure. But the key to readability is finding the literal “shapes” on the screen and their patterns. My eyes can just scan them. (Python is the most readily readable in that regard.) But, if one does not write Clojure in idiomatic style, it does truly become hard to read.

                                                                    So, it sounds to me like you have a versatile and adaptable mind that readily adapts to different languages. Most Lisp people seem to have minds like that.

                                                                    It seems to me that where they often fail is in not realising that not everyone has minds like that. That for many people, merely learning one style or one programming language was really hard, and when they finally got it, they didn’t want to ever have to change, to ever have to go through it again by learning something else.

                                                                    We all know people who only speak a single human language and say that they don’t have a knack for languages and can’t learn new ones. This is not only a sign of poor teaching methods. Maybe they are actually right. Maybe they really do lack ability at learning this stuff. Maybe it’s real. I see no reason why not.

                                                                    A lack of ability to learn to speak more than one human language does not stop someone from being highly creative in that language – I am sure that many wonderful writers, poets, playwrights, novelists etc. are monoglot.

                                                                    Well, a lot of skilful programmers who are able to do very useful work are also possibly monoglots. It took a lot of effort for them to learn one language, and they really like it, and all they will even consider are variants of that single language, or things that are different but at least use the same syntax.

                                                                    In the ’50s and ’60s, it might have been COBOL, or PL/1, or RPG.

                                                                    In the ’70s & ’80s, it might have been BASIC and variants on BASIC, especially for self-taught programmers. For another group, with more formal training or education, Pascal and variants on Pascal.

                                                                    In the ‘90s onwards, it’s been C.

                                                                    And so now we have lots of languages with C syntax and a cosmetic resemblance to C, and most people are comfortable with that.

                                                                    Me, personally, I always found C hard work and while I admired its brevity, I found it unreadable. Even my own code.

                                                                    Later, as more people piled onto the Internet and I got to talk to others, I found that this was a widespread problem.

                                                                    But that was swiftly overwhelmed and buried behind the immense momentum of C and C-like languages. Now, well, Stephen Diehl’s observation that I quoted is just how it is for most people in industry.

                                                                    If on the surface it looks like C, then it’s easy. Java looks superficially like C, although it’s not underneath. Javscript looks like it, although it’s not and it’s not like Java either. C++ is like C but with a million knobs and dials on. D is like C. C# is like C. And they’ve thrived.

                                                                    And people who know nothing else now thing that a language that replaces { and } with BEGIN and END is impossibly wordy and verbose.

                                                                    In the opposite direction, a language which replaces { and } but also for and while and if and almost everything else with just thousands of ( and huge blocks of nothing but )and it doesn’t even keep the block delimiters in order! Well, YES, to such a person, YES, this is totally unreadable.

                                                                    I do not know how old you are. I am quite old; I’m 53. I began and finished programming in the 1980s. But I try to retain a flexible mind.

                                                                    However, I see people of my age raging at “new math”. The idea that

                                                                    3 + 4 * 5

                                                                    … is the same thing as

                                                                    4 * 5 + 3

                                                                    … deeply offends them. They are old enough that they’ve forgotten school maths. The little they they recall is fragmentary and inconsistent. They have forgotten rules that they learned later such as “Bless My Dear Aunt Sally” or “BODMAS”. (If these are meaningless, Google them. :-) ) They think that they can do it and they don’t know that actually decades of use of calculators means they can’t. Prove to them with a calculator that actually there are precedence rules, and they will angrily say that the calculator is wrong and was clearly programmed by someone who “follows this ‘New Maths’ nonsense.”

                                                                    I have often read Lisp people saying things like:

                                                                    « Look as this:

                                                                    f(a,b)

                                                                    versus

                                                                    (f a b)

                                                                    It’s the same! We have just moved the same characters around! It’s really the same thing!”

                                                                    Well, no, to someone who only knows x(y,z) and nothing else, this is self-evidently nonsense and ridiculous.

                                                                    I put it to you that it is necessary to accept that, just as there are people who are monoglots and will die monoglots and may have rich and fulfilling creative lives being monoglots…

                                                                    … that by the same token, there are useful, skilled, productive programmers who can only handle ALGOL-type languages, who with serious effort might be able to move from the C branch of the ALGOL family to another branch, such as Python or PHP or Perl, but asking them to step outside the ALGOL family altogether and learn APL or Forth or Haskell or Lisp is just a step too far, one that they will never successfully take, and that is not a problem or a failing of theirs.

                                                                    Lisp syntax lives or dies by how you horizontally indent braces. If you do not practice “semantic indentation” then you can truly be lost in a sea of meaningless parens, trying to find how the words relate to each other. That indentation visually shows the relationship. A visual tree.

                                                                    Are you familiar with the “sweet expressions” project? It tried to “fix” Lisp syntax with indentation. It got nowhere much despite a lot of effort.

                                                                    https://readable.sourceforge.io/

                                                                    I don’t think it is ever going to succeed.

                                                                    In other words, I do not think that indentation can ever be the answer. It might help those who get over this hurdle, climb this hill, but it won’t help those for whom the hill will always be too high and too steep.

                                                                    But the barrier to entry is very, very high, and it would better serve the Lisp world to recognise and acknowledge this than to continue 6 decades of denialism.

                                                                    Agreed!

                                                                    I have introduced many people to Clojure and they’ve never found the syntax to be a barrier to entry. As a functional programmer, I find that C syntax gets in the way of Functional patterns and its syntax is a barrier to entry in learning Functional Programming.

                                                                    I am glad to hear it. I do suspect that for a lot of people, though, FP itself is just too far away from anything they will ever need.

                                                                    I read your “semantic formatting” link and I can’t understand a word of it, I’m afraid. :-(

                                                                    Let me dig up some examples:

                                                                    A C# functional approach to database return value transforms and validation: https://gist.github.com/Slackwise/965ac1947b69c60e21aa030be96b657b

                                                                    I am certain the Clojure equivalent would be shorter and much easier to read. Notice it looks fairly lispy on its own, in idiomatic Functional C# style. That is the nature of a Functional approach, be it C like syntax, or Lispy syntax. […] I would say that familiarity is key, but moreso: consistent style.

                                                                    Way over my head. I really am sorry.

                                                                    Any language written in a funky style that is not idiomatic is going to be immediately hard to read. I guarantee I can take any language and make it harder to read simply by changing the style. I personally find it harder to read something even if someone makes a minor lazy mistake like writing 1+2 instead of 1 + 2. It throws off the expected “shape” of the code and impedes readability.

                                                                    There you go. To me, 1+2 and 1 + 2 are completely interchangeable, but + 1 2 is an effort to decode.

                                                                    If by Dylan implemented as a reader macro in Lisp as an option, I’m for it, for those who have hangups over syntax. But also, any language they might prefer might as well be a reader macro option. I do think though, simply building good DSLs would go a long way in building an entire OS out of one language, without having to reach for C-ish syntax.

                                                                    I had to Google this term. If I understand you correctly, well, yes, that is the general idea. I think…

                                                          1. 2

                                                            and I naively think an imperative DSL for writing queries would help improve the situation.

                                                            That’s because SQL is a bad DSL.

                                                            The entire point of a DSL is to abstract away how something works, reducing cognitive burden. That is not true of SQL except for the simplest of queries. It is instead just an abstraction layer hiding how things function, leading to nothing but your aforementioned problems.

                                                            Meaning, I do agree a simple imperative DSL would work better in the vast majority of complex cases.

                                                            All that SQL ever does is force me to think “How would SQL actually pull this information, check indexes, join them, etc?” as I write my SQL. That’s actually an increased cognitive load of translating my desired goal into the SQL that would result in it.

                                                            1. 3

                                                              I think the onus is on the library writer and not the user to mitigate and communicate such changes. They’re the ones making a breaking change in a language that idiomatically uses higher order functions prevalently in common code and in libraries.

                                                              The only real problem here is how do authors communicate changes to library users, especially ones that just wholesale update their NPM packages for a project. The most obvious way is to create new functions, or communicate it appropriately by bumping the major version number. (Clojure’s approach to adding/updating functionality without introducing breaking changes is a good case study.)

                                                              1. 2

                                                                Well the author’s point still stands, even if you ignore the JS parts and talk about other languages.

                                                                The first thing I had to think of is Clojure, where I find myself writing

                                                                (map #(format-whatever % a b c) x)
                                                                

                                                                all the time, because it’s a little verbose but not ambiguous.

                                                                1. 2

                                                                  Yes, but, implied function arity positional calling is extremely common in languages that rely on higher order functions. We have tools to handle these situations from partial application to “fully” curried functions, to placeholders for currying like Ramda’s curryN().

                                                                  If one is versed in Functional patterns and idioms, this is just par for the course, and changing arity is a known breaking change to be communicated to users. Yes, I knooooow the average JS author isn’t writing Functionally, so this may be a tall ask, but JavaScript is also a language that relies on first class functions so it should be common knowledge for library authors that changing arity is a breaking change.

                                                                  Also, just to throw in there, the only 2 languages I know that have more than one arity for the mapping function passed to map() are JavaScript and C#, so the specific example only plays out there. (Although depending on types, the C# compiler will cry as the second parameter is an index int and something else like a hacky options object is passed instead.)

                                                                  In practice, though, unit tests should capture such issues. Maybe the actual advice should be “wrap your libraries in unit tests to make sure they don’t radically change underneath you and introduce bugs.”

                                                              1. 19

                                                                Some clarifications:

                                                                • It’s not just the package name. The code contains many other crude “jokes”.
                                                                • Some error messages that potentially bubble up to the end user contain insults.
                                                                • The upstream developers don’t seem to have intention to change attitude.
                                                                1. 5

                                                                  Some error messages that potentially bubble up to the end user contain insults.

                                                                  Honestly, this is the only point they need to make such a decision.

                                                                  1. 2

                                                                    OP should have linked to the actual Debian response instead of the phoronix spam. It’s much more informative.

                                                                  1. 2

                                                                    Tried to pinch-zoom the page, but it triggered some awful post navigation throwing me back in time. Why is this even a thing?

                                                                    1. 2

                                                                      Reading “Learning React” from O’Reilly, for obvious reasons, but more interestingly:

                                                                      Why Buddhism is True: The Science and Philosophy of Meditation and Enlightenment

                                                                      Which is a scientific perspective from an evolutionary psychologist on mindfulness and Buddhism in general. Found it via the Ezra Klein podcast, and now it’s just captured my attention. Been reading it bit-by-bit on the train into work.

                                                                      1. 7

                                                                        Clojure. It felt like the natural progression, especially since I was interested in diving deeper into FP. Now I can’t not love s-exps and structural editing, as well as even more powerful meta-programming.

                                                                        (Also notable that I saw Russ Olsen, author of Eloquent Ruby, moved to Clojure, and now works for Cognitect.)

                                                                        1. 3

                                                                          I’m really interested in Clojure, but compared to Ruby there seems to be an order of magnitude fewer jobs out there for it.

                                                                          I can’t swing a dead cat without seeing 4 or 5 people a week looking for senior Rubyists. I’ve seen maybe 2 major Clojure opportunities in the last 6 months.

                                                                          1. 4

                                                                            I can’t swing a dead cat without seeing 4 or 5 people a week looking for senior Rubyists.

                                                                            What’s been your success rate when bringing carrion to job fairs?

                                                                            1. 1

                                                                              The way the local job market is, I doubt it’d damage my chances that much.

                                                                          2. 1

                                                                            Clojure is absolutely great and so is Russ. He still loves Ruby (as well) though :)

                                                                            I still maintain that one of the best books I ever read for my coding skills is Functional Programming Patterns in Scala and Clojure.

                                                                            Clojure never really got me personally - I would have liked but weirdly short names, friends telling me that for libs tests are more considered “optional” & others were ultimately a bit off putting to me. Still wouldn’t say no, just - switched my focus :)

                                                                            1. 3

                                                                              Tests are definitely not considered optional by the Clojure community. However, you’re likely to see a lot less tests in Clojure code than in Ruby.

                                                                              There are two major reasons for this in my experience. First reason is that development is primarily done using an editor integrated REPL as seen here. Any time you write some code, you can run it directly from the editor to see exactly what it’s doing. This is a much tighter feedback loop than TDD. Second reason is that functions tend to be pure, and can be tested individually without relying on the overall application state.

                                                                              So, most testing in libraries tends to be done around the API layer. When the API works as expected, that necessarily tests that all the downstream code is working. It’s worth noting that Clojure Spec is also becoming a popular way to provide specification and do generative testing.

                                                                          1. 6

                                                                            Semi-active, but, the community is way more engaging than the Twitter void.

                                                                            https://mastodon.social/@Slackwise

                                                                            P.S. It’s insanely frustrating to copy and paste these usernames on mobile, especially since they keep turning into mailto links. Could we please use profile links instead? Makes it easier to one-click follow, on desktop and mobile.