1. 2

    One of the most exciting developments I’ve seen in this area in the recent past is Glamorous Toolkit (https://gtoolkit.com/) because it’s not just some academic prototype and much more flexible than a lot of what’s out there. It’s pretty sad to see some “state of the art” tooling when compared to this. Here’s a nice introduction: https://www.youtube.com/watch?v=Pot9GnHFOVU

    1. 6

      This is more than just software, but I’d love a scanner on my fridge/pantry that I could scan all my food into.

      Then I could see what is in the fridge, and, more importantly, what’s about to go bad, without looking through it.

      It’d also make making a grocery list a snap, since a big chunk of my food is staples.

      1. 2
        1. 1

          Oooh, thanks!

        2. 2

          Does this mean a check-in/check-out system? I guess for the scanning part nobody can help you with physical setup… But you can attach an Android smartphone with Binary Eye or something, scan everything incoming, and enable «forward all scan data to URL» with whatever you have around to receive and collect the data.

          I guess you could scan receipt before and after each batch of bought things to show these are incoming, and have a different marker to scan with things running out.

          Sounds like the receiver might be a reasonably simple script pushing everything into an SQL database — or doing nothing, if you prefer parsing the logs. Maybe having webserver logs with data would make getting around to actual processing easier…

          (of course, good luck with loose fruit here)

          1. 1

            Yes, check in check out. I wouldn’t mind doing the scanning, frankly. I guess I would have to scan things going out.

            Yes, loose fruit or cooked items would be problematic.

            1. 2

              Then maybe indeed install Binary Eye and start scanning? Once you have some data, the barrier of entry to actually processing it will become lower… (and even if unprocessed data doesn’t help you find expiring items, it will later help you estimate the range of consumption rates of various items)

              Cooked items are kind of less of a problem, as once you have a barcode for each rought type (which can be Data Matrix or something — yay multiformat scanning), the overhead of check-in/check-out is not large compared to cooking. I guess for fruit you could check-in each batch…

        1. 1

          I really like the UX on mobile and how snappy the site feels.

          1. 13

            About 25 years ago, an interactive text editor could be designed with as little as 8,000 bytes of storage. (Modern program editors request 100 times that much!) An operating system had to manage with 8,000 bytes, and a compiler had to fit into 32 Kbytes, whereas their modern descendants require megabytes. Has all this inflated software become any faster? On the contrary. Were it not for a thousand times faster hardware, modern software would be utterly unusable.

            Alright; I’d like to see people using an editor fitting in 8k of storage compiled with a language fitting in 32k[1] as a daily driver.

            Okay, perhaps it’s a bit lame to focus on those numbers specifically; but my point is that programs have also become immensely more useful. Editors – even editors like Vim – today do a lot more than 40, 30, 20, or even 10 years ago. And how long did it take that guy to build that TODO app with his 13k dependencies? How long would it have taken 30 years ago to build a similar program?

            And look, I’m not a huge fan of large dependency trees either; but I think this article is a gross oversimplification.


            [1]: tcc is 275k on my system.

            1. 7

              Over time you should expect things to become more powerful and easier to use! Look at microcontrollers for instance. They have become smaller, faster and easier to use over time. The argument is that software seems to be getting slower at a more rapid rate than it is gaining functionality.

              Hardware has increased in speed and gained fancy new features at the same time. Why is it that modern websites are sluggish? Why can’t we have our cake and eat it too? More complicated software that is also faster (given that the hardware is getting faster – this should be free).

              I don’t think software being more powerful or complicated is at all a fair argument for why it is slower.

              1. 6

                I don’t think software being more powerful or complicated is at all a fair argument for why it is slower.

                I think it’s entirely fair. That doesn’t excuse sluggishness in modern software for some tasks (like say, typing lag), but it does explain some of it. If you’re doing a lot more work you should expect it use more resources. There is also user expectation: those with more computing resouces tend to want their software to do more.

                I don’t want my software to be sluggish either (it drives me up the wall when it’s slow for basic tasks, which is why I cannot abide web apps for the most part), but if you’re going to compare old software that did very little with new software that does a lot as the post does, then discounting the feature sets is not at all a fair comparison.

                1. 8

                  I would 100% agree with you if the medium on which software is run on hadn’t increased in speed by orders of magnitude over the years. Has software increased by orders of magnitude in terms of power and complexity? Maybe, but then it should be the same speed as software was a few decades ago.

                  The fact is that software has gotten more complex and more powerful, but not nearly to the extent that hardware has gotten faster. There is certainly some reason for this (although I disagree with the article on what that is).

                  1. 4

                    Certainly it seems like it should be a lot faster, and maybe it’s slow, but there’s no question that I’m more productive on systems now than I was in the mid 90s.

                    1. 3

                      Recently, I was on a Windows machine and was obligated to write a text file. It had NotePad++, which I remembered as a “good editor,” so I used it. On Linux/Mac I’ve gotten used to a well-tuned neovim running in a GPU accelerated console… suffice to say that Notepad++ is no longer in its previous category.

                2. 5

                  Most webpages aren’t that slow; most of the “big” websites generally work quite well in my experience. There are exceptions, of course, but we tend to remember negative experiences (such as websites being slow) much more strongly than positive ones (websites working well).

                  A lot of the slowness is from the network. When you’re sitting in front of a webpage waiting for it to load stuff then most of the time the problem is that the HTML loads foo.js which triggers a XHR for overview.json and the response callback for that finally triggers data_used_to_render_the_website.json. Add to that the 19 tracker and advertisement scripts, and well… here we are.

                  There’s a reason it works like that too, because people want mobile apps (for different platforms!) and whatnot these days too, and turns out it’s actually quite tricky to serve both a decent website and a decent mobile app. It’s probably underestimated how much obile complicated web dev.

                  Note that some things are ridiculously slow. I have no idea how Slack manages to introduce 200ms to over a second of input lag on their chat; it’s like using a slow/inconsistent ssh connection. It’s been consistent crap ever since I first used it 5 years ago and I don’t quite understand how people can use Slack daily without wanting to chuck their computers out the window. But slow and crappy software is not a new thing, and Slack seems the exception (for every time I visit Slack, I’ve also visited dozens of sites that work well).

                  At any rate, it’s much more complex than “programmers stopped thinking about the quality of their programs”.

                  1. 5

                    Most webpages aren’t that slow; most of the “big” websites generally work quite well in my experience. There are exceptions, of course, but we tend to remember negative experiences (such as websites being slow) much more strongly than positive ones (websites working well).

                    We certainly use a different subset of the modern web! I find even GMail is sluggish these days, and often switch to the HTML-only mode. Jira (and basically all Atlassian projects) are what I would call “big” websites and wow are they slow.

                    A lot of the slowness is from the network. When you’re sitting in front of a webpage waiting for it to load stuff then most of the time the problem is that the HTML loads foo.js which triggers a XHR for overview.json and the response callback for that finally triggers data_used_to_render_the_website.json. Add to that the 19 tracker and advertisement scripts, and well… here we are.

                    Eh, I don’t fully buy this. Is it the network’s fault that every website comes bundled with 30 JS modules that need to load and then call out for more crap? I mean sure, with no-js this doesn’t become as much of an issue – and I don’t actually understand how someone can use the modern web without it – but I wouldn’t blame the network for these problems.

                    There’s a reason it works like that too, because people want mobile apps (for different platforms!) and whatnot these days too, and turns out it’s actually quite tricky to serve both a decent website and a decent mobile app. It’s probably underestimated how much obile complicated web dev.

                    Modern webdev is unbelievably complicated. I’ve been working on a project recently that dives into the depths of linker details, and it is nothing compared to how complicated setting up something like webpack is. But I would also argue that this complexity is superficial. Things like Svelte and Solid come to mind for what I think the modern web should look more like.

                    Note that some things are ridiculously slow. I have no idea how Slack manages to introduce 200ms to over a second of input lag on their chat; it’s like using a slow/inconsistent ssh connection. It’s been consistent crap ever since I first used it 5 years ago and I don’t quite understand how people can use Slack daily without wanting to chuck their computers out the window. But slow and crappy software is not a new thing, and Slack seems the exception (for every time I visit Slack, I’ve also visited dozens of sites that work well).

                    I’m right there with you! Its really unfortunate that no matter what company I go to and how good their engineering fundamentals are, the tools used are Jira, Slack and every other slow website.

                    At any rate, it’s much more complex than “programmers stopped thinking about the quality of their programs”.

                    I completely agree with you! Unfortunately, I’ve seen quality take a back seat far too many times to “just get something to work!” that I do think it is a part of the problem.

                    1. 5

                      I’m not a huge fan of modern web dev either; in my own app I just use <script src=..> and for the most part ignore much of the ecosystem and other recent(-ish) developments. /r/webdev called me “like the anti-vaxx of web dev” for this, as I’m “not listening to the experts, just like the anti-vaxx people” 🤷‍♂️😂

                      But at the same time the end-result is … kind of okay, performance-wise anyway. Most of my gripes tend to be UX issues.

                      Is it the network’s fault that every website comes bundled with 30 JS modules that need to load and then call out for more crap? I mean sure, with no-js this doesn’t become as much of an issue – and I don’t actually understand how someone can use the modern web without it – but I wouldn’t blame the network for these problems.

                      That’s kind of an unrelated issue; a lot of these SPA websites are built against a JSON API, so it needs to call that to get the data and it just takes time, especially if it’s a generic API rather than an API specifically designed for the app (meaning it will take 2 or more requests to get the data). Good examples of this are the Stripe or SendGrid interfaces which feel incredibly slow not so much because they got funky JS, but because you’re waiting on those API requests

                      1. 4

                        I’m not a huge fan of modern web dev either; in my own app I just use and for the most part ignore much of the ecosystem and other recent(-ish) developments. /r/webdev called me “like the anti-vaxx of web dev” for this, as I’m “not listening to the experts, just like the anti-vaxx people” 🤷‍♂️😂

                        This is hilarious! I’m with you though.

                        That’s kind of an unrelated issue; a lot of these SPA websites are built against a JSON API, so it needs to call that to get the data and it just takes time, especially if it’s a generic API rather than an API specifically designed for the app (meaning it will take 2 or more requests to get the data). Good examples of this are the Stripe or SendGrid interfaces which feel incredibly slow not so much because they got funky JS, but because you’re waiting on those API requests

                        That’s a good point. It might not necessarily be slow frontend, but it is still slow engineering. One of the previous places I worked at I fixed up an endpoint which was just spewing data, and upon talking to the frontend engineers they were using maybe 10% of it. Made a pretty significant speed improvement by just not sending a ludicrous amount of unused data!

                        1. 2

                          Yeah, it’s inefficient engineering, but consider the requirements: you need to make some sort of interface which works in a web browser, an Android app, an iOS app, and you frequently want a customer-consumable API as well.

                          This is not easy to do; if you build a static “classic” template-driven web app it’s hard to add mobile support; so you have to build an API alongside that for the webapp for the mobile apps to consume, which is duplicate effort. You can trim the API to just what you need for this specific page, but then other API users who do need that data no longer have it.

                          For a comparatively simple site like Lobsters it’s fine to not do that since the desktop UI works reasonably well on mobile too, but as soon as things start getting more involved you really need a different UI for mobile, as it’s just a different kind of platform.

                          It’s a difficult problem to solve, and it was much easier 20 years ago because all computers were of the same type (a monitor with a keyboard and a mouse). People are kinda figuring this out how to best do this, and in the meanwhile we have to suffer Stripe’s UI making 15 API requests to load the dashboard.

                          GraphQL is intended to solve this problem, by the way, but that has its own set of problems.

                          1. 1

                            Oh its certainly not easy, but I also don’t think it is particularly difficult. The reality is that there needs to be separate APIs for each of the use-cases (app, webpage and customer-consumable), since they all have different upgrade cycles and usage-types. One of the problems I see often is everyone wanting there to be one API for everyone and that will never work efficiently.

                            Netflix has a nice blog post [1] about how they handle the number of APIs they have (Netflix has gaming consoles, smart TVs and a whole host of other platforms that their API supports and it isn’t one “mega” API for all of them). They essentially have a Proxy API on the server-side which bundles all of the microservice APIs into whatever API calls the various frontends need. That way backend engineers can keep publishing APIs as they see fit for their microservices, and frontend engineers can group together what they need into an efficient API for their platform. And note, I’m using “frontend” loosely since there are so many different platforms they support.

                            Of course whether this effort is necessary for a small shop is unclear but for a bigger place (like Stripe or SendGrid) it is frankly poor engineering to not be fast.

                            I was very excited about GraphQL for a little while, but you’re right it does come with its own set of problems. Its still yet to be seen whether it is actually worthwhile.

                            [1] https://netflixtechblog.com/embracing-the-differences-inside-the-netflix-api-redesign-15fd8b3dc49d

                            1. 3

                              Of course whether this effort is necessary for a small shop is unclear but for a bigger place (like Stripe or SendGrid) it is frankly poor engineering to not be fast.

                              Yeah, I don’t know. Netflix is perhaps a bit of an outlier; they also managed to make their extensive microservice platform work very well for them, whereas many other organisations’ experiences have been markedly less positive.

                              Perhaps a big part of the problem is that there’s no “obvious” way to do any of this. That Netflix approach looks great, but also a very non-trivial amount of bespoke engineering effort with quite a lot of operational overhead. It doesn’t look like something you can pick off from the shelf and have it “just work” for you, so companies tend to focus their engineers other efforts as they feel that gives them better ROI. That sounds kinda lazy, but these kind of projects can also fail, or worse, get implemented and then it turns out it doesn’t work all that well and then you’re stuck with it and it becomes a liability.

                              The issue with GraphQL is that it’s really hard to implement well on your backend. Basically, it allows your API consumers to construct arbitrary queries against your database (okay, you can lock this down, but that’s how it’s supposed to be used). It’s certainly possible to facilitate this, but it’s not an easy problem to solve. Perhaps radical improvements in the network stack (e.g. with QUIC and others) will alleviate much of this (because all of that is also an inefficient organically grown mess).

                              On HN one of the Stripe devs said they’re working on fixing the performance of the dashboard a few weeks ago after I complained about it by the way, so at least they’ve acknowledged it’s an issue and are actively working on a fix. Perhaps things will get better :-) Actually, I already have the impression it’s better compared to half a year ago.

                              Also, I’d like websites from “small shops” to be fast as well. All of this shouldn’t be higher engineering you can only do if you can afford an ops team and 16 devs.

                              My own approach is to just use server-rendered templates with about 700 lines of jQuery sprinkled on top :-) It sounds very old-fashioned, but it actually gives very good results, IMHO. Then again, I’m not Stripe or SendGrid and am operating on a rather different scale in almost every way.


                              Also, related: last night (after my previous comment) I happened to be talking to a friend about the new reddit design, and I figured I’d try it and see if it’s any better (I normally use old.reddit.com). I couldn’t believe how slow it is. Like, I literally can’t scroll: it just jumps all the time and Chrome uses both CPU cores to the max. Granted, I have a pretty slow laptop, but what the hell? What a train wreck. My laptop can play movies, play games, compile code, and do all sorts of things, but it struggles with … a text website.

                              This is the kind of stuff you’re talking about. Yeah, some sites really are inexcusably bad.

                            2. 1

                              if you build a static “classic” template-driven web app it’s hard to add mobile support

                              It was like, a handful of lines of CSS and HTML for my static site to be supported on mobile with no frameworks. And often I go on a website and the sheer frameworks that they use get in the way of me using their site on mobile. This UK government coronavirus website was apparently optimized for mobile but none of the buttons worked, even when I zoomed in on them. This BBC News website was impossible to navigate because it kept on freezing up on my recent phone.

                              Whereas web forms from 20 years ago work fine and are perfectly fine to use, they might require some zooming but nowhere near as much effort to attempt to navigate, and at least they work.

                              Things will work well enough if you let go of the frameworks. Let the browser do it’s job!

                    2. 1

                      Hardware has increased in speed and gained fancy new features at the same time.

                      Yet hardware also has loads of legacy cruft and compatibility layers making things slower than they would need to be. But that’s inevitable with the incremental nature of development. But I think incremental development is the only way to gain experience. And then every now and then you have a new technology come around and get a chance to start from a somewhat empty slate and apply what you’ve learned. I have high hopes for RISC V for example. And I think there are similar developments in software. Better tools and languages allow for writing better and faster software. A good example ist Rust, where you regularly see blog posts of Rust reimplementations of the supposedly pristine C implementations of ancient Unix tools outperform the C version, because the compiler can optimize more, because it has stronger guarantees from the language and you can use more high level constructs. Similar to that, I think that webassembly will improve the web performance story quite a bit.

                    3. 5

                      Having used some old editors that come with some C compilers prior to 1985 and running them on emulators to try and do real work on those systems, I can attest to them being woefully underpowered compared to modern editors.

                      1. 2

                        I still have fond memories of the Lattice C (SAS/C) editor circa 1987. Maybe I’m a masochist.

                        That being said, I hate editors with a lot of features. I end up never using 90% of the features so all those features do for me is add complexity, slowness, bugs, and unexpected modalities. I suppose that explains why my favorite editors are ED (from AmigaDOS/TRIPOS), the original vi (yes I know modes), and sam…

                        1. 1

                          I used to be similar, but after neovim added async plug-ins (so the features don’t affect the performance of the main interface), I started to build a much more extensive collection of them. Language servers are a fantastic innovation, allowing the good parts of working in an IDE without loading up some monstrosity.

                      2. 2

                        Tangentially,

                        I spent a few years using ex-vi (I’ve also in the past used ed(1) and vim’s vi(1)), C, POSIX, and surf(1), along with a minimal desktop environment (that was roughly, openbox with custom shortcuts, and XMonad) and it was pretty fun. It’s a nice feeling to know that my programs will work in a decade with minimal changes. Now I’ve moved to Python and Doom Emacs, on the one hand, nothing has changed much. Some things are maybe easier, maybe not. On the other hand, it’s given me a respect for the things that are easier.

                        One thing I will note is that the lag in using these new ‘high powered tools’ is much, much greater. Despite the fact that doom emacs, for example, goes out of it’s way to make latency when actually using the editor something that doesn’t bother the user. Loading up chromium takes an age when you’re used to surf popping up in under a second. Waiting for lightdm to start, log in, and then ‘start’ GDM is excruciating when you’re used to being dropped to a terminal after boot and loading Xorg in under a second.

                        There isn’t that much of an advantage to all of these bells and whistles, most of the complex stuff averages out because grep mostly gives results in the same time that an IDE takes to show the dialog. Everything you can do now you could achieve with shell scripts and get the same convenience and practically perform the task each day with about the same timing.

                        1. 1

                          You can do a modern programming language with a text editor from 1994 : Rus Cox co-authored Go with ACME.

                          1. 2

                            Russ made a video intro on it: https://research.swtch.com/acme

                            1. 1

                              You do not let any choice, I must try it again now! https://9fans.github.io/plan9port/ or http://drawterm.9front.org/ + http://9front.org/

                          2. 1

                            Vim is 37MB. Can someone please explain to me why a text editor like vim needs such a huge size?

                            1. 5

                              Where do you get this number? The vim executable on my work Ubuntu desktop is 2.6 MB, another <megabyte of shared objects, and 4.5 MB for libpython3.6m which is optional. A download of Vim for Windows is 3.6 megabytes, so about the same. Did you miss a decimal point?

                              1. 2

                                Not to put words into @Bowero’s mouth but the latest VIM sources are almost 60MB, so maybe they were referring to source or source+buildtime resources or translations or something?

                              2. 5

                                37M seems wrong, it’s nowhere near that on my system:

                                -rwxr-xr-x 1 root root 2.6M Jun 12 18:05 /usr/local/bin/vim*
                                

                                That 37M probably includes runtime files? Which aren’t really needed to run Vim but are just useful:

                                88K     ./plugin
                                92K     ./colors
                                128K    ./tools
                                136K    ./print
                                140K    ./macros
                                224K    ./pack
                                276K    ./compiler
                                892K    ./indent
                                1.1M    ./ftplugin
                                2.1M    ./autoload
                                2.5M    ./tutor
                                3.6M    ./spell
                                6.7M    ./syntax
                                8.2M    ./doc
                                27M     .
                                

                                Does Vim need support for 620 different filetypes, detailed reference documentation, a “tutor” in 72 different languages, or some helpful plugins shipped by default? I guess not; but it doesn’t get loaded if you don’t want to use it. It’s just useful.

                              3. 1

                                I used an editor under MS-DOS that was 3K in size, and could handle text files up to 64k (if I recall—it’s been 30 years since I last used it, and I only know the size because I typed in the source code from a magazine). It was a full screen editor.

                                Turbo Pascal pre-4 was I think 50k, and that included the editor, so that would fit your criteria. Do these editors give the functionality found in modern editors or IDEs? No. But they are usable in a sense [1].

                                [1] In the “Unix is my IDE” sense, using the command line tools to search and process text.

                                1. 6

                                  But would you still choose to use those tools today? I mean, Unix was built with teletypes and printers, so you can undoubtedly build very useful things with limited tools, but why use a limited tool when you’ve got enough computing power to use a more powerful one?

                                  1. 1

                                    I might, especially if I found myself back on MS-DOS. I’ve tried various IDEs over the years (starting with Turbo Pascal 3) and I never found one that I liked. Back in the 80s, the notion that I would be forced to learn a new editor (when I had one I knew already) is what turned me off. Since the 90s, I’ve yet to find one that wouldn’t crash on me. The last time I tried ( just a few years ago) I tried loading (never mind editing or compiling) a single C file (57,892 bytes) and it crashed. Hell, my preferred MS-DOS editor I used (40K executable, not the 3K one I mentioned above) written in 1982 could handle that file. You can’t use what doesn’t run.

                                2. 1

                                  A few minutes?

                                  #!/bin/sh -e
                                  
                                  mkdir -p "$HOME/.config"
                                  
                                  case "$1" in
                                  ('')
                                          exec sed '=; s/^/  / p; s/.*//' "$HOME/.config/todo"
                                          ;;
                                  (add)
                                          shift
                                          exec echo "$*" >>$HOME/.config/todo
                                          ;;
                                  (del)
                                          tmp=$(mktemp)
                                          sed "$2 d" "$HOME/.config/todo" >$tmp
                                          exec mv "$tmp" "$HOME/.config/todo"
                                          ;;
                                  (edit)
                                          exec $EDITOR "$HOME/.config/todo"
                                          ;;
                                  (*)
                                          echo >&2 "usage: todo add text of task to add"
                                          echo >&2 "       todo del num"
                                          echo >&2 "       todo edit"
                                          ;;
                                  esac
                                  
                                  1. 4

                                    Right-o, now ask your mother, spouse, brother, or other non-technical person to use that. It’s equivalent (probably even better) for people like us, but it’s not really an equivalent user-friendly GUI program.

                                    1. 1

                                      I honestly think it could have been done likewise in 1985 (35 years ago) before people unable to use a shell would be entirely unable to access a computer’s files and features.

                                      If it really got extremely popular, it could have been adopted by 30 users author included.

                                      In 1995 whoever finding it on internet willing to give it a try would download it, spawn COMMAND.COM (Windows 95) try to run it, see it fail, open it and wonder “what the fuck?”, close it.

                                      I guess a todo.apk would get some more luck today for roughly the same time in Android Studio.

                                      1. 2

                                        I honestly think it could have been done likewise in 1985 (35 years ago) before people unable to use a shell would be entirely unable to access a computer’s files and features.

                                        Yeah, probably. But, for better or worse, the “average user” is quite different now than it was 35 years ago. Actually, this is probably one of the reasons things are so much more complex now: because while I’m perfectly happy with a script based on $EDITOR ~/.config/todo, this clearly won’t work for a lot of people (and that’s fine, not everyone needs to be deeply knowledgable about computers).

                                        1. 1

                                          Agreed! A lot of things happen in 35 years! Software shaping society at high pace, society shaping software likewise.

                                        2. 1

                                          Which means that the challenge is becoming increasingly harder for many factors (more, less skilled, more distributed people expecting more done faster by computers of more diverse types).

                                          We need keep the software stack manageable, as if a simple Todo app already takes us libraries to get the job done in reasonable time, I do not want to know what your accounting software will require to be maintained (SAP anyone?).

                                          And the TODO app made with 13k dependencies means a huge amount of time spent maintaining the 13k dependencies for everyone. Now we cannot stop maintaining these 13k dependencies because every TODO app in the world now relies on it.

                                  1. 3

                                    One difference between modular synths and FOSS is that they’re considerably more expensive than their closed/monolithic equivalents! In hardware, that flexibility comes at a cost. I’ve got a small rack with six or seven modules, but it probably cost around $1500 to put together. It makes some cool sounds but I find it less musically useful than the Modal Electronics Skulpt synth I got for $300.

                                    People interested in trying out modular synthesis without spending a bundle on hardware should check out VCV Rack, a free-as-in-beer GUI program for Mac/Win/Linux that emulates a modular synth. You can download a ton of free modules, including ones built from the same free firmware that’s in popular modules, and there’s also a store selling more modules. It’s a lot of fun to mess around with, and it can do things the hardware can’t, like polyphony.

                                    1. 1

                                      It’s also free-as-in-speech (licensed under GPL3 with an exception for commercial plugins)

                                      1. 1

                                        Oops — I remembered it had changed licenses, but thought it went the other direction.

                                      2. 1

                                        VCVRack runs very, very well on my Linux DAW, and is a regular delight in the studio.

                                        Some simply amazing modules available, because of the ethos of its F/OSS community. Eurorack hardware developers even use it as a platform to test their ideas ..

                                      1. 33

                                        When content recommendation becomes the most important highlight of a privacy-friendly browser’s new release.

                                        I love Firefox, but sjeesh

                                        1. 13

                                          It is infuriating that the developers of a web browser consider it acceptable to implement any “content recommendation” on their program.

                                          1. 7

                                            Why? As stated up-thread, browsing data is never uploaded. Content recommendation happens locally only. What is so wrong with this?

                                            1. 7

                                              Because it’s a browser. It should empower me to search the internet for the stuff I want to see, not they think I want to see. I gain no user experience whatsoever. It’s a slippery slope downhill from any recommendation system, no matter how privacy friendly they claim it to be.

                                              1. 6

                                                Imagine your new FM radio “recommended” which station to tune to when you turned it on. Would it really be any comfort if the manufacturer assured you that that this recommendation had nothing to do with your own preferences, because they don’t know and definitely don’t care? Bookmarks have been part of browsers since the beginning. This is something else.

                                                People only put up with this nonsense because it’s free-as-in-beer. That’s why I’d be happy to pay for a fork that treated me like a paying customer rather than a set of eyeballs to sell through some convoluted scheme papered over with a lot of patronizing rhetoric.

                                                1. 4

                                                  Maybe a car analogy is useful for you. It’s as if your car “recommended” which restaurant to go when you drive it on Saturday afternoon, and actually drove you there without asking, until you overrade it. A minimal amount of fuel would be lost at the beginning of the journey; this is no problem, you can override it at any time. Would you be OK with that?

                                                  I do not want my web browser to make any network request when I open it, unless I ask for it explicitly. As other posts in this thread explain, this is actually impossible with firefox. This is what infuriates me.

                                                  1. 0

                                                    Though they say the browsing data is never uploaded, it’s trivial to match the IP and the time of when the content was recommended. That info can then be correlated with the site serving the recommended content. Several ways exist in which to deanonymize browsing history.

                                                2. 10

                                                  One of the first things - besides installing uBlock and friends - I do with a new FF installation is the disabling of all these spurious ‘services’ - content suggestion, dangerous content warnings, the various telemetry bits apart from bug reports, those I do send seeing as I run nightly and as such can provide useable reports.

                                                  1. 4

                                                    I would be grateful if you could share the configurations that you are doing. I am asking so that I could note them down and set them too.

                                                    I would like if NixOS would provide firefox configuration options that could be configured centrally, or per user, to make sure that every upgrade applies them.

                                                    1. 3

                                                      home-manager allows you to declaraticely configure which Firefox add-ons to install (although you still need to enable them manually the first time you start Firefox for security reasons). And you can set Firefox options declaratively using their enterprise policies.

                                                      1. 2

                                                        I don’t use much magic to configure it, most is by hand. The only ‘automatic’ thing I do is install a policies.jsonfile (in distribution/policies.json in the FF install directory, in my case that is /opt/APPfirefox/bin/distribution/policies.json) which disables automatic updates since I handle those using a script. I do not want to have binaries writeable by users so these automatic update policies are out of the question. The update script pulls new nightlies from the server and installs them, installs the policies.json file in the correct location and sets ownership and permission so that regular users can execute, but not modify the distribution. I used to have a FF sync server when that was still a thing but eventually it got too hard to reinstate ‘old’ sync support. I do not have, nor do I want to have a ‘Firefox account’ since I do not use any such external services if I can in any way avoid them. I might look into building a ‘new’ FF sync server some time but other matters are more important for now. Until such time I will simply install the following extensions:

                                                        • uBlock origin (set to ‘expert user’ mode)
                                                        • uMatrix (disabled by default)
                                                        • Nuke Anything (to get rid of annoying overlays which uBlock can not filter out)
                                                        • Open With (to open e.g. media files through a local script)
                                                        • Containers with Transitions (to always open certain sites in site-specific container tabs)
                                                        • Foxyproxy Standard (disabled, sometimes used to redirect sites through a local Tor node)
                                                    2. 13

                                                      It seems to me it’s just a “here are the most popular articles”-list; don’t see anything wrong with that, or any fundamental privacy-concerns. Also from the expanded announcement on it:

                                                      Recommendations are drawn from aggregate data and neither Mozilla nor Pocket receives Firefox browsing history or data, or is able to view the saved items of an individual Pocket account. A Firefox user’s browsing data never leaves their own computer or device.

                                                      And from the FAQ:

                                                      [N]either Mozilla nor Pocket ever receives a copy of your browser history. When personalization does occur, recommendations rely on a process of story sorting and filtering that happens locally in your personal copy of Firefox.

                                                      1. 11

                                                        I see something wrong with that, that being giving the user an experience that they have not ask for nor had any control over. Also, what news site, and what collection of news given to the user is trustworthy in a general sense?

                                                        I feel about it as if I got public broadcasting in my new tab, not something I want nor I am interested in.

                                                        1. 9

                                                          that being giving the user an experience that they have not ask for

                                                          How can you be so sure? I’m a Firefox user, and I find those articles occasionally useful.

                                                          nor had any control over

                                                          You can switch it off easily in preferences or directly on the New Tab page (three dots in the upper right corner).

                                                          1. 4

                                                            “nor had any control over” is a terrible way to word it (it is your computer and you are definitely in control). My first reaction was “this person is entitled as heck”.

                                                            However, there is an implied social contract (because firefox existing makes it socially/politically almost impossible to get an alternative off the ground). I still disagree with lich, but their argument has legs.

                                                          2. 3

                                                            I see something wrong with that, that being giving the user an experience that they have not ask for nor had any control over. Also, what news site, and what collection of news given to the user is trustworthy in a general sense?

                                                            I don’t feel that’s a fair characterization. Any new feature can be described as giving the user an experience they did not asked for. And as other commenters note, it can be disabled. Which grants control.

                                                            As to a user experience, I have lobsters show up in my recommended list, probably because I visit it so often. It does make some sense that I would be recommended what I like to habitually visit.

                                                            I even removed the suggestion a few times and timed how long and how many visits made it reappear. For me, it learned the association in a day and ten visits to the front page because my habit is to close the tab after quickly reviewing the stories posted.

                                                          3. 6

                                                            Where does the aggregate data come from?

                                                          4. 5

                                                            I cannot use Firefox and feel safe without ghacks user.js. It is kind of absurd that there is no real community-lead option for browsers. You could put the blame on standards bodies for creating bloated standards, but now more than ever they are just a facade commanded by corporate interests. I don’t know much about it but Project Gemini (along with gopher) seem to be closer to achieving the goals of free software and the “original dream of the web” (whatever that means).

                                                            Edit: typo

                                                            1. 1

                                                              I totally get your point. Would something like Pale Moon feel better to use?

                                                          1. 2

                                                            I’d be curious to know what you use for email nowadays, since you write that you haven’t used notmuch in a long time.

                                                            1. 5

                                                              Gmail :)

                                                              With a full time job, removing mailserver maintenance from my setup allows me to enjoy other things instead.

                                                              1. 4

                                                                I keep hearing it and I have no idea what are you guys talking about. Email setup for a small group of people takes as much time to maintain as you want to spend. Mine takes, on average, zero hours a month. I’d be curious to hear about email setups that constantly break on their own and need operator attention. Maybe a list of mistakes that lead to that can help future operators.

                                                                In terms of precision, a trackball will not be as good as a mouse can be.

                                                                Depends on the size of the ball. ;) Big ball trackballs like Kensington Expert Mouse are more precise than most mice. It may also depend on the thumb vs. three fingers operation. The big ball ones can also be used with either hand .

                                                                1. 8

                                                                  I’m glad to hear your setup works well for you.

                                                                  Here are some of the issues I have faced:

                                                                  • Went on vacation to another country and on day 1 of the week-long trip, my self-hosted mail server had a hardware failure. Made for a very stressful trip.

                                                                  • Was sometimes unable to receive emails from various senders for various reasons, all of which required getting in touch via a separate channel and then debugging.

                                                                  • Was unable to send emails and only noticed days later.

                                                                  • Spam filter was significantly worse than gmail, even after years of diligent training.

                                                                  Using a major hosted email provider takes care of all of these issues, and reduces my work load when migrating/updating servers.

                                                                  1. 3

                                                                    While it might take zero hours a month for most of the time, I at least would be slightly more stressed simply because that thing exists and I have to care of it. I also try to outsource as much as possible (with a few exceptions for entertainment) of the technical side of my life to others.

                                                              1. 3

                                                                You can install using a prebuilt image too. Some rebuild time, but pretty easy…

                                                                I found the instructions on the wiki lacking, so wrote my own.

                                                                # Find a build from https://hydra.nixos.org/job/nixos/trunk-combined/nixos.sd_image_raspberrypi4.aarch64-linux -
                                                                # in this case, we're using https://hydra.nixos.org/build/118111398.
                                                                
                                                                # Curl the image and flash your SD card in one fell swoop.
                                                                # From the install machine, replace mmcblk0 with wherever your SD card is.
                                                                # Verify the printed SHA256 against https://hydra.nixos.org/build/118111398.
                                                                # (Click "details" for the bz2 archive to see the expected hash):
                                                                curl -L https://hydra.nixos.org/build/118111398/download/1/nixos-sd-image-20.09pre223885.d6fcf36e478-aarch64-linux.img.bz2 | tee >(sha256sum >&2) >(bzcat | dd if=/dev/stdin of=/dev/mmcblk0 bs=4M status=progress) >/dev/null
                                                                
                                                                # Boot the NixOS install image, and run, from the console:
                                                                sudo -s
                                                                passwd nixos
                                                                systemctl start sshd
                                                                
                                                                # Upgrade the install image in-place to a customized image.
                                                                # Connecting over ssh is probably easier for these since you'll need to copy a configuration over.
                                                                # Just ssh nixos@nixos-host and enter the password you chose.
                                                                # Then elevate to root, you'll need it.
                                                                sudo -s
                                                                
                                                                # This needs to be manually mounted for NixOS to correctly change the boot generation when you rebuild for the first time.
                                                                # The config will make this permanent.
                                                                mkdir -p /boot
                                                                mount /dev/disk/by-label/FIRMWARE /boot
                                                                
                                                                # Update the channel to the latest:
                                                                nix-channel --update
                                                                
                                                                # Create swap space. The config will make this permanent.
                                                                fallocate -l 1g /swap
                                                                chmod 0600 /swap
                                                                mkswap /swap
                                                                swapon /swap
                                                                
                                                                # Copy over configuration.nix to /etc/nixos/configuration.nix.
                                                                # Change "4" to "3" in the bootloader config if you're on a rpi3.
                                                                # See the comment in the configuration file about what to do if /boot runs out of space.
                                                                nixos-rebuild boot
                                                                
                                                                # Set a root password.
                                                                passwd root
                                                                
                                                                # Boot into the customized image:
                                                                reboot
                                                                
                                                                # Now you are no longer in an install image and can use the system!
                                                                # Reclaim SD space by GCing components from the install image.
                                                                rm -rf /home/nixos
                                                                nix-collect-garbage -d
                                                                

                                                                Use this configuration.nix:

                                                                { pkgs, lib, ... }:
                                                                
                                                                /*
                                                                 * This config is derived from: https://nixos.wiki/wiki/NixOS_on_ARM/Raspberry_Pi
                                                                 * Note: if you get a "no space left on device" when building this, run:
                                                                 *     rm -rf /boot/kernel.img* /boot/initrd* /boot/old
                                                                 * and run your nixos-rebuild again. The boot partition is rather small.
                                                                 */
                                                                {
                                                                  imports = [ ];
                                                                
                                                                  ###
                                                                  ### This section is critical for the raspberry pi to boot.
                                                                  ###
                                                                  boot.loader.grub.enable = false;
                                                                  boot.loader.raspberryPi = {
                                                                    enable = true;
                                                                    version = 4; # change to 3 for rpi3
                                                                    firmwareConfig = ''
                                                                      gpu_mem=192
                                                                      dtparam=audio=on
                                                                      disable_overscan=1
                                                                      hdmi_drive=2
                                                                      disable_audio_dither=1
                                                                
                                                                      # Can be shortened if desired.
                                                                      boot_delay=10
                                                                    '';
                                                                  };
                                                                
                                                                  # This is necessary for the rpi3 as well.
                                                                  boot.kernelPackages = pkgs.linuxPackages_rpi4;
                                                                
                                                                  # Makes graphics work.
                                                                  hardware.deviceTree = {
                                                                    base = pkgs.device-tree_rpi;
                                                                    overlays = [ "${pkgs.device-tree_rpi.overlays}/vc4-fkms-v3d.dtbo" ];
                                                                  };
                                                                
                                                                  # Enable nonfree firmware (necessary for the rpi)
                                                                  hardware.enableRedistributableFirmware = true;
                                                                
                                                                  # Log important messages to the system console.
                                                                  boot.consoleLogLevel = lib.mkDefault 7;
                                                                
                                                                  # These are the filesystems defined on the SD image.
                                                                  fileSystems = {
                                                                    "/boot" = {
                                                                      device = "/dev/disk/by-label/FIRMWARE";
                                                                      fsType = "vfat";
                                                                      options = [ "nofail" ];
                                                                    };
                                                                    "/" = {
                                                                      device = "/dev/disk/by-label/NIXOS_SD";
                                                                      fsType = "ext4";
                                                                    };
                                                                  };
                                                                
                                                                  # Prevent use of swapspace as much as possible
                                                                  boot.kernel.sysctl = { "vm.swappiness" = 0; };
                                                                
                                                                  ###
                                                                  ### This is where all your config goes.
                                                                  ###
                                                                
                                                                  # Customization for console font, language, time, etc...
                                                                  console = {
                                                                    font = "sun12x22";
                                                                    keyMap = "us";
                                                                  };
                                                                  i18n = {
                                                                    defaultLocale = "en_US.UTF-8";
                                                                  };
                                                                  time.timeZone = "America/Los_Angeles";
                                                                
                                                                  # Graphics. Comment if you don't care.
                                                                  hardware.opengl = {
                                                                    enable = true;
                                                                    setLdLibraryPath = true;
                                                                    package = pkgs.mesa_drivers;
                                                                  };
                                                                  services.xserver = {
                                                                    enable = true;
                                                                    displayManager.lightdm.enable = true;
                                                                
                                                                    # enlightenment is probably fine for the rpi4, but we'll use the old standby of XFCE for the rpi3
                                                                    desktopManager.xfce.enable = true;
                                                                
                                                                    videoDrivers = [ "modesetting" ];
                                                                  };
                                                                
                                                                  # Sound. Comment if you don't care.
                                                                  hardware.pulseaudio.enable = true;
                                                                  hardware.pulseaudio.support32Bit = true;
                                                                  sound.enable = true;
                                                                
                                                                  # Hostname, host ID, etc.
                                                                  networking = {
                                                                    hostName = "rpi";
                                                                    firewall = {
                                                                      enable = true;
                                                                      allowedTCPPorts = [ 22 ];
                                                                    };
                                                                    wireless.enable = true;
                                                                  };
                                                                
                                                                  security = {
                                                                    hideProcessInformation = true;
                                                                  };
                                                                
                                                                  environment.systemPackages = with pkgs; [
                                                                    wget vimHugeX curl git htop zsh tmux psmisc pciutils manpages
                                                                    zip unzip
                                                                    usbutils alsaUtils
                                                                  ];
                                                                
                                                                  # SSH config. Change passwordAuthentication if you want to log in with a password.
                                                                  services.openssh = {
                                                                    enable = true;
                                                                    passwordAuthentication = false;
                                                                    permitRootLogin = "prohibit-password";
                                                                    forwardX11 = true;
                                                                  };
                                                                
                                                                  users = {
                                                                    users.myuser = {
                                                                      uid = 1000;
                                                                      isNormalUser = true;
                                                                      extraGroups = ["wheel" "audio" "tty"];
                                                                      shell = pkgs.zsh;
                                                                      openssh.authorizedKeys.keys = [ ];
                                                                    };
                                                                  };
                                                                
                                                                  nixpkgs.config = {
                                                                    allowUnfree = true;
                                                                  };
                                                                
                                                                  swapDevices = [ { device = "/swap"; size = 1024; } ];
                                                                }
                                                                
                                                                1. 5
                                                                  # Boot the NixOS install image, and run, from the console:
                                                                  sudo -s
                                                                  passwd nixos
                                                                  systemctl start sshd
                                                                  

                                                                  The whole point of the author was that they didn’t want to have to connect a screen to their raspberrypi but have sshd enabled on first boot.

                                                                  1. 1

                                                                    I’m aware. Last time I tried this process (as the OP said), you needed to set up QEMU to compile things – that is, set up QEMU to run GCC inside QEMU – or use an aarch64 EC2 instance. Which just seems weird considering that cross compilers exist, and left me more than a little disappointed in the current ability of nixpkgs to natively cross compile binaries. Or am I missing something important?

                                                                    To me, just running the rebuild on the pi is good enough, and doesn’t require hacks like running an entire aarch64 cross compile inside an ARM emulator. When you have to pick the lesser evil, and all…

                                                                    [E] What’s especially confusing is that native cross compiling seems to exist, but all the guides I see end up emulating GCC with QEMU. I can’t tell if this is just bad documentation or if that’s really what you have to do.

                                                                    1. 1

                                                                      Im aware.

                                                                      Would’ve been nice to mention that then. Because right now it looks like your answer is a solution to the original problem, which it is not.

                                                                      I can’t tell if this is just bad documentation or if that’s really what you have to do.

                                                                      Just bad documentation. Have a look at https://github.com/nix-community/nixos-generators. The post has also been updated to reflect that.

                                                                      1. 1

                                                                        Would’ve been nice to mention that then

                                                                        I don’t really feel like editing my post when you say it like that regardless of how right you are, so go be pedantic elsewhere. I don’t know if you’re used to strong-arming commenters on other sites, but that’s not how lobsters works.

                                                                        Thanks for the link and clarification, though. Only being able to compile for your current architecture seemed counterintuitive given how nixpkgs is supposed to function.

                                                                        1. 2

                                                                          Sorry, I didn’t want to sound pedantic or condescending. I just thought it would’ve been nice to give a heads up for readers looking for an answer to the problem in the article, because they might get a wrong impression and get stuck trying to get your approach to work without connecting a screen and keyboard.

                                                                          1. 1

                                                                            No worries. I’d clarify, but it seems like it doesn’t allow edits at this point. :(

                                                                1. 3

                                                                  You can use https://github.com/nix-community/nixos-generators to create a bootable aarch64 image cross compiled from x86 out of the box.

                                                                  1. 2

                                                                    Just replied via e-mail to you, but for anyone else that’s reading: I have added a section which includes nixos-generators as it’s an amazing tool. I didn’t update the Vagrant section mostly because it’s just a log of stuff that I have done to get it working, but I have added a note.

                                                                    Let me know if you have any other suggestions!

                                                                    1. 1

                                                                      Generators were one of the interesting things I learned from the Super Bootable 64 post a few days ago. Super convenient tool. Thanks for the reminder.

                                                                    1. 4

                                                                      I’m not sure that’s a realistic request to make of the companies. Sure, it would be amazing to know all that beforehand, but I think no company is proud of having a somewhat broken deployment process or no proper CI. I suspect, that if they were all open about that, they’d have a hard time hiring anyone. And I can totally see how some of the awful setups described in the article came into existence.

                                                                      The major thing for me is, whether they let you make improvements. Because if you’re allowed to change things for the better, a worse starting situation might be overall preferable to a mediocre one, where you’re not allowed to touch anything.

                                                                      1. 8

                                                                        they’d have a hard time hiring anyone

                                                                        I can appreciate how it’s hard, but FWIW I think I’d advocate doing it anyway because having difficulty with employee hiring (when people don’t like what they hear in the interview) is much cheaper than having difficulty with employee retention (when people don’t like what they find out on the job, after you’ve paid the cost of onboarding them).

                                                                        Separately, this also provides another channel for feedback. Candidates’ reactions to an honest description of your deploy pipeline gives you an idea of where you are relative to the rest of the world.

                                                                        1. 7

                                                                          If a company is honest about their problems during the hiring process there are two reasons that the candidate might pass on the job.

                                                                          1. The candidate is turned off by the problems

                                                                          In my opinion this is very rare. Most people I can think of will be excited by the potential of improving things and making them better.

                                                                          1. The candidate understands that the problems are the symptoms of having a broken/non-existent engineering culture and by joining the company they will simply join the dumpster fire without being able to do anything about it

                                                                          I think the parties involved in a job interview should be brutally honest with each other. It’s like any other partnership or relationship. You can’t trick people into it for long before it backfires so start it right.

                                                                          1. 2

                                                                            My experience recruiting people to a company with a so so dev experience is that people respond really well to honesty. I try to tell candidates what we do well, what we don’t do well, and what we are doing to fix the latter.

                                                                          2. 3

                                                                            Sure, it would be amazing to know all that beforehand, but I think no company is proud of having a somewhat broken deployment process or no proper CI. I suspect, that if they were all open about that, they’d have a hard time hiring anyone.

                                                                            If a company has a problem so big that it would prevent them from hiring people if it were known, then fixing it should be a top priority. It’s not just that being able to do your job shouldn’t be treated like a perk – but it deserves mentioning that it’s really stupid to hire smart people, and not give them the tools they need to work at their full potential. But if it’s so bad that it prevents them from hiring good people, there’s a good chance it’s also preventing them from keeping good people around, with all the problems that entails: no way to disseminate information, no way to grow expertise and so on.

                                                                            I’ve worked in a place that had one of… you know what, actually the setup they had was worse than anything described in that article, on every level. I can’t describe how awful it was in detail, because it’s rage-inducing – let me just say, as a first example, that after making a one-line change, it took 15-20 minutes to do the commit, and that there was a reasonable chance (about once per month) that attempting to do it would corrupt your local copy of the repository and you’d have to make a new one from scratch, which took about 4-6 hours.

                                                                            Nobody left because of that, but as soon as things got a bit tough, it quickly became the straw that broke the camel’s back. Someone would ask you when you’d push your fix – right as your local copy would get corrupted, right before your eyes, and you’d be looking at staring at a progress bar for the next six hours. Hopefully you’d backed up your files, too, otherwise you had to redo it from scratch. If that happened at about 4 PM on the day before the release, you were the lucky winner of spending a night at the office because there was no way you’d even have something to compile, let alone test and push, before 10 PM.

                                                                            Okay, no infrastructure is ever perfect. Anything can be improved. But there’s a long way from “our deployment process needs two minutes of handholding and our CI pipeline could be better, but we’re working on it” to “our deployment process involves an 80-step manual procedure where step 42 involves rlogin-ing to a server halfway across the globe and ssh-ing into about twelve servers by hand, and we don’t do CI, one of us manually does a test suite every afternoon, by rotation”. Okay, you shouldn’t “advertise” these things in an interview, but if they’re so common that they’re “the dev experience”, not a temporary situation while you’re transitioning to another set of tools or whatever, that is a problem. It shouldn’t be mentioned in an interview for the same reason you don’t mention you have a release tomorrow – because everyone should be working on fixing it around the clock.

                                                                            1. 2

                                                                              IMO it is totally realistic and I’ve done this exact thing. You need to set the tone that you are interviewing them as much as they are you. If you are desperate for a job, then yes, it doesn’t make tactical sense to ask this.

                                                                              Otherwise if you are not desperate, you can ask this, and it actually gives you leverage. Think about it: your reaction to their answer to this question means a lot. If you react in a positive way, as in, you understand this is common and that you look forward to dealing with it and improving things, it can look really good on you. As an anecdote, the interview process I went through had 3 phases and I got to the last phase. Honesty and by extension courage display self-reliance.

                                                                              1. 1

                                                                                I’m not advocating dishonesty. When asked about your engineering practices and workflows you should definitely answer honestly. (And I guess it’s a good question for an interviewee to ask at an interview)

                                                                                What I’m saying is that maybe you shouldn’t always proactively announce all the warts and issues with your workflow (which also requires that you’re aware of them, which I suspect in enough cases is just not the case. If for example all your staff is using MacBooks you probably don’t even notice that this could be a problem until you have your first hire who doesn’t want to use a MacBook).

                                                                            1. 12

                                                                              Using a single monitor.

                                                                              1. 2

                                                                                I’ve always been of the opinion that multiple monitors don’t make sense. I only look at one monitor at a time anyway, and I can set up my window manager to allow me to switch between workspaces on that monitor with less effort than it takes me to yaw my head.

                                                                                A well configured single-monitor setup is essentially a multi-monitor setup except all monitors are virtual and materialise right in front of you instead of being stuck to your sides.

                                                                                That said, I have been forced to use macOS at work for a while now, for which multiple monitors was more convenient. I switched back to Linux and a proper window manager now while working from home, so we’ll see what happens when I get back to the office.

                                                                                1. 2

                                                                                  I’m using i3, so it’s basically a single key press for me to switch workspaces, and I’m still super happy to have a dual monitor setup.

                                                                                  While it might take the same time to switch workspaces by pressing a key instead of turning your head (I highly doubt that btw) it still makes a difference in terms of cognitive load, because looking around is much more natural than pressing a button. It’s just the way our little monkey brains are wired. With the other workspace you sort of have to be aware that it’s there and actively switch to it (even when you’ve internalized it and built muscle memory). The 2nd monitor is still always in your peripheral vision, you can’t really forget it’s there.

                                                                                  I think you can draw an analogy between the dual monitor setup and the “no modes” philosophy of Larry Tesler. With the dual monitors there are no modes and everything is present at all times. With one monitor you have to repeatedly switch to “2nd workspace mode” (and I say that as a huge fan of vim).

                                                                                  I have one monitor in portrait mode and the other in landscape. Its really helpful to keep my editor on one monitor and my browser with documentation on the other. Or now for video calls I keep the call on fullscreen on one monitor and use the other to take notes and look up stuff.

                                                                                  1. 2

                                                                                    There’s a cognitive difference between having two monitors and one, though - they’re in physically different spaces, and the brain pays attention to geometry and positioning.

                                                                                    I’m not sure if this particular effect applies to anyone, but in my case, it feels like my brain prefers that I keep two windows in physically different spaces (different monitors) rather than “in the same space”, overlapping and being switched via alt-tab. Is this just me?

                                                                                    1. 1

                                                                                      Well, switching applications with alt-tab is nothing like having multiple workspaces set up for quick switching. If all I had was alt-tab, I would also want multiple monitors (and indeed this was the case when I was stuck on macOS.)

                                                                                      For one thing, alt-tab forces you to cycle through all applications, which is the biggest time kill.

                                                                                      Second, alt-tab does not actually do anything until you’ve released the modifier key. That’s a long-ass time to spend on context switching. You would want your workspaces to be set up such that the switch happens as soon as you press the corresponding key, not when you release the modifier.

                                                                                      Third, workspaces are different from individual applications. Workspaces are entire configurations of windows, much like multiple monitors give you.

                                                                                      Fourth, in case it wasn’t obvious at this point: it needs to be really fucking fast. Faster then you can yaw your head. I haven’t tried to clock my workspace switching, but I know if I hold down the “previous workspace” key, it toggles back and forth between the last two workspaces and successfully renders both alternately. Autorepeat rate for my keyboard is set to 25, so switching definitely happens in less than 1000/25 = 40 ms.

                                                                                      Alt-tab cycling on a single workspace is nothing like switching directly and quickly to a screenful window configuration.

                                                                                      1. 2

                                                                                        I’m not 100% sure, but based on some things you’ve said (“instead of being stuck to your sides” and “alt-tab forces you to cycle through all applications” in particular) suggest you aren’t using a tool that makes efficient use of multiple monitors. On Linux, this is understandable, because many of the Free Desktop standards (ICCCM and EWMH) are really inflexible when it comes to multiple monitors. And AFAIK, there’s been virtually no evolution in this space. The only way to make it better is to break the EWMH spec in a couple key places.

                                                                                        In particular, window managers like the one found in GNOME are just absolutely abysmal IMO when it comes to multiple monitors. So much so, that a lot of their advantages are negated for my own workflow. The main problem is that you can only view one workspace at a time and each workspace covers all monitors. That is precisely the model that is enforced by EWMH. A much better model, IMO, is to have one workspace on each monitor with the ability to pull any workspace to any monitor you want. From there, is naturally follows that alt-tab should be among applications on a single workspace, which in this new model, will just be among applications on the currently focused monitor.

                                                                                        This is exactly what motivated me to spend a couple years of my life building WIngo.

                                                                                        When I’m forced to use GNOME, then I hack around some of its limitations with scripts. This one, for example, makes it easy to switch focus between monitors while respecting the relative stacking order of windows on each monitor.

                                                                                        It’s really a pity what EWMH has done to multi-monitor support on Linux. It’s really held it back from being a lot better than it is today.

                                                                                        1. 1

                                                                                          Yes, you misread my comment. It was in reference to the comment above that, where someone explained how they find alt-tab insufficient on a single monitor, which I agree with. Multiple monitors never even entered the discussion!

                                                                                          That said, I appreciate that you shared the information. I agree with most (if not all) of it, and this is also the reason I’m running XMonad, which handles workspaces in a non-EWMH compliant way too. (Maybe even very similarly to Wingo?)

                                                                                          1. 2

                                                                                            Ah sorry about that. I thought I might, hence the hedging. :)

                                                                                            And indeed. XMonad’s handling of multiple monitors is what directly inspired Wingo’s model!

                                                                                            I have fond memories of learning Haskell back in the day just to configure XMonad. Good times.

                                                                                        2. 1

                                                                                          My point doesn’t have anything to do with alt-tab in particular, though - it has to do with mapping different windows to different physical spaces. Workspaces, like you described, still have exactly the same problem - if anything, they make the problem worse, because now you have several different workspaces overlapping the same physical space, and then several different windows per virtual workspace. Additionally, my point is about total cognitive effect, not just the physical speed of whatever method you use to switch windows versus turning your head.

                                                                                    2. 1

                                                                                      I wanted to save some bucks on my electrecity bill so I switched to a single low-power monitor (nothing fancy, just a 22”) from a 3-screens setup + 1 laptop. And, honestly, this new setup is fine. I use Gnome 3 with the “Activities” button to switch between apps, and it works surprisingly well for me (I do programming, mainly).

                                                                                      I have some theories, but I can’t explain why the single monitor setup works so well.

                                                                                      1. 2

                                                                                        I’ve found it to be a good approach for better focus. Also it makes it easier to transition from office to train - I’m not finding the lack of multimonitor a weakness.

                                                                                        Not that train travel is relevant at this moment in time of course!

                                                                                        1. 2

                                                                                          How much electricity do you really save by switching from 3 monitors to one? I mean, electronics tend to be less power consuming than stuff like showers, heating, lights (if not LED), fridge, etc.

                                                                                        2. 1

                                                                                          Here in home office, I miss the second monitor at work. The big thing is remote meetings: With two monitors I can present one and prepare something on the other. With one monitor everybody sees me scrolling through my mails. It isn’t about privacy but about the distraction. Fortunately, confidentially is not that big a topic on my level.

                                                                                        1. 11

                                                                                          For server management: Ansible. I used to build “snowflake” servers, which seemed easier. Until I needed to change providers or upgrade the servers, and ended up spending hours reconfiguring everything from scratch, badly.

                                                                                          1. 2

                                                                                            Did you evaluate any alternatives to Ansible? I love configuration management, but I can’t help thinking sometimes that maybe ansible, specifically, with its sharp corners, inconsistencies, misfeatures, and YAML might almost take longer than just setting it up manually.

                                                                                            1. 3

                                                                                              I love Ansible but I hate Python (relevant XKCD). I’d love to see a faster, more modern competitor written in Go or Rust or something.

                                                                                              People complain about YAML, but what do you want instead? JSON, with no comments? TOML? I’m unaware of a clearly superior YAML alternative. I think a reimplementation of Ansible in Rust that was 100% compatible with my existing playbooks would hit the spot.

                                                                                              1. 3

                                                                                                CFEngine is my go-to solution that is both fast and modern (whatever that means.)

                                                                                                Another superior alternative to YAML is Dhall. (I’ve even thought about compiling a set of Dhall files to a single, big, hard-coded Ansible playbook, just to avoid having to deal with the ambiguities of YAML.)

                                                                                                1. 3

                                                                                                  I’d love to see a faster, more modern competitor written in Go or Rust or something.

                                                                                                  Ansible mostly works by sending python programs to the target server and running them there. I’m not sure how you could make that work with a compiled language. Perhaps you could generate shell scripts and run those there? But then your requirement of “faster, more modern” might be at risk :)

                                                                                                  I’m unaware of a clearly superior YAML alternative.

                                                                                                  1. 1

                                                                                                    You’re quite right, I realized this some time after I posted… I didn’t think very hard about the specific languages I suggested. Those are fun languages but maybe not ideal for Ansible’s use case.

                                                                                                    Are there any interpreted languages you like better than Python?

                                                                                                    Obviously part of why Ansible uses Python is because Python is installed by default on most Linux systems, so you can start running Ansible plays without installing anything at all on the target host. A more obscure language would be worse for that purpose.

                                                                                                    But let’s imagine that you are Google or someone with the resources to make your favored language popular. What interpreted language could improve on Python?

                                                                                                    1. 2

                                                                                                      Common Lisp is probably the one that can beat Python, but that of course has significant learning hurdles for most people. CLISP’s installed size is 17.6MB on Arch Linux, SBCL 58.8MB and python 80.7MB. The comparison is a bit unfair since python has more batteries (many of which are important for Ansible!) out-of-the-box, but perhaps shows that including a Common Lisp into distros by default wouldn’t be totally absurd.

                                                                                                      1. 1

                                                                                                        including a Common Lisp into distros by default wouldn’t be totally absurd.

                                                                                                        I’m assuming SBCL is free/open/libre? My impression of the Common Lisp ecosystem is that it’s a morass of licensing issues.

                                                                                                        1. 1

                                                                                                          Seems to be Public Domain / BSD, with 4 copyright notices: https://sourceforge.net/p/sbcl/sbcl/ci/master/tree/COPYING

                                                                                                  2. 2

                                                                                                    People complain about YAML, but what do you want instead? JSON, with no comments? TOML? I’m unaware of a clearly superior YAML alternative.

                                                                                                    I’m using Nix with NixOS. As a language Nix is not necessarily better than YAML, in fact it has a pretty confusing syntax imho and has suffered from its success, because you can’t change it. It never was a very good case of programming language design, but it is an excellent tool for package management, state management and deployment/orchestration, because of the overall system design.

                                                                                                    I would love to use Guix, which uses the same basic model of declarative package management/state management, but uses Guile Scheme for all configuration management and packaging. But the Guix community is even smaller (NixOS is already pretty niche) and there are way fewer packages.

                                                                                                  3. 2

                                                                                                    Maybe mgmt ? Not quite as feature rich yet….

                                                                                                    1. 1

                                                                                                      Thanks for the tip! It’s a different design than Ansible, and I’ll have to research it more to see how I feel about that, but it looks like what I was asking for.

                                                                                                    2. 1

                                                                                                      I’ve also used Puppet, which is more demanding about using the tool properly. Ansible OTOH feels like a fancy bash script, with all of the upsides and downsides of that.

                                                                                                  1. 36

                                                                                                    magit, a git porcelain for emacs. It’s reason enough to be using Emacs, if for nothing else, imho (of course you benefit if you also use emacs for other stuff). I’ve seen my share of git GUIs and most of them are extremely clunky, require a mouse, and support maybe 10% of git, so as soon as you don’t just need to git add; git commit; git push you need to fall back to the cli. Magit offers a extremely consistent and powerful UI. You can easily manage multiple remotes, rebase, cherry pick, stash, reset, etc. And while the git cli has improved drastically in terms of consistency and usability, for some things it’s just so much faster to have a graphical UI.

                                                                                                    Disclaimer: I’ve only used Magit as configured with spacemacs. The vanilla Emacs version might have slightly different keybindings, but the overall point still stands.

                                                                                                    1. 6

                                                                                                      I find magit especially powerful because it’s context aware.

                                                                                                      Want git log for a file? Just M-x magit-log with that file open, and it will default to the right options.

                                                                                                      Want to check a file on a different branch? M-x magit-find-file allows you to open any file on any commit without having to switch branches.

                                                                                                      Not to mention that you can hook up your VCS provider like Github as well, and get things like “checkout this PR” with a few key presses.

                                                                                                      All of these are available outside of magit, but require much more setup, which isn’t worth it for the odd command you run every couple of weeks.

                                                                                                      1. 2

                                                                                                        Want git log for a file? Just M-x magit-log with that file open, and it will default to the right options.

                                                                                                        I’ve always just used magit-status, so I’m not sure, but I don’t have a magit-log command on my system…

                                                                                                        1. 4

                                                                                                          Definitely exists on mine, along with almost 500 other commands starting with magit-. I’ve noticed that magit is incredibly context-aware if you run commands directly from file-buffers, and often does exactly what I want it to do.

                                                                                                          1. 2

                                                                                                            Ah, I found it, but it’s an obsolete command:

                                                                                                            magit-log is an alias for ‘magit-log-other’ in ‘magit-obsolete.el’.
                                                                                                            
                                                                                                            (magit-log REVS &optional ARGS FILES)
                                                                                                            
                                                                                                            This function is obsolete since Magit 2.90.0;
                                                                                                            use ‘magit-log-other’ instead.
                                                                                                            

                                                                                                            which is probably why I couldn’t find it at first.

                                                                                                            1. 1

                                                                                                              I believe this is what I’m calling.

                                                                                                      2. 4

                                                                                                        Or just ediff-merge, even without magit (I used it with psvn mode as well, for example). That thing is awesome and I can’t imagine how I ever got by merging manually by opening a file with conflict markers.

                                                                                                        For those not in the know: you get three buffer panels. One is version A (your version), the other is version B (the version you’re merging into yours) and the third is the final file. Then you can flip through conflicted sections and choose A or B, and when you’re confused you can overlay the ancestor on the merged buffer so you can see what has changed. There are dedicated tools like meld which do more or less the same (though I find meld’s specific UI rather confusing), but having everything inside your nice editor just makes it that much nicer (because you sometimes end up making tweaks in the merged version).

                                                                                                      1. 7

                                                                                                        My first experience with this idea was Sublime Text’s Ctrl-P. Every program needs it’s own Ctrl-P.

                                                                                                        Nice to see the idea spreading!

                                                                                                        1. 7

                                                                                                          Emacs’ M-x takes this one step further imo, in that it exposes every function that is reachable through the GUI as a callable function with a text interface. Of course the whole thing is quite dated and could use some modernizations, e.g. context awareness and a nicer graphic design, but the basic idea is there and super powerful.

                                                                                                          1. 2

                                                                                                            That’s where helm comes in!

                                                                                                            1. 1

                                                                                                              Emacs’ C-h k and C-h w are great, too. The former tells you the function bound to a key, and the latter tells you which keys are bound to a function.

                                                                                                            2. 2

                                                                                                              Ubuntu experimented with something similar with Unity, where hitting a specific key combo would let you search the menus of the current application. I thought it was cool, and a nice alternative to scanning menus.

                                                                                                              1. 2

                                                                                                                Care to explain what Ctrl-P does in Sublime for those of us who don’t use Sublime?

                                                                                                                1. 3

                                                                                                                  I haven’t used Sublime in years now, but IIRC it is a fuzzy finder, opening files, function defintiions etc in the same place, which inspired ctrlp.vim plugin and other similar plugins

                                                                                                                  1. 2

                                                                                                                    Ctrl-p exists in VSCode, chrome devtools. Even Visual Studio has this in the form of Ctrl-Q, though it doesn’t search the files.

                                                                                                                    1. 3

                                                                                                                      The version 1 of Sublime Text is from 2008. The version 2.0 dates back 2012. This editor came long, very long, before VSCode, and Atom etc..

                                                                                                                      But maybe Sublime Text took inspiration from another software that predates. In which case I don’t know which one it is.

                                                                                                                      I remember trying SciTE, Scintilla and TextMate. But chose Sublime Text compared to them.

                                                                                                                      1. 1

                                                                                                                        I should have been more clear. I intended to say, it exists in those editors now. I am pretty sure it is a sublime innovation.

                                                                                                                        1. 1

                                                                                                                          I also thought so, but reading other comments they say it’s in Emacs. Meta-x . emacs is even way older :-)

                                                                                                                          I use Emacs really roughly, essentially for magit. I’ll have to check this M-x but I don’t edit projects in emacs in general….

                                                                                                                  2. 1

                                                                                                                    It’s the Sublime equivalent of M-x.

                                                                                                                1. 3

                                                                                                                  This strongly reminds me of xiki which I found promising a few years ago:

                                                                                                                  Ligth overview:

                                                                                                                  Source:

                                                                                                                  There had been some crowd founding for this project years ago. But it did not gain the momentum I was expecting. My usage was more of a exploratory thing, and I did not invest in using it longer cause I switched OS (NixOS), and I have not tried on it.

                                                                                                                  But that gave me a good lasting impression of a possible future for CLI interfaces.

                                                                                                                  1. 4

                                                                                                                    I remember when I first stumbled upon Xiki I was amazed by its flexibility. Sadly it didn’t really make it much beyond a prototype stage and nowadays it seems pretty dead.

                                                                                                                    It also reminded me of the Acme editor from plan9. And a little bit of squeak/e-toys. Being able to very easily create some one-off interfaces for special use cases is super powerful.

                                                                                                                    But to be really useful you need tight integration with many parts of the operating system and other software and those integrations need to be written and maintained by someone…

                                                                                                                    Also I think this coincides nicely with the post on text based cli tools by danluu from a few days ago. It helps immensely to have some structured information on how your tools compose and what data they expect, because it allows you to generate these sorts of interfaces and good context aware autocompletion.

                                                                                                                  1. 1

                                                                                                                    I really like that there is support for pie/radial menus and it’s demonstrated in the README.

                                                                                                                    1. 10

                                                                                                                      Or you might just use for example a ClojureScript wrapper for React, which simplifies usage quite a bit (taking advantage of the immutable persistent data structures for automatic and efficient diffing), enjoy all the benefits of Google Closure, have a single build tool (for back & frontend if you use Clojure on the server side), and be done.

                                                                                                                      Honestly though, I’m not sure if it’s a great idea to advocate for vanilla JS. Sure, if all you want to do is register some click handler to send an XHR or make the background change color based on the time of day – basically the little bits of interactivity JS was initially designed for – then go ahead and use the bare minimum of what’s necessary. But if you’re planning to do a slightly more complicated “web app” I’d say there’s a reason why all those technologies exist and more often than not you add a feature here, expand something there, and find that your application has grown beyond its initial scope (OK, the proper thing to do would probably be to do a complete rewrite using what you’ve learned thus far, but that’s seldom what gets actually done).

                                                                                                                      1. 6

                                                                                                                        This is exactly what we’re doing, and my experience is that the apparent complexity as a dev working in cljs/om is far less than using ad-hoc jquery on top of some arbitrary templating language like erb or haml. We have a full fledged, well-designed application for our frontend, and the only language I write is clojure(script).

                                                                                                                      1. 7

                                                                                                                        Still working on stuff for the final sequence of the book.

                                                                                                                        Rolling things around in my head for monitoring and logging for the production AWS deployment I got setup for $dayjob. Currently thinking about Prometheus & Elasticsearch/Kibana.

                                                                                                                        Somewhat unhappy so far with Ansible, though I have beaten it into place. Malcontent is from knowing what convergence in config management could/should look like. Wondering if I should pick Puppet back up or look into Chef. Or something else entirely - Propellor is Haskell, for example, but not entirely different from Ansible. Talking me down from this ledge is welcome, but what I really want is a config management system that:

                                                                                                                        1. Uses the type system to prevent unforced errors in your deployment & provisioning

                                                                                                                        2. Can self-bootstrap or do one-off deploys like Ansible without obligating you to manually provisioning a client for a server-client setup (a la chef zero)

                                                                                                                        3. Has an optional “plan” mode like Terraform for letting you know what it would change, ideally runnable from the dev’s computer. Ansible’s dry-run is not good enough.

                                                                                                                        Keep trying to think about alternatives to LaTeX, but there really isn’t anything better as far as I can see. I’ve given Prince XML a try, but it’s not better.

                                                                                                                        1. 1

                                                                                                                          Have you had a look at Scribble? I can’t speak from experience but it might be something to look into.

                                                                                                                          1. 1

                                                                                                                            Scribble’s a documentation tool, not typesetting. I had to do a lot of work to make the Haskell book look professional and using something like Scribble drops all that on the floor.

                                                                                                                            The other problem I’m having is that anything capable of equivalent or better fidelity (InDesign, Framemaker, Scribus) is either proprietary, not available on Linux, or not very automated.

                                                                                                                        1. 4

                                                                                                                          Maybe this will make http://gridstylesheets.org/ more viable. Would be nice. (Although I’d still love to see native support)

                                                                                                                          1. 18

                                                                                                                            Howdy all.

                                                                                                                            Been a month since I posted. Sometimes it is just hard to find the energy to write given how much I have to get done. But lately, I’ve been finding it useful to write to help me think through decisions or to make notes to remind future-me of what I was thinking now. Along those lines, I wrote GraphQL beyond the web and Finding a User Interface Library this week. The GraphQL post is essentially a follow up to a post from last week, Querying OS Information.

                                                                                                                            In related areas, I’ve been working on fixing up some stuff in Ant Design, a UI library for React. (No, I don’t speak or read Chinese, but there’s no reason to let that stop me.) I’m hoping to help them with a translation of their documentation and web site into English.

                                                                                                                            I’m still doing a lot of work on Open Dylan as well. I helped someone out with their UUID library last week and did some further improvements to my libsodium bindings. I need to improve the libsodium bindings a bit more so that I can get further with my implementation of macaroons.

                                                                                                                            I’ve also been spending a lot of time with my 5 year old daughter, reading to her, helping her read, and teaching her about some of the fun sides of math. Also had another beautiful skink visit our yard.

                                                                                                                            1. 2

                                                                                                                              At one point I was thinking about using GraphQL to implement an interface to the Docker daemon API. It’s nice to see exploration in similar areas.

                                                                                                                              1. 2

                                                                                                                                Thanks for the link to Ant Design, that does look interesting. I’m sad that there isn’t a HTML standard for a datepicker, so something like this might be the next best thing.

                                                                                                                                1. 1

                                                                                                                                  If you want their date component, but without all of their style and other stuff, it is available as a separate component from react-components/calendar. But I like the Ant look, so I’m happy to get it all in a single package. :)

                                                                                                                                2. 2

                                                                                                                                  I was thinking of writing an interface to query OS info through SPARQL. But haven’t found the time and necessary motivation and tech to build upon yet. GraphQL is syntactically cleaner IMHO, but I think there is tremendous value in having a high level query language for those sort of things at all (and SPARQL has been around for some time).

                                                                                                                                  1. 2

                                                                                                                                    Hello!

                                                                                                                                    I thought about that too and talked about it some with @coreload who is a big proponent of SPARQL and related technologies.

                                                                                                                                    I ended up coming down to the issue that GraphQL is just so much easier and lighter weight to implement and it lets me do exactly what I need in this case, and I’m able to do it in a bit of C that can run on almost any device. I didn’t know of any implementation of SPARQL that would allow me to do the same. Further, if I wanted the capabilities that SPARQL offered, I’d probably want them in whatever front-end I was writing and just by the nature of having my data in a structured format (ala JSON / JSON-LD), I’d be able to pump that into a more capable system when needed.