1. 1

    I like the idea. No ligatures is a dealbreaker for me unfortunately.

    1. 1

      This is so cool! It’s something I’ve sort of for a while. An ecosystem around it, e.g. Comby, would be neat.

      1. 2

        what kind of ecosystem are you talking about? Premade queries or something?

      1. 5

        Similarly, I have a ~/.bash.local file which allows for machine-specific config (it’s .gitignored) and overrides by being sourced last: https://github.com/Pinjasaur/dotfiles/blob/193df781b46e1f7e7a556f386172b76f067adcd9/.bash_profile#L28-L32

        1. 2

          I have a slightly more complex setup. I put all of my bash config under ~/.config/bash, which is in a git repo. I have a helper function that sources files in the pattern ${XDG_CONFIG_HOME}/bash/$1/$2 and ${XDG_CONFIG_HOME}/bash/$1/$2.d/*. I call this function with hosts and the output from hostname and with systems and the output of uname. This lets me have either individual files or directories full of files inside ~/config/bash/hosts for individual machines and the same in systems for things that are for every machine I have with a specific OS (e.g. FreeBSD, Linux, macOS, with a special case in Linux that tries again with Linux-WSL if it detects that it’s running in WSL).

          This means all of my configs for all machines are in the same git repo and don’t get lost if anything happens to a particular machine.

          1. 2

            I also have a .aliases-local alongside local bash, and check for existence of both before sourcing in my dotfiled bashrc.

            1. 1

              Same!

              if test -e ~/local.sh
                source ~/local.sh
              end
              
            1. 4

              I strongly agree.

              Print debugging is awful for me, and it feels like Stockholm Syndrome. The debugging tools often either aren’t good enough, or are a pain to use. In saying that though, I think what may be more common is simply that programmers/engineers have spent the time to learn them (so they may not be as hard as feared), and print is bearable/good enough for what they’re doing.

              A comparison may be a REPL development loop, versus a slower compile, run, loop.

              1. 32

                In distributed systems printf debugging is your only option. “JuSt AtTaCh A dEbUgGeR” only works when you have the program running on your local development machine, frequently reality and facts will have you diagnosing faults on a machine running on the other side of the planet. Debuggers don’t really work there.

                1. 13

                  Erlang (and thus Elixir) have some nice debuggers where you can attach to remote nodes.

                  If you’re able to recompile/redeploy with print statements to your remote machines, surely you could enable debugging on an open port (depending on the language and/or frameworks)?

                  1. 8

                    The point is that in distributed systems when happens is more important than what happens.

                    If you step through the program manually you add delays that the program will just crash on, which is equivalent to doing a single print in a whole run.

                    If you think that playback debugging will save you then you’re only right in the case that the hidden state during execution is small enough to be practical to record. In data analysis the intermediate data is often many orders of magnitude larger than the input and the out put which makes playback debugging impossible on regular runs of the program.

                    The biggest advance in debugging in my career was when I started doing a s/print/log/g on the region I was working on once I found the bug and then putting it under debug level of logs.

                    1. 2

                      Distributed systems certainly introduce a lot of failure cases where a debugger won’t help you, but it doesn’t eliminate the cases where it could. I frequently find myself frustrated at the fact that the ability to attach a debugger remotely to a process seems to be considered an unnecessary extravagance in most environments, in light of the many cases I’ve experienced where it would have been a much faster way to solve the problem than using print statements. Obviously it requires a thoughtful security policy to be able to safely offer that as a feature, but I think it’s a worthwhile investment.

                    2. 3

                      BEAM debuggers are just dynamically added prints within running system, mostly beacause there is no other way to do so, as step-debugging makes no sense in such environment.

                      1. 3

                        Not when the machines belong to a customer and the problem only happens in production.

                        Or rather, the turnaround time and expense for getting that sort of access can be prohibitive compared to making them a custom build with extra logging.

                        Come to think of it, what’s the dividing line between printf-debugging and logging? I use the same API calls for both, and most of the printf-based debugging I do is by turning on extra layers of logging that are already in the code for this purpose.

                      2. 8

                        “JuSt AtTaCh A dEbUgGeR”

                        At the risk of going off-topic, what’s the meaning of that capitalization? It messed up the way my screen reader spoke that phrase.

                        1. 13

                          It communicates mocking sarcasm. Like you’re repeating what someone says in a goofy voice. It’s a somewhat-recent meme, I started seeing it around 2016.

                          1. 1

                            i often wonder what that “goofy voice” sounds like in other peoples’ heads. use of that spongebob-case kinda smacks of 1997 when people used the “R” word indiscriminately and mocked neuroatypical behavior/speech patterns.

                        2. 4

                          To be fair, he literally says that

                          There are many reasons why print debugging is still the best option for many developers. rr, Pernosco and similar tools can’t even be used at all in many contexts.

                          (And imho he doesn’t say it in a way that makes it sound like a superficial “why don’t you just..” comment at all).

                        1. 7

                          Many of the new concepts weren’t novel to Rust. But considering I’ve had exposure to many popular programming languages, the fact many were new to me means these aren’t common features in mainstream languages.

                          My takeaways from this is that:

                          • We need a better/different term for “mainstream languages” that includes the many languages that have those things
                          • Programmers really need to explore PLs a bit more
                          • “Mainstream languages” are really far behind and programmers are hamstringing themselves by sticking with them
                          1. 9

                            The whole blog is dedicated to bashing Proctorio, how weird

                            1. 17

                              Eh. It claims to be about “exam spyware analysis” and bashes the similarly named ProctorTrack too. I don’t find it too weird; if I were forced to use such software, I would probably inspect it and might go so far as to write a blog complaining about it, if reporting the problems I saw in other ways brought no joy.

                              1. 9

                                I am forced to use Moodle when I teach and I have definitely considered launching a novelty Twitter account just to bash the software. Not so much because I think it would matter, but because doing so might be cathartic… :-)

                                1. 4

                                  And Moodle while clumsy to death is one of the less bad of the bunch by my small experience.

                                2. 2

                                  How’s that weird?

                                  1. 4

                                    He (or she) created a blog just for bashing a single company. Even the domain is “proctor.ninja”. Maybe they are an employee, maybe they thinks Proctorio is the worst evil, and maybe it is, but they definetly has a grudge.

                                    1. 10

                                      Proctor io has a history of suing experts who critique their shady practices. I would probably attempt to remain incognito if I was making these claims as well

                                  2. 1

                                    There was an entire blog dedicated to how xkcd sucks. It seems like there are … several now. The original (with the hyphen) was hilarious.

                                    There’s also an entire mastodon instance dedicated to SalesForce fandom .. or at least it seems at first. It’s difficult to tell if they’re really fans, making fun of it ironically or a little of both.

                                    1. 1

                                      Wait until you find out about https://twitter.com/memenetes. They even sell merch about bashing Kubernetes! XD

                                    1. 111

                                      I tell anyone asking me for career advice the same two things.

                                      The first: the deeper in the world’s dependency tree you are, the less frequently things will churn, and the longer your skills will last. TCP doesn’t change very often. Theoretical skills may be applicable for your entire career. Human skills are more durable than any technical skill. Kernels don’t change very often (but more than TCP). Databases don’t change very often (but more than kernels). There is a spectrum of skill durability, and you will burn out faster if you find that all of your skills become worthless after a very short time. Dependency forces things not to change their interface, which causes the work to shift toward performance and reliability among other things that some people find far more rewarding over time.

                                      The second: the more people who do what you do, the worse you will be treated, the more BS you will have to put up with, the worse your pay will be, the faster you will be fired, the harder it will be to find a job that values you, etc… etc… Supply and demand applies to our labor market, and if you want to be happier, you should exploit this dynamic as heavily as possible. Avoid competition like the plague. But don’t avoid funding. How do you avoid competition without going off into the wilderness where there is no money to be made? Hype drives funding, but it also drives a lot of competition. However, using rule #1 above, the hyped things depend on other things. Many of these dependencies are viewed as “too hard” for one reason or another. That’s the best place to be. Go where other people are afraid, but nevertheless have a lot of money depending on.

                                      All hyped things rely on things that for one reason or another are not commonly understood, and tend not to change quickly. That’s a good place to find work involving durable skills that tend to have lower competition. Go where the dependency is high but the competition is low, and you have a better chance of being happy than people who go where the competition is high or the dependency is low. Bonus points if it’s actually “hard” because then you won’t get bored as quickly.

                                      There are areas of front-end that are high-dependency, durable, slow-changing, and low-competition. That’s where engineers are likely to be happiest. But these two principles apply to every field or zooming out to any business generally. I’m pretty happy working on new distributed systems and database storage engines for the time being. But I’m always looking for the things that are viewed as hard while also receiving significant investment, as these are the things that will ultimately give me more opportunities to live life on my own terms.

                                      1. 10

                                        Go where other people are afraid, but nevertheless have a lot of money depending on.

                                        There is an old Yorkshire saying: “where’s there’s muck, there’s brass”.

                                        1. 7

                                          This is so true, I’ve gone to my car to fetch my laptop just to upvote and comment. It’s an exceptionally important piece of advice I wish I had understood as early as possible in life, but I didn’t.

                                          CS (pure) and Math degrees are so good because they teach you really basic theories that are mostly timeless. Whenever I’ve gravitated towards more trendy or applied skills, either in coursework or in jobs, there’s always been a really poor and transient ROI.

                                          […] using rule #1 above, the hyped things depend on other things. Many of these dependencies are viewed as “too hard” for one reason or another. That’s the best place to be.

                                          What are some examples of these dependencies right now, or in the near future?

                                          1. 6

                                            Thank you very much for this post. Great distillation of essential career advice, especially the part about the durability of human skills. So many developers would derive far more value from a single public speaking or improv class than from learning yet another new programming language.

                                            1. 3

                                              Oh man, the number of times I’ve echoed this exact same message to others almost verbatim in the first two paragraphs. Thanks for posting this. Thinking about my career in this way a few years ago was probably the most valuable change I made.

                                              1. 4

                                                Thank you for the kind words :)

                                                Large-scale ML, blockchain, IoT, serverless, k8s, etc… are all areas recently flooded by newly minted experts in the topical skills, but like the Australian poop diver who claims to have never worked a day in his life, there are great opportunities for high-respect jobs in the dirty internals of the systems :) Particularly with this set of hyped tech, there are very few people who seem to specialize in getting bugs to jump out in distributed systems. Everybody is still writing almost all of them in a way that assumes the happy path. But there are techniques for building all of these systems in ways that encourage the race conditions to jump out. The few people who take pride in building correct distributed systems will have their plates full for a while!

                                                Another reason why this kind of bug hunting and prevention is not all that popular may be that the sorta-similar yet way-cooler-seeming field of systems security tends to absorb a lot of the people who may have otherwise been predisposed to this type of work.

                                              2. 2

                                                love this comment. like the other commenter, do you have any examples of “hard, but trendy” in frontend or elsewhere?

                                                1. 8

                                                  Spitballing, I’m going to google “hyped programming field” and see what comes up, then I’ll try to break it into areas for investigation. Ok, my results on the first page seemed to be about AI, python, golang. I mentioned high-scale ML depending on distributed systems skills and correctness skills above, so I’ll think about the others. Python feels harder for me to answer so let’s dig into that.

                                                  Python is immensely popular and I think that becoming an expert in alleviating any friction point that people often hit will be lucrative. But what about things that SOUND really boring? When I think about things that suck about Python, the most dreadful thing that comes to my mind is migrating large applications from Python 2 to Python 3. Python 2 stuff is still everywhere, and it’s increasingly hazardous over time because its support has run out. But people don’t want to touch things that are still ticking along. Legacy systems, like geriatric medical care, becomes more important every day.

                                                  But despite being extremely important and an excellent place to apply interesting mechanical (yet supervised) translation and correctness analysis during modernization, so many people have been burned by consent issues at work where their managers forced them to work on legacy despite them not wanting to work on them. So much of the overall programming population has been burned by non-consensual legacy engineering that almost everyone wants to stay as far away as possible. The only question is how to find the companies who realize that modernizing their legacy systems is actually something you want to pay a specialist to do instead of forcing the task on junior devs with no negotiating power. Banks are well-known for paying consultants for this kind of work, but to be honest I’m not sure.

                                                  Maybe Python 2 modernization isn’t exactly a golden ticket due to the difficulty in finding companies who are willing to hire specialists to perform this task. Maybe it’s too easy. But may it’s not. I’m not sure. In any case, this maybe demonstrates the general search technique, and can be used to illuminate further areas for research. If general Python 2 modernization is “too easy” then you can slap on more filters. Python 2 modernization for automotive codebases. That sounds much more correctness-critical and likely to pay a specialist to accomplish.

                                                  Anyway, the general pattern is: what feels repulsive and hard? Maybe that sense of repulsion creates a dynamic where the few people who do the thing are extremely well treated due to their scarcity. If that scarcity of talent aligns with an extremely popular overall field, there’s a good chance that there are folks who require a specialist to address this niche.

                                                  1. 6

                                                    Anyway, the general pattern is: what feels repulsive and hard? Maybe that sense of repulsion creates a dynamic where the few people who do the thing are extremely well treated due to their scarcity. If that scarcity of talent aligns with an extremely popular overall field, there’s a good chance that there are folks who require a specialist to address this niche.

                                                    Here’s an example of scarcity working out well for an expert. Another company in my industry was converting to a different accounting system. These projects are incredibly complex and can last years. Part of the process required recreating hundreds of templates for the new system. One contractor handled the template conversion; she retired at a young age after the project was complete.

                                                    1. 4

                                                      non-consensual legacy engineering

                                                      Have you written about this anywhere? I’d be curious to hear more about it. It immediately struck a chord with me, and probably does with most software engineers.

                                                1. 3

                                                  At my previous job I did everything (full-stack) and it progressively led to being primarily frontend (in Elm, at least). There wasn’t a path to what I wanted to work on (both tech and domain), which was one of the reasons I left.

                                                  When interviewing for my next job, I told everywhere that I did not want to work in anything frontend related. I’ve been asked I’d be willing to a minority split, but I knew that that promise wouldn’t be held. I’ve also had to prevent myself from thinking at my new place that I could quickly knock out a PR or too.

                                                  Anyway, just saying, you’re not alone.

                                                  1. 7

                                                    I just wanted to say that this article was well-written. I had been meaning to learn about Pijul and this was a good starting point.

                                                    Pedantic: I think there is a small typo where there should be a line-break before the pijul record command to separate it from pijul ls.

                                                    1. 4

                                                      Thx very much! It was very fun to learn about Pijul and work on the article, so glad it was useful. The typo should be fixed as well ;)

                                                    1. 28

                                                      The font looks really good, and has a lot of great features! But why the ligatures…

                                                      When I see the current state of coding fonts, and ligatures, I don’t know whether I’m the last of the Mohicans, or whether I’m just becoming an old man…

                                                      1. 12

                                                        You are not alone, but the zip file they have ha a “No ligatures” directory. At least for ttf.

                                                        1. 10

                                                          Why not? I really like those, it is appealing visually and permit to increase the readability at least for me. I use JB Mono most of the the time in my system so maybe I am more used to it but ligatures what a important point when choosing a font for me.

                                                          1. 11

                                                            I’m a vim user. Seeing a different representation than what I’m actually editing trips me up. I’ll often want to go to the equals sign in the != operator. When the ligature version of that operator is visible, I have to remember which characters it contains, and when I type “f=” to go to the character, the cursor is visually over the entire ligatured operator and I don’t trust that it’s actually over the second (invisible) character.

                                                            It’s not that big of a deal and I’m sure I could work past it, but it was enough for me to switch back.

                                                            1. 5

                                                              I am also a (n)vim user and this seemed weird for me so I tried with the JetBrains Mono font and ligatures. In the mini-buffer for search, /!= produces the ligature and when I search for the ligature, I land on the first character of the ligature, eg when I pressed x it remove the ! and keep the = in the text. So the cursor is never on the second, or more, character of the ligature. The ligature contains the exact characters you have typed and it is just a visual interpretation but will not appear with another font/software. And when typing f= to go the the character, it works (at least in my experience). For me a ligature, it is mostly eye-candy (but better readability too) for the set of characters that compose it. Mentally, I have the character set is my representation when searching/editing etc.

                                                              I understand how it can break your mental model and flow by creating some disruptive visual response between the character set behind the ligature and the visual response of the ligature being a character on its own. I like ligatures for that.

                                                              1. 5

                                                                the cursor is visually over the entire ligatured operator and I don’t trust that it’s actually over the second (invisible) character.

                                                                This sounds weird. I haven’t tried this font yet but I normally use Hasklig, which has similar ligatures (Think it’s Source Code Pro with added ligatures? Primary focus is on Haskell, but works well with other languages too). When the cursor is over either of the characters in the ligature, it doesn’t draw the ligature. I’m also using (n)vim, although it’s the terminal (usually konsole in my case) that’s actually drawing the ligatures. I don’t know whether the ligature breaking when under the cursor is an intentional thing or just a side effect of the cursor being there. From looking at the JetBrains mono samples, I think Hasklig’s ligatures are a lot more conservative: for example, it will render ‘/=’ (haskell’s not-equals operator) as a double-width ≠, but it won’t change != to anything, so I think Hasklig’s ligatures always look like a tidier combination of the individual characters, not a completely different character.

                                                                1. 1

                                                                  the cursor is visually over the entire ligatured operator and I don’t trust that it’s actually over the second (invisible) character

                                                                  I use vim with Fira Code with ligatures enabled, and this does not match my experience. When the cursor is over the ligatured characters, on my systems, they are displayed as separate characters. Maybe JetBrains Mono is different though?

                                                                  I do still have to remember what characters make up the ligature in order to navigate directly to one of them, but 30 years of muscle memory take care of that for me.

                                                                  1. 1

                                                                    A few people mentioned that this doesn’t happen with their setups. I don’t know whether it’s vim or the terminal that renders the ligatures. I don’t have a ligature font installed anymore. I tried it on a previous computer. It sounds like with an updated vim/font/terminal/something then the problem is avoidable. I still think I’d run into similar versions of the issue: having to mentally remove the visual abstraction to reference the underlying text. In the end I don’t think I’ll go back to it since it doesn’t feel more readable to me regardless.

                                                                    I just wanted to offer a more concrete reason for why I stopped since the OP was asking.

                                                              2. 4

                                                                The difference between =, == and === is like trying to indentify the differences in a hyphen, en dash and em dash. Not a fan.

                                                                1. 3

                                                                  === generally has three lines and looks like ≡≡≡. = and == are easier to tell apart because of their length.

                                                                2. 4

                                                                  There’s a ligature free version thankfully. Can’t wait for windows terminal to give you a no ligatures switch. I don’t like the way they look and I don’t want my font to lie to me.

                                                                  1. 3

                                                                    I’m with you. Personally, I do not see the point of not seeing the real characters that make up your code. But that must be the way my brain works.

                                                                    1. 4

                                                                      I am Chingachgook, and I support this message. As we say in my language, “ligatures are hella wack, yo.”

                                                                      1. 2

                                                                        One of the reasons I use this font is because of the ligatures. For me it increases readability and also just looks nice.

                                                                        1. 2

                                                                          I use it as my main font (terminal, including nvim; and as the mono font in firefox), but without ligatures. It’s just not a problem if you don’t like them :-) Otherwise it looks just great.

                                                                          1. 1

                                                                            I’m with you, here. But then I also tend to find “fi”-ligatures in English text jarring on occasion. Worst is when those show up in preformatted text.

                                                                          1. 8

                                                                            Using a notebook, and writing out what I’ve tried so far by hand.

                                                                            The number of circles I can drive myself in without self reflection far outweigh any amazing gdb tricks I can paste here.

                                                                            1. 1

                                                                              +1 to that. I treat it as some sort of scientific notebook and write down my hypotheses, experiments, results, etc.

                                                                            1. 1

                                                                              This was really interesting, and well put together. I’ve thought too for a while that we still have very rudimentary tools as software engineers.

                                                                              1. 1

                                                                                Thank you for sharing this. It works perfectly for me.

                                                                                1. 2

                                                                                  Is there a concept of jails in Nix(OS)? Or is it somehow not as relevant?

                                                                                  1. 3

                                                                                    You can declare a list of docker containers to run: https://nixos.wiki/wiki/NixOS_Containers

                                                                                    If you want the tight integrations, NixOS does have native support for running containers: https://nixos.org/nixos/manual/#ch-containers

                                                                                  1. 1

                                                                                    Are there some release notes or a changelog available?

                                                                                    1. 23

                                                                                      So accurate, and I’m glad Lea had the patience to put it into writing. I’m much more inclined to write off the entire ecosystem as some expletive.

                                                                                      This is generally why I push juniors towards learning Elm instead of JavaScript these days. There are so many edge cases in today’s JavaScript. So many inconsistencies. So much magic one just has to know. So much conflicting information and constant churn. I feel this pain every time a junior asks me for help with something that won’t work as they expect, which these days is effectively every day.

                                                                                      Juniors are surprisingly good at finding logic rules that are internally inconsistent in programming languages.

                                                                                      There’s been a push lately for people to write “simple Haskell”, and to be honest I think we more desperately need a push towards simple JavaScript. That or just abstract it away entirely and allow it become the bytecode of the web.

                                                                                      1. 13

                                                                                        So many inconsistencies. So much magic one just has to know.

                                                                                        This sounds like English.

                                                                                        JS has two clear strong points: everybody knows it and it’s the lingua franca of the web. Just like how everybody knows English and it’s the lingua franca of international commerce.

                                                                                        The way it is going, we will use JavaScript forever.

                                                                                        Yes you could learn Elm. But when you quit your company 2 years from now, it will likely be better to have +2 years of JS than 2 years of Elm.

                                                                                        1. 16

                                                                                          everybody knows it

                                                                                          I would argue against that.

                                                                                          I think it’s no coincidence that one of the most popular technical book series for this language is called You Don’t Know JS.

                                                                                          1. 9

                                                                                            Well they know it the same way most people know English. Incomplete and error-prone but most of the time still good enough.

                                                                                            1. 4

                                                                                              I think “incomplete and error-prone” is what causes user experiences the likes of which is described in the article. For an experienced programmer, that might mean giving up on some library or language. For a novice, that might mean reconsidering their interest in programming.

                                                                                          2. 5

                                                                                            It sounds a bit like C, in fact: A standardized cross-platform (ha!) language with odd corner cases everyone seems to augment with libraries to smooth over the fact it was never fully portable from the beginning. It keeps being used, so it accretes more libraries around it, making it harder to switch away from, as even if you’re writing in a different language, you need to accept that the rest of the world speaks an API designed around That Language the moment you talk to something from the outside world.

                                                                                            1. 5

                                                                                              “everybody knows it and it’s the lingua franca of the web “everybody knows English and it’s the lingua franca of international commerce”

                                                                                              Sure, if by that you mean “everyone claims to know it, but when they need to use it, many fall flat on their face, or resort to some half-assed translation system that just complicates matters”.

                                                                                            2. 24

                                                                                              You push juniors towards learning Elm, a little known language, with smaller community and fewer learning and documentation resources, and no proven longevity (just google “leaving Elm” for crying out loud)? As someone who had to pick up JS over the past year and uses it at their job, any newbie picking up Javascript ES6 and following good programming practices should have little problem. The ecosystem is a different story, but most “edge cases” and “gotchas” come from inexperience with the language. Recommending they learn some random language won’t help with a PEBCAK problem like that.

                                                                                              1. 4

                                                                                                Despite being a Haskell fan, I don’t find Elm to be an attractive target. Sure, it’s simple, but the JS interop is really messy, some aspects of setting up elements just don’t scale well, and I’ve seen far too many complaints about the core team’s behavior to assume it’s just a fluke.

                                                                                                Yes, JavaScript has a ton of weird stuff going on. However, it’s still the standard, and learning it is beneficial—even if you don’t like to use it personally—because at minimum you’ll be seeing a lot of it. The edge cases in tooling are a mess but there are improvements lying around if you scan a bit (e.g. Parcel 2 is looking far more promising over Webpack’s config soup), and most of the type system weirdness is “solved” by using TypeScript (which makes me sad since it’s unsound, but it also has some incredibly powerful type system features that many other languages don’t).

                                                                                                1. 4

                                                                                                  I want to be clear that the point of my comment was not to fetishise Elm.

                                                                                                  The point is that all of JavaScript’s inconsistencies makes learning how to write programs with confidence immensely more challenging.

                                                                                                  JS interop is not part of learning how to write programs, and some people’s reaction to how the the language designers reacted to language feature requests (which usually added a greater surface area for potential runtime failure) is also not part of learning how to write programs.

                                                                                                  Minor aside: I don’t see how Elm’s FFI is “messy”. The port system works the way I would expect it to. It might feel more cumbersome than running some IO unsafely, but effects are hard, and this is the price we pay for a smaller surface area of potential runtime failures.

                                                                                                2. 2

                                                                                                  With 8+ years of JS (and TS) experience, and a smattering of Perl, Java, C, C++,C#, Elm, Ruby (Rails), Elm, Haskell, and more. I’d rather write all of those other languages combined every day than write more JS. The community always feels like they revert to whataboutisms and “it’s the language of the web!”. When it comes to writing a server, it’s perfectly acceptable to use any of a variety of languages. When it comes to writing for the browser it’s JS or nothing. Suggesting Elm is akin to suggesting cannibalism. I’d suggest Svelte, but most people think it’s JS. Why can’t the web front end be as diverse and accepting as the back end?

                                                                                                1. 2

                                                                                                  I use newsboat. It’s simple and works well. It’s also interesting to watch it slowly be rewritten into Rust.

                                                                                                  1. 4

                                                                                                    I recently used Clojure(Script) for the first time ever along with re-frame and reagent for a simple frontend for a side-project. I liked it all overall! I have a lot of Elm experience so it wasn’t entirely foreign to me.

                                                                                                    One thing that I haven’t found is docs on what are all the available functions—e.g. I was wondering how to handle on mouse enter and on mouse leave events. I guess I missed it, but it looks like you can basically just the event names in kebab-case.

                                                                                                    1. 2

                                                                                                      I’m using Clojure(Script) for the first time in a side-project for a simple website to interact with an API. I’m a Vim user but I’m sort of lost in between:

                                                                                                      • SLIME and all the variations, incl. these 2 plugins (though one seems for Common Lisp)
                                                                                                      • liquidz/vim-iced
                                                                                                      • tpope/vim-fireplace
                                                                                                      • CIDER (and nREPL?) and all the variations
                                                                                                      • snoe/clojure-lsp
                                                                                                      • Parens plugins like eraserhd/parinfer-rust and guns/vim-sexp

                                                                                                      I’m used to just setting up a language-server for a language and more or less going on from there. So far I really likeeraserhd/parinfer-rust and snoe/clojure-lsp but it seems like I’m missing out on other things? I realise that some of the above overlap/call each other. I suppose that some of my uncertainty comes from being new to Lisp and how the development flow works a little bit different to other languages?