Threads for sohalt

  1. 13

    The license is interesting; I can’t recall ever seeing this before. Is that something you added yourself? If I search for “Interface-Protection Clause” then it just turns up this project.

    It’s kind of contradictory though, because first it says:

    Without limiting other conditions in the License, the grant of rights under the License will not include, and the License does not grant to you, right to Sell the Software.

    But then in the MIT license:

    Permission is hereby granted [..] to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software.

    Wouldn’t it be clearer to just modify/write a new license instead of putting a clause on top which contradicts the next clause?

    1. 6

      Good to notice. Then it is neither free software nor open-source.

      1. 4

        It is free to use, and the source is available for everyone to see and modify.

        1. 19

          This license will ensure that nobody will touch this software.

          1. 9

            I don’t see why; it doesn’t restrict almost any use case, and I don’t see any fundamental objections, and minor issues of language (if any) are fixable. Who cares about some arbitrary list that some arbitrary organisation made decades ago?

            1. 4

              It essentially makes it against the license to pay anyone else to make modifications of the software, and that could include employees.

              That arbitrary list is fundamental to the essence of the license, so who cares? The legal department cares.

              1. 4

                It essentially makes it against the license to pay anyone else to make modifications of the software

                What makes you think so?

                1. 3

                  For purposes of the foregoing, “Sell” means practicing any or all of the rights granted to you under the License to provide to third parties, for a fee or other consideration (including without limitation fees for hosting the Software), a product or service whose value depends, entirely or substantially, on the third party having access to the interface of the Software.

                  So this would seem to limit any ability to retrieve monetary compensation for any of the rights later listed in the license: “including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,”

                  1. 4

                    “Sell” means … a product or service whose value depends, entirely or substantially, on the third party having access to the interface of the Software.

                    If the Preql language itself isn’t a substantial part of your product (and in most cases, it wouldn’t be), then you’re not selling it, the clause doesn’t apply, and your license is effectively MIT.

                    1. 8

                      If the Preql language itself isn’t a substantial part of your product (and in most cases, it wouldn’t be)

                      Imagine that you are in that position – author of such product or a manager. How could you be sure that it is „not a substantial part“?

                      1. 1

                        If you are not sure, then it probably is. I don’t see how it could become such, unless it’s on purpose.

            2. 2

              I hope you’re wrong.

              1. 16

                Not a lawyer, but in many of the companies I worked for, there was a whitelist of licences. If we wanted to use something and license is on the whitelist, we were free to do so. If the license is on another list, if we build a good enough case and endure several meetings with managers, we could use it. If the license is completely new, that means involving lawyers, which almost no one bothered to do and people just went looking for other stuff or implementing things from scratch.

                1. 7

                  I know you don’t create these policies and that it’s not your intention to say exactly this, but what you’re saying pretty much comes down to “gimme free labour or I don’t want it” in practice.

                  1. 10

                    I doubt it’s about it being free; most companies would gladly shell out money to buy nonfree software, yet still be very wary about using code under a legally untested or unclear license. It’s all about ass-covering; companies are terrified they might get sued by some patent troll or copyright holder (think stuff like Oracle suing Google over their reimplementation of the Java APIs).

                    1. 6

                      Yes, exactly. Most of the companies I worked for were even requiring that we pay for support (when it existed), as any downtime costs money. As you nicely put, it’s all about risk mitigation – no one want to have their reputation tarnished or involved lawyers, as it means loss of money or reputation.

                      1. 5

                        Yeah, but how would you actually convince them to pay you if you use a standard open source license? There’s no obligation at all to pay anything, and in practice most won’t, or throw only breadcrumbs your way.

                        I’m absolutely not a money-driven person, but “sending back patches” puts just as little bread on the table as “make me free stuff for exposure” does for artists. I feel a lot of people are rather naïve about this. Sure, open source ideals and all of that are wonderful and in a perfect world we’d all be happily coding together and paying our fair share. But not everyone is playing by the same rulebook here. Jeff Bezos’ goal is to make profit, nothing more, nothing less. If he can make profit by paying you $1 instead of $10 while netting $100k then he will have no qualms in doing so. He doesn’t care one iota if that $1 is a living wage or anywhere near “fair” or proportional. Jeff Bezos is hardly an outlier here.

                        How much money does CodeYellow send to Debian, PostgreSQL, PHP, Laraval, and all the other projects you use (assuming you still work there)? Perhaps CodeYellow is better most – that would be nice – but all companies I worked for that amount was literally “$0”. And sure, CodeYellow provides plenty of added value, but just as a builder pays for their raw materials, it doesn’t strike me as unreasonable that CodeYellow (and AWS, etc. etc.) also pays for them.

                        At any rate, if you’re concerned about the non-standard license then you can simple contact the author to buy a different one. Sure, it’s a bit more effort, but you can’t have your cake and eat it too.

                        1. 2

                          Yeah, but how would you actually convince them to pay you if you use a standard open source license?

                          That’s one of the great unsolved problems of our age. I think there are some nice initiatives around (like for example GitHub’s sponsoring option) but they’re not gaining a lot of traction yet.

                          There’s also the question of distribution: how do you fairly distribute any payment/sponsorship across a large open source project? One-man projects are a different story of course, but a lot of the widely used projects are multi-person efforts.

                          I’m absolutely not a money-driven person, but “sending back patches” puts just as little bread on the table as “make me free stuff for exposure” does for artists. I feel a lot of people are rather naïve about this.

                          Totally agree on this. For myself, open source was always more about freedom of source and didn’t care as much about money, but then the vast majority of companies don’t subscribe to these ideals and just take the free software and lock it away. And it could be argued the world would be a much better place if people would be able to make a living off of free software, because it would mean more viable free software could make its way into the hands of actual users, and less developers would feel like they’d have to work on proprietary software to support their free software producing “hobby”.

                          How much money does CodeYellow send to Debian, PostgreSQL, PHP, Laravel, and all the other projects you use (assuming you still work there)?

                          I left a couple of months ago, I’m now working at bevuta IT on a project for the EU, which is likely to be open sourced.

                          Code Yellow actually sponsored a CI test server for the CHICKEN project and of course I was paid to work on some open source projects of our own. But I agree with you, most companies don’t pay at all, and as far as I remember, Code Yellow did not sponsor any of the projects we were actually using day to day (unless you count the odd code contribution and bugfix) that weren’t developed in-house.

                          1. 5

                            I think GitHub sponsors is great and I don’t want to knock it, but it’s also not really a viable business model. You certainly can make a living out of it (people are), but it’s not easy, mostly works well for individual devs (rather than business), and is not suitable for all projects either (generally only for “user visible” projects, and even thn only for “dev users”, rather than the general population).

                            Take something like vim-go for example; the current maintainer nets $102/month (the previous maintainer got a bit more, about $400/month IIRC). All of that is nice pocket change, but is it really in proportion to the usage? Even with just 5,000 companies using it (probably a low estimate) times $1/month we would be talking about $5k/month. We could discus what a “fair” amount would be exactly for a long time, but these are tiny investments, and if you consider your devs will get a better editor in return it’s an investment that will actually give you a return too.

                            The entire world and their mother is running OpenSSH, but OpenBSD still gets in to intermittent financial troubles. They run on $300k/year (2020 fundraising goal; CAD, about 240k USD), which may sound like a lot, but this is the salary of what, one dev in silicon valley? Maybe two? Even by the lower European wages we’d be talking about ~4 devs. Spread out over all users of the software this is nothing. The kind of money you won’t even bother picking up if you drop it.

                            If every company would pay $1 for ever open source tool, library, or application they use we’d be talking about a $100-$200/month investment, at the most, and often probably much smaller (let’s ignore npm and it’s 20k dependencies, that’s a special problem). This wouldn’t solve everything, but it’s a simple start.

                            Yet it’s not happening; not even close. In my observation most people sponsoring projects tend to be private individuals like you and me, who care about these things. I feel a big reason it’s not happening is because companies don’t have to and just can’t be bothered. So what you need is the proverbial “stick behind the door”, which is what these kind of licenses are. It’s sad that this is needed, but it is what it is.

                            Or, maybe, what we need is a single organisation that you can tell “we use these projects” and pay that $100/month (or whatever is appropriate), and they distribute it to the projects. This would certainly simplify the administration and burden for the companies, as well as lower payment processing overhead and the like. One would imagine that something like the FSF would do that, but they seem more concerned with their crusade to fight the Open Source pagan heretics, or something, and the OSI doesn’t seem to be doing much at all except bicker amongst themselves and write blogspam.

                            It’s kind of hilariously sad that GitHub Sponsors is an initiative from a company mostly writing proprietary software. I’m not a purist and don’t see it as a terribly great problem as such, but my irony meter is going in to overload.

                            For myself, open source was always more about freedom of source and didn’t care as much about money

                            Yeah, I don’t really care about it as an end-goal either; just as a means to ensure viability.

                            I left a couple of months ago, I’m now working at bevuta IT on a project for the EU, which is likely to be open sourced.

                            Aha, nice; it mentions that “CHICKEN Scheme is one of our favourite programming languages” :-) Looks like Felix is working there as well?

                            1. 4

                              Looks like we’re in total agreement about this.

                              So what you need is the proverbial “stick behind the door”, which is what these kind of licenses are. It’s sad that this is needed, but it is what it is.

                              Here you run into the problem that these licenses are “new” and untested in court, so legal departments won’t touch them with a ten-foot pole. It also doesn’t help that they don’t match the OSI’s criteria (or the FSF’s), which such licenses won’t be endorsed by trusted parties.

                              maybe, what we need is a single organisation that you can tell “we use these projects” and pay that $100/month (or whatever is appropriate), and they distribute it to the projects.

                              This sounds like a good solution and something the FSF (or FSFe) could be doing. Have you contacted them to suggest something like this? It seems that recently the FSF is doing some good advocacy (like the public money, public code campaign and the ethical tech giving guide) instead of just preaching to the choir like they used to.

                              Aha, nice; it mentions that “CHICKEN Scheme is one of our favourite programming languages” :-) Looks like Felix is working there as well?

                              Yep, I have several colleagues that I’ve known for a while and am happy to finally be working with them!

                              1. 1

                                While I’ve argued the that FSF/OSI should do more direct funding of projects many times before, I didn’t have that specific idea until I wrote that comment. So, no, I haven’t contacted them yet :-) You’re the first I told it to! Consider yourself special!

                                I hope to finish my article about this soon™; I’ll be sure to post it to those kind of channels as well. It’s good to hear the FSF is improving (finally…)

                                As for the license, you can still sell access to a more standard license if you want, like SQLite does (even though it’s public domain).

                      2. 5

                        This is exactly how corporations or software departments often work. If something is free of charge, they will use it. Why not? On the other hand, they are usually ready to pay for proprietary software or external services. So the strong copyleft + dual-licensing is the way to go. Your software will then fall in the „proprietary software“ category for them, but it is no problem. Their lawyers will be happy in the same way as if the company buys a license for Photoshop, AutoCAD, Oracle DB, Total Commander, WinRAR etc. and you will get money.

                    2. 3

                      Well with regular software licensed in common open source ways, nobody else is prevented from modifying it or hosting it for a fee. You have essentially limited the users of to exactly one person who can do anything involving any kind of money for the software. That is a non-starter for almost anyone outside of the plain hobbyists - and it effectively preventing any adoption besides a few insignificant users.

                      Looking at the license, it isn’t entirely clear what “interface of the Software” means either.

                      1. 4

                        Then I think you misunderstood.

                        It is possible to create commercial software that uses Preql, with or without modifications, and sell it however you want. The only limitation is that in that case, you can’t provide the language itself to your users (i.e. the interface). That restricts specific use-cases, such as offering it as a cloud service to developers, or selling a Preql plugin to existing database software.

                        1. 2

                          It is possible to create commercial software that uses Preql, with or without modifications, and sell it however you want.

                          you can’t provide the language itself to your users (i.e. the interface).

                          Can you explain what exactly that means? How do I include the language without modifications but not provide the language to the users??

                          1. 6

                            It means you can’t provide a product which is built around the ability for users to use the language directly.

                            Integrating it in your desktop or web app and selling that is okay.

                            Making AWS SuperQL™® or CloudPostMyMariaSQLiteBlockchainML++ which are essentially cloud versions of of Preql (and thus expose the language/interface to users directly, as a major feature) would not be okay.

                            In short, it’s intended to prevent exploitation from these kind of people, as they have done before and will undoubtedly continue to do in the future.

                            1. 3

                              Let’s say you are writing a product that uses Preql to save and fetch user data from the database. It is called from internal routines, that respond to unrelated user activity. In that case, there is no reason for the user to ever write any Preql code, which means he isn’t being given access to the language. In that case, Preql can be used under MIT conditions, and you can sell your product without a worry.

                    3. 3

                      “free to use” and “free software” are not the same thing. I don’t know if your rider actually excludes you from being free software or not.

                  2. 6

                    I’ve spent a lot of time thinking about the license, and I could not find anything that fit what I wanted. It’s a long discussion, but I believe the popular licenses are flawed, in that they don’t properly support those who want to be able to write open-source for a living.

                    The one that came the closest was The Commons Clause (https://commonsclause.com/), and I modified it. But the “contradiction” you mention was already there, purposely put by a well-respected lawyer.

                    Wouldn’t it be clearer to just modify/write a new license

                    Maybe I think too much like a programmer, but I don’t see why I shouldn’t write my license using a “library license”, well-tested and recognized, instead of reinventing the entire wheel from scratch.

                    1. 23

                      Maybe I think too much like a programmer, but I don’t see why I shouldn’t write my license using a “library license”, well-tested and recognized, instead of reinventing the entire wheel from scratch.

                      This is akin to having a lawyer write your auth code.

                      1. 3

                        Right; fair enough. I had temporarily forgotten about the Commons Clause 😅 I never really liked the “tacking on” of that either, but if it works (legally speaking), it works, so whatever.

                        I think your license and modifications to the Commons Clause make sense, by the way; by removing the “consulting/ support services related to the Software” and changing “whose value derives, entirely or substantially, from the functionality of the Software” to “the third party having access to the interface of the Software” it limits the scope a lot to what you actually want to prevent.

                        That being said; I’m very far removed from being a lawyer. Perhaps @kemitchell wants to chime in?

                        1. 3

                          don’t properly support those who want to be able to write open-source for a living.

                          I recommend using a strong copyleft license (GPLv3 or AGPL) and dual-licensing. You can sell licenses that allows use inside proprietary software or services (that do not provide source code and rights to the end-user).

                          And if someone complies with the copyleft license and provides all the rights and code to the end-user and make some money while doing it – does it harm you in any way?

                          1. 2

                            What the commons clause claims in its FAQ vs what it says in its content are very different. To quote the clause itself:

                            For purposes of the foregoing, “Sell” means practicing any or all of the rights granted to you under the License to provide to third parties, for a fee or other consideration (including without limitation fees for hosting or consulting/ support services related to the Software), a product or service whose value derives, entirely or substantially, from the functionality of the Software. Any license notice or attribution required by the License must also include this Commons Clause License Condition notice.

                            I specifically want to call out this bit:

                            a product or service whose value derives, entirely or substantially, from the functionality of the Software.

                            What does “substantially” mean? When does use of software under the commons clause become substantial enough to be in violation of the license? More than anything, lawyers hate ambiguity. This line is very ambiguous.

                            Your modified version of the license reads:

                            a product or service whose value depends, entirely or substantially, on the third party having access to the interface

                            “Access” is not defined. One could argue that “access” means that the code paths are being exercised by code available to a third party. This modification, in my opinion, is more restrictive and more ambiguous than the original commons clause.

                            I understand that your objective is to prevent this from being repackaged and sold directly as a product. This is a pretty hot topic in general right now and I’d say no one has quite figured it out. That said, based on my experience with 3p OSS licensing, no company would knowingly accept this license for any use case. Commons clause is already a tough sell and the modifications made make it near impossible. If you’re open to feedback, I would strongly consider using the Commons Clause language without modification.

                            1. 2

                              Thanks, I appreciate the feedback. I was also concerned about the meaning of substantially, but since it only applies to access to the interface, that shouldn’t be a problem. I suppose I can be more specific about the use of the word “access”. In essence, it can be solved by being described as a dataflow query (i.e. taint analysis).

                              But the Commons Clause, as it is, is too restrictive, and will drive away many of the early adopters.

                              I’m definitely open to feedback. Like you said, no one has figured it out yet. And I might change my license in the future. But at the moment, I don’t see an alternative.

                            2. 2

                              Maybe I think too much like a programmer, but I don’t see why I shouldn’t write my license using a “library license”, well-tested and recognized, instead of reinventing the entire wheel from scratch.

                              Common practice is that amendments* to a license loosens original rules and adds more rights to the licensee. So using a name of a well-known license as your „library license“ and adding a restricting amendment is at least confusing.

                              Using the name of an original free software / open-source license is quite parasitic and harmful. Common users will see Apache or MIT + something else that they do not read. Yes, it is their fault that they do not read and understand it fully. But I consider it unethical to exploit someone else’s mistakes this way. Such common users will then doubt whether Apache, MIT or any other free software license grants them rights that it actually grants them.

                              Nobody prevents you from creating a new license or a new category of software. But please, do not exploit existing licenses and categories, well known-names and do not confuse users.

                              *) for example the Classpath Exception that could be added to GPLv2 – licensee can do everything allowed by GPLv2 + something else allowed by the amendment.

                              1. 1

                                Have you thought about using something like https://spdx.org/licenses/BUSL-1.1.html ?

                            1. 4

                              One could require the number to be spelled out, or approximated

                                  Blah blah blah 123456 machines will be affected by this.  Proceed?
                                  Enter, in words, the number of machines to continue: One hundred and twenty three thousand four hundred and fifty six 
                              
                                  To the nearest 10,000, enter the number of affected machines: 120000
                              
                              1. 2

                                Even with something this complex you will have a learning effect set in, if you encounter it too often, where you will eventually mindlessly type in the rounded number without having thought about how big that number actually is and if it’s what you were going for. The only thing that really works is to have the use of this kind of tool be so rare that every time you use it you’re already kind of on alert, because it’s not your usual procedure.

                                1. 6

                                  Yeah, typically I’ll point-and-call these sorts of potentially dangerous actions; it’s saved me numerous times in the past

                              1. 2

                                This is definitely a big improvement over the simple Y/n prompt, but as already hinted at in the post, when you run into this too often it loses its effectiveness. That’s even when you do tricks like the formatting one, because when you do something repeatedly the brain will eventually automate as much as possible of it without having to consciously think about it anymore, even if it is such a “complex” task, as stripping all separators.

                                1. 4

                                  Not really a fan of that syntax. And it seems a little too limited imo. However I really like the idea of having some special purpose programming languages designed to teach about some specific PLT concepts, like variable scope, mutability, pass by value/pass by reference, etc. as presented in https://blog.brownplt.org/2018/07/05/mystery-languages.html

                                  1. 2

                                    I think you’re spot on. I’d never considered the idea of a language to teach people languages, but it makes complete sense when you think about it. Yes it will inevitably have things people don’t like, but the concept to me is something I wish existed at any point while I was learning how to program.

                                  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.