1. 3

    When I started in school/industry (early ‘80s) it was a pretty common notion that you can judge someone’s aptitude for programming by how comfortable they are with pointers and recursion. One of my standard whiteboard questions at Microsoft in the ‘90s was deep-cloning a tree-like structure (and if there’s extra time, a DAG), because it involves both (well, typically…recursion is naturally optional). This had the advantage of not seeming like the question was just to reimplement a standard data structure.

    I think nowadays there’s probably a legitimate gap between systems programmers who need to care how computers actually work (what we used to call just “programmers”), and application (?) programmers who focus on business logic and glue code. So there’s probably some similar, but different, notion of judging aptitude for application (?) programming. I still have a very hard time being comfortable with that gap, though.

    1. 10

      If something starts out by making the assertion that Clojure has “taken the world by storm”, at least you know where the author is coming from. :) I don’t know if I’ve ever seen a dedicated Clojurist attack Haskellists specifically, so this is interesting from that standpoint.

      Regarding the complaint about Haskell docs being terrible because they just refer you to academic papers: Well, some Haskell docs are terrible, but also “it turns out” academic papers contain a lot of meaning and are often way better documentation than a typical language would give you. In particular, when I read the original paper introducing Monad to Haskell, it was much clearer than most of the explanations people have written since. Python has PEPs, Haskell has papers.

      By the way, while you’re looking for examples of people explaining monads badly, keep an eye out for people trying to explain transducers…

      1. 2

        I don’t know if I’ve ever seen a dedicated Clojurist attack Haskellists specifically

        Maybe Not?

        1. 3

          Well…hmm… IIRC, in that talk, though he used Haskell in the examples, he’s just looking at a specific type that isn’t unique to Haskell. Besides, he says he made the same “mistake” himself in spec. So hardly calling Haskell a “bad language”!

          1. 2

            As I understand it, his problem is that he wants a value to be a member of multiple types, but in Haskell every value can have only one type. That is a pretty foundational aspect of how the Haskell type system works. A language with extrinsic types like Cedille wouldn’t have this problem, maybe he’d like that.

            It’s not an attack on e.g. Kotlin even though a value only has one type there also, but Kotlin has special syntax to make null handling convenient.

            My personal opinion is that it is not really a significant problem to fix call sites when a function gets/loses a Maybe in its signature… I’d see it as an advantage since you could optimize the caller, even. If the caller is handling a Nothing that can no longer be returned, I don’t see why that code has to compile.

            In Clojure, with spec, I believe you can have multiple specs matching a value. So a value can have multiple “types”.

          2. 1

            My least favorite video from Rich. I used to use a lot of Clojure and I really like LISP but I would never trade back my ML (F#) to that. Clojure code is much harder to get right the first time and painful to refactor. I usually write Clojure as a quick and dirty if absolutely necessary (like for example no C# driver for something). I think I am going to use Kotlin the next time though.

        1. 27

          Obligatory please don’t tell anyone how I live, here is my very messy desk:

          OS: Arch Linux

          CPU: Intel i5-6600 @ 3.30 GHz

          RAM: 16 GB DDR4

          WM: i3

          MB: Gigabyte Q170M-D3H

          KB: IBM Model M

          GPU: Nah

          Cat: Orange and White Maine Coon, “Salsa” aka “Salsa T. Cat Esq.”

          Cat treats: Chicken

          Water: Tap

          Coffee: Black

          Whisky: Neat

          1. 11

            I enjoyed this image very, very much. Thank you for your honesty! I particularly enjoyed the pump bottle of vaseline.

            1. 6

              Thanks! I was going to remove it and take another picture but then I thought, well why not just show a slice of everyday life? It’s cold and dry where I live in Canada and my skin needs some lotion so I don’t get the alligator complexion.

              I was thinking a lot of this excellent Calvin and Hobbes comic when I was taking the picture, should I clean up my desk before I take a picture so I appear to be neat and tidy or just present my life as-is unfiltered?

            2. 2

              This feels like home. I don’t know if you can actually compare two messes but our areas feel equal in messiness.

              1. 2

                I see the base for the soldering iron. I’m scared to ask where in here the actual iron is.

                1. 1

                  Haha, it’s off to the left, on the window sill.

                2. 1

                  I often struggle with how messy my desk becomes. My preferred style of note taking to work out a problem is a good pen and pads of paper, so things end up accumulating and I don’t feel like I want people to see my office. Thank you for sharing this picture! I’m right in the middle of reorganizing, or I’d show you how bad mine can get.

                  1. 1

                    is that a speaker strapped to the bottom of the left monitor? If yes, why?

                    1. 1

                      It is! It was an accessory that was available with that monitor and from what I recall, a lot of Dell business/professional monitors. Here’s what it looks like off the monitor.

                    2. 1

                      Fantastic! As well as Arch, I’m a huge Kubrick fan—where did you get your desktop background?

                      1. 1

                        Awesome, glad you liked it. I’ve had that one for a long time, I did a search on the filename and there is a copy here: https://www.colipera.com/you-deserve-nothing/vector-2001_00359644/

                    1. 10

                      I realize it’s different in implementation but I think it’s hilarious that for 20 years we’ve been moving away from frames and server-side rendering in favor of client-side scripting, XHR, and single-page apps and now this is talking about using frames and server-side rendering. :)

                      1. 7

                        It seems there has been some back and forth between the two paradigms during the past 2 decades. React just announced server-side components, which mimics what Meteor JS introduced several years ago. And some websites use a mix of server templates and client JS.

                        I wonder what are the constraints that influence this evolution? increasingly large client-side apps? lower network speeds? larger and more diverse audience, with less-performant hardware and bandwidth? It’s interesting to watch – and I wonder how it affects framework adoption. It’s a lot easier for a new dev to learn jQuery than a framework that has client and server setup.

                        Link to react blog post, where they touch on some of those design constraints: https://reactjs.org/blog/2020/12/21/data-fetching-with-react-server-components.html

                        edit: a co-worker shared https://htmx.org/ – strikingly similar to Hotwire. Check out the “motivation” section. It would make sense to me if the “best” solution lies somewhere between fully-bundled single-page app and an entirely server-side rendered app

                        1. 46

                          My going theory (and folks feel free to jump in on me for revisionism):

                          For most of the aughts, we used to basically/mostly just have server-side apps.

                          Ruby on Rails and Django come onto the scene around 2005, and by around 2010 startups like Github and everybody and their brother is using Rails or some equivalent.

                          Unfortunately, these server-side frameworks are slow as hell compared to other ones of the time and so people start solving this by exploring the autoscaling tech tree (giving us products like Heroku) and the thick-client tech tree (giving us products like Backbone, Mithril, Angular, React, and so forth…tech already unlocked by things like Google Web Toolkit and Dojo years prior but hey, nobody wants to write Java at their startup). This is also around the time that CDNs started getting big, so companies like Cloudflare show up to offer hosting of assets.

                          So, it’s like the mid 2010s and barring some weird evolutionary forks like MeteorJS we see that people are really all hot and bothered about Single Page Apps. This is further pushed by the rise of mobile apps, because everybody suddenly wants to use the same server backends to handle API calls while subcontracting to body shopscreating mobile applications alongside their web offerings, thus increasing shareholder value while being able to use dumber backends (and consequently, hire cheaper developers). Feeding this further, the 2010s saw the rise of services like Firebase and Zapier where your thick-client could talk to a service you didn’t have to host or program; you could glue together a startup without ever knowing anything about server-side programming and the accompanying ops/performance issues.

                          The server (and server-side rendering) is toast, long live the server.

                          Except. Except.

                          Drunk on their successes and beers from conferences, the Javascript ecosystem just kept growing. And growing. And growing. In the 2010s we went from minimal asset processing (possibly raw files, maybe sprockets or similar if you were in Rails) to Grunt, Gulp, Browserify, and eventually Webpack, with pitstops for evolutionary dead-ends like Parcel and Brunch. At the same time, we started wanting to use languages like Typescript and even newer versions of Javascript that hadn’t formalized yet so we stole features from the proposal stages and brought them in using tools like Babel. Oh, plus, we decided that npm was not good at their job (npm 2 to npm 3 migration, anybody?) and so tools like yarn from Facebook came out to further confuse things.

                          Anyways, all of this to say that a once-promising land was overrun by bullshit.

                          A few ecosystems (I’m biased in favor of Elixir/Phoenix/LiveView here, but Turbolinks in Rails and I want to say some stuff over in PHP land also did this) discovered that a) they still ran plenty fast or their host language had sped up in the last decade, b) that dealing with the clownshoes of Javascript and thick-clients was excessively frustrating), c) Websockets were finally pretty reliably available, and d) all they ever wanted to do was patch subtrees of the DOM and give a-c maybe they could teach the server how to do this with a little bootstrapping on the client.

                          And so now, server-side rendering is back on the menu.

                          (As a colleague points out, Google also did a lot of stuff along the lines of Webpack earlier with Closure Compiler, and there are other beats I’ve left out due to ignorance or convenience, but I think this is a good rough sketch for people.)

                          1. 11

                            Not revisionist at all, I think you nailed it, except I would also mention the vast amounts of effort that have gone into improving network and browser performance in the past decade. Receiving a chunk of HTML over the (typically fast) network and replacing a chunk of the DOM is now quite competitive with receiving some JSON, diffing a shadow DOM in JS, and making selective DOM edits.

                            1. 2

                              Fantastic. Thanks for sharing.

                          2. 5

                            I had the same first thought but it looks like a significant difference with traditional server-side rendering is the idea to send partial page updates as HTML via websockets.

                            1. 4

                              Same here. Initially I thought “hm, this is exactly how we used to program Rails in 2006, but with better syntax to replace/automate away the manual RJS partial update mess”, but it’s the async websocket notifications that actually make this cool and viable for this brave new world.

                              It actually looks more convenient than manually setting up websocket communication and reading from an API in JavaScript. What really makes this neat to me is not having to touch a single line of JavaScript.

                              I wonder how well this translates to different types of applications, though. I seem to recall that back in the day, Rails was really good at building certain classes of web applications/sites but it didn’t do so well on other types of sites.

                          1. 5

                            Recently also acquired the TS3 and I am a bit awed by the power of Thunderbolt 3. One cable carries 87W of power, 4K@60Hz, and a huge number of USB 3 at 10 and 5Gbps. My monitor also has a few USB-A ports which themselves get carried through its Thunderbolt 3 to the dock and then to the laptop. It’s clean as heck.

                            1. 2

                              I love mine too — only problem is my 2020 MacBook Pro technically requires 96W of power, though I never drive it hard enough for long enough to have trouble. But I think Apple just solved that problem permanently with the M1…

                              1. 1

                                It’s also been reported that the M1 has Thunderbolt 4 ports, which support hubs that can multiplex one Thunderbolt-4 port into three – handy for devices that only have one port on them and don’t support chaining.

                            1. 11

                              I haven’t desired an OS war debate since about 2005. I understand that this isn’t fair since I’m probably laying down kindling and not asking for a flame war.

                              I would switch much faster if I had iTerm2 (don’t say tmux, alacritty unless they are 1:1) and a few other tools. I’ve run Gentoo as my main machine and many Linux-es in the past (all I can do for street cred folks). Xcode, the app store, economics or something else apparently just makes high quality UIs possible because it’s not the same? Monodraw, Alfred, Pixelmator and a few others. There are a few I could budge on. The Mac apps are very polished, fonts are the best and usually the UX is good (iTerm’s options boxes are kind of insane). I keep flirting with the idea but then I make a list of stuff I’d miss.

                              Linux has upsides too. It’s really what I want, a Unix box. I could ditch tiling window manager clones or near-misses and get a full-on tiled thing going (of course the browser kinda of kinks the terminal based flow but whatever). That’s not my issue. My issue is that Linux is great on the server. Linux (unix) excels at text but its desktop and GUI layer has always been weird. I don’t want it to be like this. If Electron was magically as fast as QT (etc) and made it easy to layout GUIs like Xcode, maybe that would be it? I just don’t know what the issues are in the GUI space. Armchair analyst mode though: people pay for mac software.

                              This just continues to be true: computers suck, macs suck the least. But everything can change with time.

                              1. 6

                                I’m not a fan of tmux and alacritty either but found kitty to be a great cross platform alternative to iTerm. At least if it’s the panes and tabs that you want.

                                Much more pleasant configuration too if you like to keep clean dotfiles.

                                1. 2

                                  What does iTerm2 do that’s not in something like gnome-terminal?

                                  I use both and I’d like to know about any cool features I’m missing in iTerm2.

                                  They look the same to me from my Linux accustomed experience, what am I missing?

                                  1. 2

                                    Does anything else have “native tmux” yet? That is, tmux windows/panes are just iTerm windows/panes—you don’t need to do any tmux key commands at all. Makes persistent server sessions very nice. I believe the iTerm author implemented the protocol for this in tmux but I’m not sure if any other emulator has adopted it.

                                    1. 1

                                      iTerm has more customization knobs than gnome-terminal (or any other Terminal emulator I’ve used) by an order of magnitude.

                                      1. 1

                                        Same, would love to know what I was missing from iTerm2. I don’t use tmux integration, not sure about other cools features that I missed. But one thing I noticed is it’s significant slower thang the default terminal application.

                                        1. 1

                                          Good question so I’ll do my best. Most of this is taste but I hope I can explain a feeling.

                                          1. The hotkeys are nice (to me). They are quicker than leaders and are basically the same as Chrome tabs. Cmd+T for new tab, Cmd+Alt+Arrows. And of course mac apps flash the menu item and have hints next to them. But that’s iTerm leveraging MacOS.
                                          2. The pane splitting is easy. Moving panes is easy. Moving panes to windows or the opposite, easy-ish.
                                          3. Broadcasting input to all tabs is neat (but rarely used). Tmux does this too.
                                          4. The fonts look nice (because MacOS). I’m sure other terminals have 256-color and image support. iTerm was early on this (to me). Powerline fonts, all the fluff.
                                          5. The fullscreen has native and non-native options, so it’s quick and has survived the Apple OS changes.
                                          6. I use a global hotkey for a dev log described here.
                                          7. You can temp fullscreen a pane with shift+Cmd+enter. It has an overlay telling you you are in this mode.
                                          8. Like someone said, the customizations are great. Just one example: you can dim panes on unfocus to your liking. Even not graphics dimming, font color dimming. It’s great.
                                          9. The tmux stuff is neat, a bit weird (root window has to stay open). Haven’t used it a lot.

                                          I’ve tried the windows options. Putty (not the same thing) hasn’t changed in decades. ConEmu or Hyper is close. Hyper is a bit slow (maybe things have changed). ConEmu is close with WSL. But I’m biased because of muscle memory!

                                          Sorry, getting off-topic. Back to the OP, I agree in the sentiment. I’m spooked by the changes. It’s consumer facing more and more. But I don’t know if any of these things are nails in the coffin or the community will continue to workaround/adapt. There have been breaking changes on major OS versions for a long time. People working sometimes wait when they optimize for stability. But, OP, I hear you. 🌻

                                        2. 2

                                          Yeah, it’s only a matter of time. After a recent upgrade of iTerm2 my whole screen would periodically flicker wildly. Occasionally my machine (2019 Pro) would reboot. I temporarily downgraded to Terminal, and everything settled down. My text mode apps also seemed snappier. My lesson from all this: to always be on the lookout for costs when things change. Even when the change seems pleasant (timestamps on specific lines in iTerm2, tmux integration, lots of other lovely stuff). Because we suck at changing things at scale without regression.

                                          1. 2

                                            I agree with this. And your description of Linux feeling different from macOS, at least in terms of GUIs, reminds me of this blog entry: https://blogs.gnome.org/tbernard/2019/12/04/there-is-no-linux-platform-1 IMO, to make a Linux computer feel like a real Unix desktop you need a controlling entity to smooth over the edges. Like Android or Chrome OS or even Raspberry Pi OS. Of course, purists would say “this isn’t the GNU/Linux I know”. They’d be right. But from what I can tell, we don’t even have that option.

                                          1. 18

                                            I’ve been reading the Gemini specification, as well as this post, and my conclusion is that it’s just a worse version of HTTP 1.1 and a worse version of Markdown.

                                            1. 6

                                              worse version of HTTP 1.1

                                              Strong disagree. TLS + HTTP 1.1 requires to perform a upgrade dance involving quite a few extra steps. The specification is also pretty empty regarding SNI management. Properly implementing that RFC is pretty demanding. There’s also a lot of blind spots left to the implementer better judgement.

                                              In comparison, the Gemini TLS connection establishing flow is more direct and simpler to implement.

                                              TLS aside, you mentioning

                                              I’ve been reading the Gemini specification

                                              sounds like a clear win to me. The baseline HTTP 1.1 RFC is already massive let alone all its required extensions to work in a modern environment.

                                              1. 7

                                                I agree that the specification is simple to read, but the specification itself is too limited and don’t find it suitable for the real world.

                                                For example, I prefer HTTP’s optional end-to-end encryption because when working with internal routers within an infrastructure dealing with certificates is a PITA and a completely unnecessary bump in complexity and performance overhead being inside an already secured network.

                                                I also disagree on that “extensibility is generally a bad idea” as the article says. Extensibility can work if you do it properly, like any other thing on software engineering.

                                                EDIT: Or the requirement of closing the connection and re-opening it with every request, and all the handshakes that means.

                                                For clarity about what I think could be an actual improvement: I would prefer an alternative evolution of HTTP 1.0, with proper readable specs, test suites, clearer https upgrade paths, etc; instead of an evolution of Gopher.

                                                1. 4

                                                  TLS + HTTP just requires connecting to port 443 with TLS. I’ve worked on lots of things using HTTP for >20 years and I don’t think I’ve ever seen the upgrade protocol used in real life. Is it commonly used by corporate proxies or something like that?

                                                2. 6

                                                  When I looked at it (months ago), I got the same impression. I find this article irresponsible, as Gemini does not merit the support.

                                                  Gemini’s intentions are good. The specification isn’t. For instance, not knowing the size of an object before receiving it makes it a non-starter for many of its intended purposes.

                                                  This is an idea that should be developed properly and openly, allowing for input from several technically capable individuals. Not one person’s pet project.

                                                  I’ll stick to Gopher until we can actually do this right. Gemini doesn’t have the technical merit to be seen as a possible replacement to Gopher.

                                                  1. 3

                                                    It does accept input from individuals. I was able to convince the author to expand the number of status codes, to use client certificates (instead of username/password crap) and to use the full URL as a request.

                                                  2. 4

                                                    I prefer to think of Gemini as a better version of gopher with a more sane index page format.

                                                  1. 2

                                                    I would have preferred the post itself to emulate gemini to a degree. E.g. no inline links, no styling.

                                                    1. 6

                                                      You can view the post through the Gemini HTML gateway.

                                                      1. 2
                                                        1. 1

                                                          Excellent! Thank you!

                                                          1. 1

                                                            Gateway seems to half broken, I am often getting Gateway error: EOF

                                                            Works after some attempts.

                                                        1. 18

                                                          Rather than just saying “org-mode” like normal, here’s how I use it.

                                                          I keep two files, one inbox and one as a “brain”. When anything new comes in, I use org-capture to capture that as a todo entry and store it in the inbox. I have two states: TODO, and EXPEDITE.

                                                          My main file looks like this:

                                                          * OKRs - my planned objectives; anywhere from 3-8 projects below this header
                                                          * Unplanned Work - things that I did/need to do that aren't what my performance is measured on ;)
                                                          * Tasks - work tasks that are one-off'ish ("security training", "get a new Yubikey", (..))
                                                          * Personal - personal tasks that aren't work, but need to happen during the day
                                                          

                                                          First thing every morning, I:

                                                          • Get to inbox.org zero: everything gets refiled into the appropriate place, with a scheduled date associated to it as needed. If I have a hard deadline, it gets that too.
                                                          • Look at my org-agenda for the day: do I have anything scheduled or any hard deadlines? If not, I decide what to work on that day and pull them onto the agenda. Also, if I have any more than 1 task tagged EXPEDITE, it’s time for a conversation around urgency and priorities :)

                                                          After a five minute break to get a coffee, I pick my first task and call org-pomodoro to clock in and work. After the bell dings I take a five minute break, then jot down some notes on what I worked on (if needed) and repeat.

                                                          At the end of the day, I try to reserve ~30 to go through my email and handle that, inbox zero style. Anything that needs more than two minutes of thought is captured in my org-mode inbox for tomorrow morning.

                                                          I like this because it’s a workflow that evolved to fit how I think and operate – but you will like org-mode because it can evolve to fit how you think and operate.

                                                          1. 4

                                                            I don’t know what I’d do without org mode. It’s basically like markdown + jupyter notebooks + time tracking + outlining + presentation tool + diagram tool all in one human readable file. Add tramp-mode on top of it to unlock more power. I just wish I could better use it to collaborate with non-emacs loving team mates. As it is it has to remain a personal tool. Publish only.

                                                            1. 2

                                                              I would love to discuss and show our different systems to eachother.

                                                              I also use org-mode, using deft as something akin to a zettelkasten, and a gtd.org and work.org file for personal and work headings respectively. https://codemac.net/gtd.html is the current description, but I’m still writing it up.

                                                              1. 2

                                                                So my org-mode strategy is just a few capture templates, and a giant org note file of crap.

                                                                I’ve been trying out org-roam/gkroam to see how that might work for a lot of my one off “i have a thing to record” notes that I can eventually come back to later (via an org-habit to periodically look at things of course!).

                                                                Honestly org-mode is such an insane thing on its own, I’m curious how every emacs org user uses it, it seems so good at being adaptable to your specific flow that I doubt any two users will be similar, but guessing we could all use inspiration.

                                                                1. 2

                                                                  it seems so good at being adaptable to your specific flow that I doubt any two users will be similar

                                                                  This is exactly what I did wrong the first time I started using org mode: I found one of the awesome and exceptionally in-depth guides and followed it to the letter. But I never used the system it lead me to build because it wasn’t how my brain wanted to plan tasks.

                                                                  The Lisp curse – everything is possible so everyone does it their way – strikes again ;)

                                                                  1. 3

                                                                    Lol yep, always gotta start from ground zero, not the top of the mountain. I know EXACTLY which guide I think you’re alluding to, and that things full of ideas, but my god is it more than I really need out of my notes. Tracking time in org is neat but i’ve never gotten any use out of it besides the agenda. Maybe the timers that act like pomodoro timers, even then i just use my phone generally.

                                                                    1. 2

                                                                      But it’s not a curse in this context! You should do your personal notes your own way, and org-mode lets you do exactly that.

                                                                      The “curse” is that Lisp lets you write programs in a personally customized way, and in a shared codebase that can be a problem. Here, it works great.

                                                              1. 21

                                                                I am a big fan of having a paper notebook and a nice, hefty, metal pen. The ability to rapidly intermix text, drawings, and sketches is underrated.

                                                                EDIT: For the record, I really like Machine Era pens. Solid metal and made in the USA, with easily refillable ink cartridges.

                                                                1. 4

                                                                  After trying multiple systems on my laptop or smartphone, I always fall back to my notebooks and a foutain pen. The only thing that I miss is a way to easily record some url or reference. I thought about creating my own url shortener or find a mini printer to print sticker with QR code.

                                                                  Intermixing different kinds of inputs (text,drawings,sketches,ddiagrams) is the really what I miss the most when I tried any numeric system.

                                                                  1. 1

                                                                    I recently had the same idea about a link shortener and so I made one! It doesn’t have much in the way of documentation but it was literally a two hour project and it’s only 50 lines of Go so I think you should be able to get it running really quickly. It uses autoincrementing numbers so the links are always very short and easy to write down (also spell out to someone, remember etc.) I hope you find it useful! Here’s the repo: https://github.com/k2l8m11n2/s

                                                                    1. 1

                                                                      That’s nice ! What kind of input method do you use? Sending HTTP request via a web interface or CLI? I will definitely look at it longer, thanks!

                                                                      1. 1

                                                                        The interface is the simplest one I could think of: you GET (or just enter in your browser) https://shortener.example.com/https://some-cool-link.example.net/fun-link-stuff and you get back a number (starting with 1) that you use like so: https://shortener.example.com/1 which redirects you to https://some-cool-link.example.net/fun-link-stuff! I hope this example was clear enough, feel free to ask if you have any questions.

                                                                  2. 4

                                                                    If you like hefty metal pens, but European ones, I cannot recommend enough Caran d’Ache: https://www.carandache.com/us/en/ballpoint-pen/849-popline-metallic-black-ballpoint-pen-with-holder-p-10214.htm

                                                                    This kind of pen can go a long way.

                                                                    1. 6

                                                                      So once upon a time I spoke French reasonably well and I was trying to translate “Caran d’Ache” and now I have a headache. Turns out it’s actually a French-ish spelling of a Russian version of a Turkish word.

                                                                      1. 4

                                                                        Yes! Even for native French speakers, it feels very French, except Caran doesn’t mean anything (Ache could be a city or whatever).

                                                                        Fore those wondering the meaning:

                                                                        Caran d’Ache means pencil in Russian and has its roots in the Turkish word “kara-tash” which means black stone, in reference to graphite.

                                                                        https://www.carandache.com/us/en/content/ch/fr/la_maison/landing/la_maison_-_histoire.cfm

                                                                        1. 7

                                                                          Caran d’Ache means pencil in Russian and has its roots in the Turkish word “kara-tash” which means black stone, in reference to graphite.

                                                                          Interestingly, I come from a country where fountain pen are mandatory in school. We speak arabic, and everyone called the fountain pen “cartouch”, which means bullet or cartridge. It’s also funny because the cartridge really looks like a bullet. There’s also a close relation with lead. I thought it was an anglicism but now I’m learning it might actually comes from the ottoman era.
                                                                          Language is fun.

                                                                          1. 1

                                                                            Interestingly enough, in French cartridge is also called “cartouche” which is very similar!

                                                                            I’ve tried to find more on the source of the work, but the best I could find was:

                                                                            Borrowed from Italian cartuccia, a diminutive of carta, from Latin charta, from Ancient Greek χάρτης (khártēs) — https://en.wiktionary.org/wiki/cartouche

                                                                            Which is related to the paper that was used for cartridges (in firearms).

                                                                            I wonder what’s the link with pens beside the ink cartridge…

                                                                          2. 2

                                                                            A “Crayon of ash” perhaps?

                                                                          3. 2

                                                                            Oh, right. Карандаш. But it means pencil, so it’s a little bit weird. Does French pronunciation has anything to do with the Russian one? :D

                                                                            1. 2

                                                                              I decided to leam the Cyrillic alphabet a while back because I noticed there are a lot of shared/borrowed French words in Russian and I was going on a visit to Russia. It was really handy. I know a little French, and no Russian, but I could actually read a lot of words on signs. I got the notion from ресторан = restaurant.

                                                                        2. 4

                                                                          I like rotring pens.

                                                                          1. 1

                                                                            Have you ever had a problem with them leaking? My partner uses those, as the line quality is beautiful but after a while, every one she has had has started to leak and needs to be cleaned out.

                                                                            1. 1

                                                                              No, I haven’t had trouble with mine leaking. I mostly use the ball point pen though. Nothing fancy.

                                                                          2. 3

                                                                            In some previous variant of a similar thread, one fellow lobster got me addicted to discbound notebooks [1] [2] [3]. I heartily recommend checking them out for anyone using paper for work notes. They’re an absolutely ingenious invention, I’m surprised they’re not better known and more popular. I mean, I don’t guarantee they’ll fix all your life problems and smooth your wrinkles, but they have many benefits with not many flaws, and I think everyone should know they exist, so that they can choose them as a tool at will.

                                                                            1. 1

                                                                              What type of paper do you use? Ruled? Grid? Some of my physicist coworkers use a dotted grid-style that I’ve been thinking of trying out

                                                                              1. 4

                                                                                I use a dot-grid notebook for a daily bullet journal and all my notes. I can’t go without some horizontal true north or else I start to slant everything downwards, haha. I recommend the Leuchtturm1917 or the Rhodia Dot Web notebooks if you’re curious.

                                                                                1. 1

                                                                                  I’ve been using ruled Moleskine notebooks also with my variant of bullet journal. I also have the same slanting problem, but I think dots would be sufficient. I’ll check those out, thanks!

                                                                                  1. 2

                                                                                    I found out that dotted paper is the more versatile and my newer notebooks all have some. For example, I can easily draw a chess board when I am working on my chess or write straight or diagram almost properly without any rulers when needed.

                                                                                    I have some grieves with the quality of paper is my moleskine that vary so much between notebooks especially with foutain pen ink. Some bleeds too easily, some feathers ans some are perfect with the same ink, foutain pen and nib.

                                                                                2. 2

                                                                                  I prefer lined since I write more than I draw and I’m not good at writing on unruled or dotted paper.

                                                                              1. 2

                                                                                Let’s not get ahead of ourselves. I’m not aware of any EFI implementation that contains a mail client.

                                                                                1. 4

                                                                                  I’m now waiting for someone to say “challenge accepted”…

                                                                                1. 3

                                                                                  I wonder how to take the article. Leaving out forward slashes seems like the kind of decision you could have made at the time.

                                                                                  However, I’m tempted to say that a lot more things in the scheme that are unnecessary today. Including the scheme makes sense if you’re using some kind of client that connects to servers using a wide variety of clients. But that’s not the case any more. You’re overwhelmingly using a browser that connects to things over https. Similarly, the idea of www.example.com denoting something different from example.com seems like a shibboleth for old timers. I’m aware that you can treat them differently, but it’s not clear why you’d want to foist that complexity onto end-users.

                                                                                  I don’t dispute that this perspective would’ve seemed absurd in 1989. That’s why I don’t know how to take it–is Lee just describing the things that could’ve been identified as mistakes at the time, or does he think the forward slashes are the only thing about the scheme that was unnecessary?

                                                                                  1. 5

                                                                                    Users can just type host name and path into a browser, and it works, so the end-user problem no longer exists. Browser address bars don’t accept URLs, but an undefined, constantly changing heuristic syntax. They can even automatically derive a search URL from what’s entered. But there are certainly non-HTTP URLs in common use, like file:, mailto:, and lots of custom schemes used for “deep linking” on mobile platforms, so the full URL syntax is still very much alive and useful.

                                                                                    1. 2

                                                                                      Keep in mind that it wasn’t obvious how the internet would take shape. The idea that everyone would be using browsers, or their phones, was far from inevitable. It could just as easily have been, for example, that the “protocol” would have ended up as the signifier for the app to use, and therefor not redundant (like file extensions).

                                                                                      But I agree that the // has no real utility, and could have been easily avoided.

                                                                                      1. 1

                                                                                        Agreed. I tried to say that the idea probably made sense at the time. Working with a scheme so that one client could access things via multiple protocols was logical when HTTP was just a budding idea. It’s just that today, browsers exist, HTTP itself has become more complex, and so dedicated tools that don’t need a scheme are the norm.

                                                                                    1. 8

                                                                                      This reinforces my somewhat unpopular opinion that, despite the common ideology, open source is good for developers, and irrelevant or sometimes even harmful to users. The “user benefits” of open source are only obtainable through the work of developers. Users can’t contribute source (by definition: that’s what I mean by “user”) so they are in the same powerless position whether the software is open or closed source. The difference is just what developers the users get to deal with. Do they work for an old school proprietary software company so you get a binary every year? Are they independent guns for hire who will plug together your solution from open source components for cheap? Are they, as in this case, a messy battlespace of good guys versus jerks, with the jerks winning because the users really don’t care where the software comes from?

                                                                                      Where the users are developers, as in so many common success stories for open source (editors, compilers, operating systems, databases…) it works pretty well. Otherwise, there’s a chasm that’s hard to bridge.

                                                                                      1. 2

                                                                                        Users can’t contribute source (by definition: that’s what I mean by “user”) so they are in the same powerless position whether the software is open or closed source

                                                                                        (I will rather talk about free software than open source, but in this particular case, it is interchangeable)

                                                                                        Even if the users do not understand the source code and are unable to read or write it themselves, they benefit from the free software. If the software is free, they always have the opportunity to ask someone else than the original author to improve/modify the software. This is not possible with proprietary software. The users might chose anyone on the market, the best opportunity, to provide the service (either paid or for free). Yes, sometimes you have to pay for someone’s else work, but it is normal – you can not (ethically) force other people to do what you want for free. In case of proprietary software, the original author has monopoly to do changes in the code. In case of free software, anyone can do it (either personally or ask or pay someone else to do it).

                                                                                        1. 2

                                                                                          If the software is free, they always have the opportunity to ask someone else than the original author to improve/modify the software. This is not possible with proprietary software. The users might chose anyone on the market, the best opportunity, to provide the service (either paid or for free). Yes, sometimes you have to pay for someone’s else work, but it is normal – you can not (ethically) force other people to do what you want for free.

                                                                                          It sounds like this was more or less the dynamic going on with the third-party builds talked about in this article - the core Citra developers cared about keeping a clean git history and a maintainable codebase, which traded off against feature and performance velocity. So third parties forked the Citra codebase and threw together something messy but functional, in a way that solved at least some users’ problems better than the official fork: “Users trusted these builds that violated Citra’s license over Citra’s core development team.” Of course it’s problematic that these third parties violated Citra’s license (which looks like the GPL v2) by not releasing their own source code, and there’s nothing wrong with demanding that those third-parties do so. But assuming they were adhering to the terms of the GPLv2, being able to fork code like this to do something different than what the original developers wanted is part of the point of free software to begin with.

                                                                                          1. 2

                                                                                            Which is part of my point: If you believe the author, the third parties didn’t solve the problems, they just misled the users with “fake news” and derailed the project overall. In which case this is an example of open source allowing “bad developers” to take over the product process and harm users.

                                                                                          2. 1

                                                                                            This is where my formulation is unclear, but I’ll try to improve. The user always has to get help from a developer to implement what they need — regardless of whether the developer is proprietary, freelance, or the user’s own employee — that’s why I say users are powerless without developers. That fact is independent of whether the software is open source or not. Open source just allows a larger choice of developers; it doesn’t inherently make the relationship between users and developers better. In fact, it arguably makes it worse because it tends to subvert the standard ways users have convince developers to meet their needs (i.e., giving them money).

                                                                                            In other words, users don’t benefit directly from the source being open, and they may benefit from having a larger range of developer options. But in the case where the users aren’t themselves developers, I see a much weaker story for why that’s a net positive benefit.

                                                                                        1. 18

                                                                                          I have nothing but admiration for your work and the dedication it took to educate yourself well enough to produce what is apparently a good working crypto library. I also think you are literally one in a million for not only being able to do that, but investing the time and effort to actually do it. You are nowhere near the target for the advice to not roll your own crypto.

                                                                                          In other words, replacing the advice “don’t roll your own crypto“ with “don’t roll your own crypto unless you can spend years learning how to do it properly” is not a significant change to the advice.

                                                                                          Not to mention that even if you do know what you’re doing, at any moment you might find out you don’t know what you’re doing. Remember when everyone seemed to suddenly realize constant timing was important? Cryptography is a continuous study, not like a data structure you learn once.

                                                                                          1. 10

                                                                                            One fear I have is that some people might be discouraged to even start because of the negativity. Though my bigger fear is that the wrong kind of people end up charging ahead.

                                                                                            1. 11

                                                                                              I’m just not sure discouraging people is a bad thing. Cryptographic code is extremely unusual, perhaps even unique, in that it can fail catastrophically and silently, years after a perfect test suite passes perfectly. The gap between amateur and professional quality is huge, yet nearly invisible by normal code quality standards. Even the normal tools don’t work: I mean, have you ever seen a unit test framework that automatically tests timing attacks in addition to inputs and outputs? So if you’re going to propagate a one-liner meme about “rolling your own”, there are very good reasons to make it a discouraging one.

                                                                                              1. 3

                                                                                                How you discourage people is important in my opinion. One way to do it is to show the gap between casual and professional. Takes more than a one liner, though.

                                                                                            2. 5

                                                                                              suddenly realize constant timing was important?

                                                                                              Suddenly? There were papers at least as early as 1996 (Kocher’s Timing Attacks on Implementations of Diffie-Hellman, RSA, DSS, and Other Systems that appeared in CRYPTO 1996). AES was standardized in 2001. The writing was on the wall if anyone had cared to look.

                                                                                              1. 11

                                                                                                That’s why I said people “suddenly realized it was important”, not “it was suddenly important”. It was always important, but the news seemed to take a while to reach a lot of implementors who had thought they knew what they were doing (and probably continued to think that).

                                                                                                1. 7

                                                                                                  Yep. As late as 2017 (maybe later, that was when I checked), the most popular Java bcrypt library did not compare the hash in constant time when verifying passwords.

                                                                                            1. 4

                                                                                              There is nothing stopping you from doing the same thing and running Emacs as a launchd service for those who still want the Mac but also a persistent emacs server in the background.

                                                                                              1. 3

                                                                                                Yeah, you can do it, but using the client is not as convenient - e.g. you need to use Automator to create some wrapper around emacsclient -c so you can invoke this from Spotlight. (https://stackoverflow.com/questions/39464975/launch-emacsclient-with-gui-from-dock-on-mac-os-x) And coming from Linux launchd is not the most appealing service manager. :-) This is one area where there’s plenty of room for improvement in macOS.

                                                                                                1. 4

                                                                                                  This is probably Stockholm Syndrome from my days on the farm, but I always really liked launchd.

                                                                                                  1. 1

                                                                                                    Managing launchd with Nix is a breeze.

                                                                                                  2. 3

                                                                                                    Homebrew includes the launchd definition (brew services launch emacs). Invaluable for Spacemacs.

                                                                                                  1. 7

                                                                                                    I’m not sure there is a good reason for doing this:

                                                                                                    1. If you are in the archiving business, use the most common technologies that may have the chance to still be there in 100 years.
                                                                                                    2. The efficiency loss compared to Base64 is negligible, and it has fewer problems than this Base68 encoding.
                                                                                                    3. Base62 would be preferable from a user-friendliness perspective, but see point 1.
                                                                                                    1. 1

                                                                                                      Interesting. I had not really seen a formal definition of Base62 before. I have now seen a couple which seem to suggest A-Z a-z and 0-9 as the alphabet. I think that has some nice properties, but it also has some human down-sides too, e.g. vowels and letters/numbers which look similar to each other.

                                                                                                      I do agree that using the most common technologies is good practice. I wrote the article more as a thought experiment to see how far I could push the encoding.

                                                                                                      1. 3

                                                                                                        If processing by humans is in scope, take a look at Crockford Base32, which allows for ambiguous characters and case-insensitivity.

                                                                                                        1. 2

                                                                                                          If you’re worried about vowels/lookalikes, take a look at base58

                                                                                                      1. 28

                                                                                                        There’s a huge funnel problem for computer science at the moment. Go and Rust have some pretty serious evangelical marketing teams, but they are a drop in the ocean compared to the emergent ultramarketing behemoth that feeds JavaScript to the new developer.

                                                                                                        Part of this is that JS is constantly “new and modern” – with the implication that it’s a bandwagon that you’ll be safe on, unlike some of the old cobwebbed bandwagons. Constant change and “improvement” is itself a safety generator.

                                                                                                        Another part is that it’s so easy to get to hello, webpage. The sweet spot on the racket is enormous. Every computer including your phone comes with at least 1 and usually several JS interpreters. Frictionlessness drives adoption.

                                                                                                        The problem is that JS is, violently, garbage for most purposes. It’s a local maxima that has essentially everyone trapped, including the next generation. It’s not clear how we escape from this one.

                                                                                                        1. 17

                                                                                                          I feel about JS similarly to the way I felt about the x86 ISA taking over the world. “A local maxima that has everyone trapped”, that caused billions of dollars of R&D to be diverted into clever hardware, code generation, psychological treatment for programmers, etc. (I think the last thing is a joke, but I’m not sure.) One could even draw a parallel between the modern “micro-op” architectural approach to bypassing literal x86 in hardware and the WASM approach to bypassing literal JS in the browser.

                                                                                                          1. 12

                                                                                                            The longer it goes, the more this talk gets correctly.

                                                                                                            1. 1

                                                                                                              I’m not sure any other ISA would have been better than x86 at the time x86 began to take off. Lots of companies were trying lots of things in the RISC world, and plenty of money was being spent on RISC hardware and compilers, and the x86 still began to take off. Intel had a lot of money? IBM had a lot of money, and IBM was working on RISC. HP had a lot of money, and HP was working on RISC. And so on.

                                                                                                              1. 2

                                                                                                                Of the obvious choices available at the time x86 began to take off (1984ish), I would say the 680x0 was a better choice, demonstrated by watching the parallel evolution of the two. At least the extensions to 32-bit and virtual memory seemed a lot more straightforward on the 68k. They both would have run out of steam and gotten weird by now, but I feel like it would have been less weird.

                                                                                                            2. 2

                                                                                                              It’s not clear how we escape from this one.

                                                                                                              Simply wait. There are some better tools out there (for some value of the objective function “better.”)

                                                                                                              We’ve moved on from C, C++ and Java, all of which have had a similar level of death grip. JS is not invincible. The more users it attains, the more it suffers problems of perception due to the wide variance of quality. This gives rise to new opportunities.

                                                                                                              Really, I get a bit disappointed that everyone is content to rewrite everything every seven years, but, hey, it’s their life.

                                                                                                              1. 0

                                                                                                                I take strong offense at this proclamation of JavaScript as garbage. What kind of an opinion is that? If you don’t know JavaScript, don’t call out garbage. If you do know if well, you’ll see that it isn’t any more garbage then any other modern language for most purposes for which it is used - at least on backend.

                                                                                                                The entire ecosystem has some issues, but every ecosystem does. And considering that node was created only a decade ago and has vastly more users then some “serious” things that exist for ages, it’s obvious that there’s something that it’s going correctly.

                                                                                                                1. 29

                                                                                                                  I take strong offense at this proclamation of JavaScript as garbage.

                                                                                                                  You are offended on behalf of Javascript? People can dislike things that you like. It doesn’t do anything.

                                                                                                                  1. 4

                                                                                                                    Okay, inprecise choice of words on my part. I’ve wanted to state that I strongly disagree with his statement, english isn’t my first language and so I didn’t think every word completely through. I think you can still get the message. Be flexible a bit and you’ll understand it.

                                                                                                                    1. 8

                                                                                                                      I’m not sure what other languages you know, but compared to most popular languages:

                                                                                                                      • Javascript has a weird type-system that doesn’t really pay off. Sure, they added inheritance recently (welcome to the 80s), but there are all kinds of inconvenient relics like having to do Object.keys(x) when in Python you can just do x.keys() (as in most popular languages)

                                                                                                                      • Javascript makes it much harder to catch errors. Its implicit typecasting (undefined+“1”==“undefined1”, really??) and misuse of exceptions in the API means that when something goes wrong, you’ll often find out a few functions later, and then struggle to zero-in on the actual problem.

                                                                                                                      • The ecosystem is too fractured. The lack of a curated “standard library” sends novices into all sorts hacky solutions, and makes other people’s code less familiar.

                                                                                                                      I could really go on for a long while, and there are tons of example that I could give. I can say positive things too, like it has a good JIT, lots of interesting libraries, and some nifty syntax features (while lacking others), but overall think it’s a really bad language, that just happened to be in the right place and in the right time.

                                                                                                                      1. 1

                                                                                                                        For the record, JavaScript has always had inheritance, it just hasn’t had a class syntactical sugar that made it trivial to use until ES6.

                                                                                                                        1. 1

                                                                                                                          I wouldn’t call it bad. It just has bad parts. The == operator you mentioned is a trap for many beginners. On the other hand, there’s no inheritance problem because the inheritance was always there - you just have to know how prototypes work. The type system without extra tools and some practice is a pain. Yet the closure or say prototypical inheritance and composability you get is great.

                                                                                                                          JavaScript got really lousy reputation because unlike, say, C++ or Java, everybody wrote it, not just people who studied software engineering for five years and know how to use tools, have structure and not break the rules.

                                                                                                                          And it’s keeping the lousy reputation because it is still being done - randos adding jquery plugins for perfectly css-able animations even today.

                                                                                                                          Plus it’s got 25 years of backwards compatibility to maintain, so those bad parts never leave. Yes, it has been at the right place at the right time - but many others have tried and are still trying.

                                                                                                                          But despite all the bad parts and lack of standards, it’s still immensely flexible and productive and for a lot of use cases actually provides the best concepts to do them. Could you put something like elixir in a browser engine? Or java? Or Rust? Probably. Would it be better? Maybe, but I suspect not by much.

                                                                                                                          I don’t know, I’m probably not seeing it. I’m not claiming that it’s a great language or that it’s even good for everything and everyone. But people only see the ads and single page apps where they don’t belong or where they simply don’t like it, and ignore a lot of directness that the language provides, look down on flexibility, and don’t allow the little language that could its deserved praise (where it does deserve it).

                                                                                                                          Once again, as I’ve said in another comment - I don’t claim it’s the best language ever. I’m just saying it is not garbage. These days the tooling and the entire ecosystem is mature and there are no more language issues in writing a typical NodeJS application then in most other similar languages.

                                                                                                                          1. 1

                                                                                                                            Javascript has a weird type-system that doesn’t really pay off. Sure, they added inheritance recently (welcome to the 80s)

                                                                                                                            It added inheritance as a sop to people who didn’t know composition and refused to learn. Are you not satisfied with that? Does it have to become a pure Smalltalk clone for you? Composition is more powerful but it’s less familiar. Now JS has easy ways to do both.

                                                                                                                      2. 24

                                                                                                                        I have a deep understanding of JavaScript; I promise that my opinion is rooted in experience.

                                                                                                                        1. 6

                                                                                                                          Even though you personally find Node impressive, there might be people who don’t get impressed by languages (or any software really).

                                                                                                                          Being impressed or having respect (for a software) makes no sense. It is just a tool that should be used or discarded at will. Not a cultural icon.

                                                                                                                          If you do know if well, you’ll see that it isn’t any more garbage then any other modern language for most purposes for which it is used - at least on backend.

                                                                                                                          You have stated no arguments that support your conclusion. I believe that the jury is still out on the matter of language effect on productivity. All the studies I know of were totally botched.

                                                                                                                          Anecdotally, I have seen more poor Node backends than Python ones. I have also seen less high quality Haskell backends, which confuses me greatly. Still, I wouldn’t go as far as to conclude that everything is the same crap.

                                                                                                                          1. 6

                                                                                                                            Denying the role of aesthetic judgement in programming is madness.

                                                                                                                            1. 1

                                                                                                                              I didn’t state I find Node impressive. I do love it for the productivity it brings to me. And that is just the point of my reply. The guy claimed JavaScript is garbage, also without arguments. I’ve just pointed out that. No more garbage then any other language, in my opinion. If anybody brings arguments into this whole discussion, including the original post of the thread that claims people are pushing node, we can talk about with arguments. Otherwise we’re all just giving opinions and estimations.

                                                                                                                              Anecdotally I’m seeing much more crappy Java Enterprise and Spring backend code lately then node. Likely because I work at a java shop now. But I don’t claim that people are pushing Java exclusively for backend (even though they do at my company, we literally have 100% Java in my 800 people department), nor do I claim Java is garbage.

                                                                                                                              I hope that clarifies my objection to the claim of garbageness.

                                                                                                                              1. 4

                                                                                                                                I think you are right that JavaScript brings great initial productivity. Especially in the single developer case. For many simple tasks, it is easy to use node, easy to use npm, and easy to deploy code. Where I have seen problems that I know are avoidable in other languages is in its long term sustenance and operation, which are vitally important parts of software engineering.

                                                                                                                                Other languages have, for example, highly vetted and deep standard libraries of functions which are included in the system and move very slowly, which eliminates large classes of dependency management issues. Or, they have good type systems, which helps prevent common problems, especially in dynamic languages. Or they have exceptional tooling that enforces good practices. Or they are especially operable in production, with good intrinsic performance or observability characteristics.

                                                                                                                                But the most important thing, to me, is that most other languages have a culture of remembering, but this is distinctly lacking in JavaScript. I attribute this to many JavaScript programmers starting from scratch in their software career inside JavaScript, and not having broader exposure to the vast surface of other kinds of software. And I attribute it also to the “stack overflow” method of programming, in which rather than engineer your software, you assemble it from the guesses of others, losing fidelity and getting more blurry with each iteration.

                                                                                                                                It could sound like I’m being a pretentious jerk. I’ll confess to that. But having been a professional software engineer for now 32 years, and having seen probably a hundred languages and environments, the current JavaScript one is my least favorite. I appreciate that it’s one that you have significant personal investment in, but I would also encourage you to step out and up, and look around.

                                                                                                                                1. 1

                                                                                                                                  Thanks, this also raises some quite relevant concerns. And I agree with these things. And now I have to fall back to the fact that despite these problems, it’s not garbage. I did step out and I try other languages and their frameworks, but I’m simply personally the most productive with it. And when I worked in teams where Node was used on the backend, the teams were professionals and mostly didn’t have problems with the language itself - maybe more or less then if it was done in, say, Spring or Rails, but I would say the typical problems are always stupid things like commas in the database where they break serialization somehow.

                                                                                                                                  And that is the point of my original comment. Which was that I object to the claim that JavaScript is garbage. Maybe a lot of garbage is written in JavaScript today, but it in itself is not that, and can provide perfectly productive envrionment for doing our jobs.

                                                                                                                            2. 6

                                                                                                                              I wouldn’t call JavaScript “garbage” myself, but it sure has some problems that few other languages have. [1] + [2] resulting in "12" being a simple example. JavaScript definitely took the 90s/00s vogue of “all things should be dynamic!” more than a few steps too far.

                                                                                                                              considering that node was created only a decade ago and has vastly more users then some “serious” things that exist for ages, it’s obvious that there’s something that it’s going correctly.

                                                                                                                              Well, just because it’s popular doesn’t mean it’s good ;-)

                                                                                                                              I notice myself that I often use tools that I know, even when it’s not necessarily the best fit, simply because it’s so much easier. Yesterday I wrote some Ruby code for a Jekyll plugin and had to look up a lot of basic stuff and made a few simple mistakes along the way; there was quite a lot of overhead here. And I programmed Ruby for a living for 2 years (but that was 5 years ago, and looks like I have forgotten much).

                                                                                                                              JavaScript is rather unique in the sense that almost everyone has to deal with it because it’s the only language supported by browsers[1], so there are a lot of people familiar with JS who would rather like to use it in other scenarios as well: not necessarily because it’s the “best”, but because it’s just easier as they won’t have to re-learn a whole bunch of stuff.

                                                                                                                              That’s not necessarily a bad thing, by the way; I’m all for giving people the tools to Get Shit Done. My point is merely that much of NodeJS’s popularity probably stems from factors other than intrinsic qualities of the language, runtime, and/or ecosystem.

                                                                                                                              [1]: Ignoring wasm, which isn’t quite ready for production-use, and “X-to-JS” compilers, which typically still require knowledge of JS.

                                                                                                                              1. 1

                                                                                                                                Oh, I wasn’t claiming that the popularity of NodeJS comes from it’s quality. I’m just saying JavaScript is not garbage, which the commenter claimed without argumenting it.

                                                                                                                                I mean, I know that [1] + [2] is “12” in JavaScript. But if you ask me how many times I’ve had a problem because of that in the last year, I would possibly be mistaken, but I would say 0 times.

                                                                                                                                Again, it’s not the best language and it has its problems. But it’s not garbage.

                                                                                                                                1. 2

                                                                                                                                  I mean, I know that [1] + [2] is “12” in JavaScript. But if you ask me how many times I’ve had a problem because of that in the last year, I would possibly be mistaken, but I would say 0 times.

                                                                                                                                  I find this interesting, because a few comments upwards, you state this:

                                                                                                                                  The typical problems are always stupid things like commas in the database where they break serialization somehow.

                                                                                                                                  It might just be me, but in no other language have I ever heard of specifically this problem. If you dig a little deeper, you’ll notice that there are a few fundamental issues in the language. But definitely the most prominent root issue is that types are treated extremely loosely, which causes all sorts of offshoot problems, like the two above.

                                                                                                                                  I always try to think a bit more holistically about this, and when you do, you start to see this pop up everywhere. Just yesterday I was debugging an issue with a colleague where he accidentally was throwing a JSON-encoded string at a program where in fact he should have been taking the JSON document, extract a specific key’s string value and send that to the program. Basically the same thing: it’s too easy to mix up types.

                                                                                                                                  I occasionally see this in Python as well: when you accidentally have a string instead of a list of strings; because of the “everything is a sequence” abstraction it’s too easy to mix things up, and you end up chasing down the rabbit hole before you figure out where it’s going wrong. It’s better if things error out early when you try to do something that makes no sense.

                                                                                                                                  Having type-specific operators makes it easier to get your bearings when reading unfamiliar code, too, in my experience.

                                                                                                                              2. 3

                                                                                                                                And considering that node was created only a decade ago and has vastly more users then some “serious” things that exist for ages, it’s obvious that there’s something that it’s going correctly.

                                                                                                                                No, it means JS has a powerful monopoly (the web) and thus commands a huge mindshare. Some subset of those people want to take their painstakingly earned experience to the server.

                                                                                                                                1. 0

                                                                                                                                  So, ‘heads I win, tails you lose’, eh? Good argument. /s

                                                                                                                              1. 3

                                                                                                                                I’m thinking back to all the arguments against Smalltalk I heard back in the 80’s and early 90’s, and now we’ve ended up drowning in…JavaScript? Worse really is better.

                                                                                                                                1. 1

                                                                                                                                  Yes. All the downsides, magnified, without any of the upsides.

                                                                                                                                  Similar to the way people tried to use Objective-C as a pure OOPL, which is significantly slower than even a half-decent Smalltalk, except less expressive, less interactive and more crashy.

                                                                                                                                  And of course Swift manages to be even slower than Objective-C, and you get even less interactivity and expressiveness. Progress!

                                                                                                                                  1. 6

                                                                                                                                    Similar to the way people tried to use Objective-C as a pure OOPL, which is significantly slower than even a half-decent Smalltalk, except less expressive, less interactive and more crashy

                                                                                                                                    An Objective-C program written in a purely Smalltalk style will be slower than the equivalent written in something like Anamorphic Smalltalk (though still noticeably faster than something like Squeak), but that isn’t what happens. Even programs that are mostly high-level OO things written in Objective-C are using classes that wrap carefully optimised C/C++ libraries. A typical Mac application spends the vast majority of its time in things like the font and graphics rendering engines, which are C.

                                                                                                                                    I’ve written about this before, but I still believe that the thing that killed Smalltalk was the lack of a good way of interworking with non-Smalltalk code. A lot of core bits of Smalltalk were built around the image model, but this did not work with stateful non-Smalltalk libraries. Smalltalk never had a good abstract machine for reconciling the Smalltalk image view of the world with the C process view of the world and supporting both together. With Etoile, we tried to build an object persistence model that gave the advantages of the Smalltalk image model, but played nicely with C. If Smalltalk had gone in that direction in the early ’90s, it might still be a big player today.

                                                                                                                                    1. 2

                                                                                                                                      Yeah, absolutely agree on interop issue: image, own-world, vm, gc, thread-of-control. Basically an architectural mismatch checklist. :-) Which is why Objective-Smalltalk is also built on top of the ObjC runtime.

                                                                                                                                      However, pure OO Objective-C can easily be slower even than byte-code interpreted Squeak (so pre-JIT), and yes, I measured. And of course a Smalltalk, and particularly Squeak, will also spend a lot of its time in primitives or plugins that do the heavy lifting.

                                                                                                                                      Good Objective-C code doesn’t do that, of course, and can reach just about any performance level you wish that the machine can provide, while typically maintaining good abstraction levels.

                                                                                                                                1. 8

                                                                                                                                  Bell Labs has been merged into Nokia, I wonder if there are any p9 devs left there.

                                                                                                                                  1. 13

                                                                                                                                    None that I’m aware of.

                                                                                                                                    That said, 9front is still fairly active. Commits this year:

                                                                                                                                    cpu% hg log -d '2020-1-1 to 2020-05-11' | grep '^changeset:' | wc -l
                                                                                                                                    242
                                                                                                                                    

                                                                                                                                    And the last month:

                                                                                                                                    cpu% hg log -d '2020-04-11 to 2020-05-11' | grep '^changeset:' | wc -l
                                                                                                                                    88
                                                                                                                                    
                                                                                                                                    1. 5

                                                                                                                                      Could you imagine a Plan 9 Nokia phone?! Actually, I wonder how hard it would be to create a mobile version of Plan 9… the very opinionated GUI that insists on e.g. a middle mouse button doesn’t give me hope.

                                                                                                                                      1. 7

                                                                                                                                        If it hadn’t been a few years too early, Plan 9’s successor Inferno might have been a contender on phones.

                                                                                                                                          1. 8

                                                                                                                                            In addition to hellaphone, there are already people working on running Inferno on the PinePhone.

                                                                                                                                          2. 5

                                                                                                                                            There was an ipaq version[1]. It apparently used the side buttons for chording, and Plan 9 ships with an on-screen keyboard with hand writing recognition that was written as part of the port.

                                                                                                                                            That said, what exists is not a very good fit for modern touch UIs. The underlying GUI system should work fine, but /dev/gesture would need to be created (could be done easily as a userspace file server), and applications would need to be purpose-written or heavily modified.

                                                                                                                                            [1] ipaq: https://en.wikipedia.org/wiki/IPAQ#/media/File:PocketPC-HP-iPAQ-h2210.jpg

                                                                                                                                        1. 6

                                                                                                                                          Section 3 of this should be broken out and merged into the systemd man pages. I’ve never seen a clear description of what systemd actually does until now. This explains so much systemd behavior that I’ve just stared at in confusion before. Units are just a graph for generating jobs! I get it now!