1. 18

    I actually wound up switching off i3 (well, sway, but they’re basically the same) because I kept getting things into weird situations where I didn’t understand how the tiling works. Containers with only one child, that sort of thing.

    river, my current wm, has an interesting model: the layout management is done in an entirely separate process that communicates over an IPC mechanism. river sends it a list of windows, and the layout daemon responds with where to put them.

    Also, since you brought it up: sway is almost entirely compatible with i3. The biggest missing feature is layout save/restore. But it can do one thing i3 can’t do, and that’s rearranging windows by dragging them.

    1. 26

      That’s pretty much why I wrote river. I was using sway beforehand as well but grew increasingly frustrated with how much implicit state i3-style window management required me to keep in my head and how unpredictable that state makes managing windows if your mental model/memory of the tree isn’t accurate.

      1. 19

        link to the project: https://github.com/ifreund/river

        Looks interesting!

      2. 6

        I’m in the same boat (pre-switch). I use sway but, after many years, still don’t really understand how I sometimes end up with single child (sometimes multi generational) containers.

        My personal ideal was spectrwm, which simply had a single primary window and then, to the right, an infinitely subdividing tower of smaller windows which could be swapped in. I briefly toyed with the idea of writing a wayland spectrwm clone.

        1. 7

          That sounds exactly like the default layout of dwm, awesomewm, xmonad, and river. If you’re looking for that kind of dynamic tiling on wayland feel free to give river a try!

          1. 4

            I will! I had some trouble compiling it last time I tried. But I will return to it.

            1. 4

              Feel free to stop by #river on irc.libera.chat if you run into issues compiling again!

          2. 1

            Your reasons for spectrwm (and xmonad’s, etc. model) is exactly the reason I use tiling window managers like i3, exwm and StumpWM: I don’t like that dynamic at all ;-)

            No accounting for different tastes.

            Is there a name for those two different tiling models?

            1. 1

              automatic vs manual?

              1. 1

                I’ve seen the terms static (for when the containers have to be created by the user) vs dynamic used.

                ArchLinux seems to call them dynamic vs manual. See the management style column https://wiki.archlinux.org/title/Comparison_of_tiling_window_managers

            2. 1

              I was also quite lost with the way tiling works at the beginning. There is not much resource around this subject. It seems people just get used to it and avoid creating these useless containers. I am lucky, it was my case.

            1. 28

              I daydream about writing a web browser. Make network requests, parse, render. A modern. competitive browser would be more than a lifetime of work, but getting something that can halfway render an ugly version of simpler pages (say, this site) seems like a fun couple-month project.

              1. 8

                You might be a little late to the party, but SerenityOS is building just that. I forgot how its called, but they are building their own web browser from scratch. May be you can still find some interesting issues to work on (I don’t know if it can render lobste.rs currently). At least it may serve as inspiration and proof that it is possible :)

                1. 1

                  Same! I don’t belive it has to be “modern/competitive”, https://suckless.org/project_ideas/ recommends

                  … a very good knowledge in web standards and how to strip them down to the suckless level

                2. 5

                  Someone showed up in a chat I’m in and started doing just that. For a school project, they said.

                  I was wailing and warning and explaining but now they can parse HTML, CSS and started doing layout. Youth must have been fun. ;)

                  Fwiw, we pointed them to http://browser.engineering/ and https://htmlparser.info/ and https://limpet.net/mbrubeck/2014/08/08/toy-layout-engine-1.html

                  1. 5

                    Sounds like netsurf

                    1. 5

                      Or dillo, or links. I really loved using the latter under NetBSD on my old underpowered iBook G4. That machine was so slow that Firefox was a total resource hog (and it occasionally had weird issues where colors would be inverted due to some endian issue). Dillo development seems to have stagnated unfortunately - I thought it was a really exciting project when I first learned about it (circa 2003).

                    2. 3

                      I’ve actually kinda done that, back in 2013ish. It was able to more-or-less render my old website http://arsdnet.net/htmlwidget4.png and even tried to do dlang.org http://arsdnet.net/htmlwidget3.png

                      I wrote a dom.d module that parses all kinds of trash html and can apply css and do form population etc, and a script.d that can run code to play with that dom, and simpledisplay.d that creates windows… so then thought maybe it wouldn’t be too hard to actually render some of that, so I slapped together https://github.com/adamdruppe/arsd/blob/master/htmlwidget.d too. But like I didn’t have a very good text render function at the time, which is why it is a particular font with some weird word wrapping (it wanted each element to be a single rectangle). The script never actually worked here.

                      The table algorithm is complicated too, so I just did a simplified version. Then of course the css only did basics, like the float left there was the bare minimum to make that one site work. But still…. it kinda worked. You could even type in forms

                      I’m tempted to revisit it some day. I’ve expanded my library support a lot since then, could prolly do a better job. Realistically though links and dillo would still be better lol. but still it is kinda cool that I got as far as I did. The only libraries used if you go down are basic win32/xlib and of course bsd sockets. The rest is my stuff (all in that same repo btw)

                      1. 2

                        Did you see https://serenityos.org/ already? They are re-writing an OS and a Browser from scratch. It looks like a lot of fun.

                      1. 3

                        When using globs, you also have to ask yourself what is the maximum number of files that will exist there. Unix programs have a limit on the number of arguments that they can take and can fail with E2BIG. I’m pretty sure xargs handles that out of the box.

                        Another lesser know trick of xargs is that it can be used to unquote strings like that:

                        $ echo '"foo" "bar"' | xargs
                        foo bar
                        
                        1. 5

                          Tools like snowpack and vite should probably be mentioned. They build on the same premise that ESM is the future, and provide a bridge. UMD modules, React and TypeScript get converted on the fly to ESM modules during development. And it’s still possible to produce bundles for production. The people who benefit the most from ESM are the frontend developers as it provides a fast feedback loop.

                          1. 20

                            (Disclaimer, personal opinion. I work for Mozilla but don’t speak for them)

                            I don’t agree with everything the author says, but it’s interesting that someone is pushing back on the “Safari is the new IE” meme.

                            But I’d say that Apple could still show up more often and more vocally in standards groups and their open objection would be more fruitful feedback that holds everyone accountable for meaningful and interoperable spec development.

                            And still, that all won’t matter if people buy in to the new, “shiny” Chrome APIs and treat them as a standard. Indeed, it’s hard not to given their loud devrel megaphone.

                            1. 3

                              I personally find “Safari is the New IE” to be annoying because it is screamingly obvious to me that Node is the new IE.

                              • Safari has fetch; Node does not.
                              • Safari has supported modules forever; Node is still in transition.
                              • Etc. Etc.
                              1. 20

                                As in, Node.js? I don’t really understand this argument, given that Node is well… not a browser.

                                I guess if we’re changing the question to “What’s the JavaScript ecosystem IE?” instead of “What’s IE that replaced IE for the www?” it could make sense, but in this discussion I don’t quite see how Node’s existence as a whole even matters.

                                1. 3

                                  Frontend coding is being held back by its tools (Node), not the client’s browsers. I don’t support IE11 but I do have to support Node 14.

                                  1. 7

                                    I totally get what you’re getting at and why it’s confusing/ frustrating.

                                    But NodeJS to ever get fetch built-in is unlikely. In fact, even if, it will never be able to work exactly like the browser-fetch (which is a web standard and requires a DOM and an HTML parser and what not). NodeJS plainly doesn’t have all of those required concepts. No origin, no cookies.

                                    1. 2

                                      Deno has fetch already. Node stumbled into the frontend by accident but doesn’t actually care about it. Deno has frontend compatibility as an actual goal, and the difference shows.

                                      1. 3

                                        Yes. Deno is basically implementing a headless browser. It’s NodeJS upside down, so to say.

                                    2. 6

                                      But the sense in which Node doesn’t have fetch only applies outside of a browser. If you’re working on the frontend in a modern browser it doesn’t matter whether Node “has” fetch or not. So I also don’t get your point.

                                      1. 7

                                        It matters because npm is used both to publish node libraries and frontend libraries. The dev then has to use a bundling system like WebPack to convert the libs from one style to the other. I have seen projects where live reload takes a full minute because of that.

                                        Most of that complexity would go away if node supported ES modules and the fetch API.

                                  2. 9

                                    Isn’t Chrome the new IE?

                                    1. 2

                                      The new IE has to be analogous to the old one by being both dominant (like Chrome desktop or Safari mobile) and a drag on standards uptake. Node is completely dominant on the development side and it is dragging frontend development down with its inadequate standards support. Hence QED.

                                      1. 18

                                        A good chuck of those “standards” people moan about Safari not supporting yet, are in fact, not yet standards.

                                        They’re often random shit the Chrome team thought up…. much like all the proprietary shit Microsoft added to Trident ~20 years ago.

                                        1. 5

                                          The new IE has to be analogous to the old one by being both dominant (like Chrome desktop or Safari mobile) and a drag on standards uptake.

                                          That’s not the only way the analogy “has to be” in order to work.

                                          Chrome and IE are both:

                                          • Created by the most powerful tech company in the world at the time
                                          • In a monopoly position such that they can ignore everything other browser vendors do
                                          • Developed in a way that puts the concerns of its parent company over that of its users
                                          • Holding back anti-advertising technology
                                          1. 4

                                            But isn’t Chrome a bigger drag by introducing whatever features they want (and also by owning the standards process so it’s just a rubber stamp on old chrome features)? I see lots of “works best in chrome” sites just like we saw “works best in IE” sites. No so many “works best in node” sites ;)

                                        2. 7

                                          Node is the new JScript.NET?

                                          1. 3

                                            I don’t understand your analogy. Node.js is a back-end technology. The only “web” thing about it is that you can use it to talkie HTTP over a TCP socket, and it happens to use JavaScript as a programming language. I don’t see it as a “web citizen” at all. Complaining that it doesn’t support fetch makes just as much sense to me as complaining that Ruby on Rails doesn’t implement the fetch API.

                                            There’s a huge difference between back-end technologies and web technologies. If you don’t like a particular back-end technology you can just not use it. Don’t like Node’s NPM? Use Deno. Don’t like Deno’s lack of a fetch function? Use Go. Don’t like Go’s concurrency model? Use Rust. Or Python. Or Ruby. Or anything you want. Hell, use PHP. But if you don’t like a particular browser, you don’t have a choice, you have to suck it up and support that browser, or accept that a decent chunk of your users can’t access your site. A bad back-end technology affects only the users who chose to use that back-end technology, but a bad browser affects every web developer.

                                            1. 1

                                              Every single modern website has a front end build system in which packages are downloaded off of NPM and bundled by a Node process.

                                              1. 3

                                                That’s both not true and not relevant…

                                                1. 1

                                                  It is true by definition, because the definition of a modern website is one with a frontend build system that downloads packages off of NPM and uses a Node process like Webpack to bundle them. You can like or not like this state of affairs, but it is absolutely true that when people talk about “modern frontend” this is what is meant by “modern”. See eg https://medium.com/the-node-js-collection/modern-javascript-explained-for-dinosaurs-f695e9747b70 which is 4 years old and uses my definition of “modern”.

                                                  It is relevant because while there are still plenty of websites which use little JavaScript or use only a handful of manually curated jQuery plugins, that is no longer considered “modern” and new sites with well trained frontend developers don’t follow that old pattern any more.

                                                  My hope is that we will soon see the emergence of “postmodern” frontends that use Deno or at least not Node, but it’s still fuzzy, and e.g., if you want to use Tailwind CSS, you need to optimize it with PostCSS, which means you need Node.

                                        1. 4

                                          If even Apple and Microsoft aren’t able to keep up with the pace of change, maybe the issue lies somewhere else. Where are the efforts to simplify the web? Most of the things Google seems to be doing is adding more and more features, ever-increasing the complexity and attack surface of the web.

                                          1. 43

                                            Tell me your job is operating kubernetes and you want job security without telling me that your job is operating kubernetes and you want job security.

                                            1. 8

                                              I find it disappointing that the top comment, with ~30 upvotes and unchallenged for several hours, is cynically questioning the author’s motives. Isn’t there already enough cynicism in the world? We should be better than that.

                                              1. 6

                                                It’s meant to be taken humorously. The author’s main argument is an appeal to expertise with the statement that he mixed the kool-aid. The rest of the article is based on personal opinion so there isn’t much else to say. If you have a similar experience to the author then you will agree, otherwise not.

                                                1. 2

                                                  I don’t know, every article about kubernetes is followed by some comments about how there are some conspiracies, and how anyone pro-Kubernetes must be some shill or insecure software engineer looking to hype the industry so they can have jobs. To me this sounds more like low quality troll comment than humor. There’s nothing technical or insightful in @cadey comment.

                                                  1. 10

                                                    My comments were meant to be taken humorously. This exact comment is in the vein of a rich kind of twitter shitposting of the model “tell me x without telling me x” as a way to point out ironic or otherwise veiled points under the surface of the original poster’s arguments. I am not trying to say anything about the author as a person (English is bad at encoding this kind of intent tersely) or anything about their skill level. I guess the true insight here is something along the lines of this Upton Sinclair quote:

                                                    It is difficult to get a man to understand something, when his salary depends on his not understanding it.

                                                    I also burned out on kubernetes clusterfucks so hard I almost quit tech, so there is a level of “oh god please do not do this to yourself” chorded into my sarcastic take.

                                              2. 2

                                                fwiw - I am currently unemployed and working on a startup in an unrelated space. I haven’t worked on Kubernetes in 2 years.

                                              1. 8

                                                Or use systemd timers. They work as expected and are more flexible to use.

                                                1. 3

                                                  Not everything uses systemd.

                                                  1. 3

                                                    But if your system does, then systemd timers are probably a better choice. Cronic looks great for the other systems.

                                                1. 2

                                                  I made another pass over this. There are a few TODOs but it lists almost everything.

                                                  Let me know what you think! The language is still open to suggestion, especially from people who try it on real use cases. Actually almost everybody who has tried it has ended up influencing the language in some way (e.g. Till Red, Raphael Megzari recently)

                                                  1. 3

                                                    It was nice to read. While Oil often appears on this site, I didn’t really understand what the language is trying to do until now. It takes the conveniences of shell programming, not having to escape every string every time. And adds JSON data structures on top.

                                                    1. 2

                                                      Yes that’s one way to describe it! JSON is an almost universal interchange format, and a shell that has JSON support should also have JS/Python-like data types and expressions to complement it.

                                                      I have a draft of a blog post called “Essential Features of the Oil Language” which describes these as the four main features:

                                                      1. Python-like data types and expressions
                                                      2. Egg Expressions (Oil Regexes)
                                                      3. Abstraction With Shell-like procs and Ruby-like blocks
                                                      4. Interchange formats like JSON and QTT (quoted, typed tables)

                                                      https://oilshell.zulipchat.com/#narrow/stream/266575-blog-ideas/topic/Five.20Essential.20Features.20of.20the.20Oil.20Language

                                                      On the compatible side, we have Four Features of the OSH Language:

                                                      1. Reliable error handling (errexit)
                                                      2. Safe handling of user-supplied, untrusted data (QSN, etc.)
                                                      3. Eliminate quoting hell (arrays and splicing, mentioned in the doc)
                                                      4. Static Parsing for better error messages and tooling

                                                      So I’d say those 8 things are a good summary of what Oil’s trying to do! It’s taking awhile but I don’t see any one else doing a graceful upgrade of shell.

                                                      Thanks for the feedback!

                                                      1. 1

                                                        There is https://www.nushell.sh/. It doesn’t try to be a scripting language, but it has similar goals as a shell. The main difference I would say is that they extend the pipe to support types, instead of splitting commands and functions as Oil does. Both have pros and cons.

                                                        1. 1

                                                          Yup I’ve looked at almost all alternative shells and made a huge list of them! https://github.com/oilshell/oil/wiki/Alternative-Shells

                                                          I would like to add something like:

                                                          myls -q | where [size > 10]  # structured data that's then filtered by 'where' builtin
                                                          

                                                          but it’s a little far in the future. My thinking is that myproc [a, b] is actually a lazy argument list, and I can parse it with shopt --set parse_bracket (analogous to how we use shopt --set parse_paren parse_brace to make if (x) { ... } work.

                                                          That is all hidden under bin/oil, so you don’t need to remember the names. But that is the underlying mechanism for changing the syntax, and gradually migrating OSH to Oil.

                                                  1. 3

                                                    I wonder why Terminals don’t entirely turn off the rendering past a certain speed limit. There is some value in seeing patterns fly by, but at some speed, even patterns become indistinguishable. The whole screen might as well be replaced by a bandwidth indicator until the buffer is closed or slowed down.

                                                    1. 2

                                                      This is exactly what my own terminal emulator implementation does for that very reason - the point is to read the output, not just to render a blur. Latency matters - lag when you’re typing is really annoying - but throughput doesn’t need to be rendered at all.

                                                    1. 3

                                                      Unbeknownst to you, that person actually works at Sony. They didn’t realize this, but their contributions in their spare time are not owned by them and Sony’s lawyers now want to sue you for using their proprietary, patented technology.

                                                      If you didn’t get a written statement from that person saying they owned those contributions, and actually intended to release them under your open source license terms - then you could indeed be found in the wrong!

                                                      Legally speaking, what does having them sign a CLA do? If Sony has that line in their authors’ employment contract, then it seems like they would own the code regardless. Is the idea something like: the CLA provides some sort of protection because you put up a step asking for authorization so you can say you’re not intentionally using code that’s under others’ copyright?

                                                      1. 2

                                                        Is the idea something like: the CLA provides some sort of protection because you put up a step asking for authorization so you can say you’re not intentionally using code that’s under others’ copyright?

                                                        Yes, exactly that. In one scenario you may be liable for damages (‘profits lost due to using their unlicensed IP’) while in another you could argue to the court that you did due diligence and it’s the contributors fault, not yours.

                                                        1. 3

                                                          Lack of intent and due diligence are not defenses to copyright infringement. That’s a common misconception you’ll see on YouTube, in disclaimers people try to use when posting copyrighted content, but will not see in the Copyright Act.

                                                          On whether people actually have the right to license contributions: please read a few CLAs. See also Apache’s licenses page, which has CLA forms both for companies and for individuals.

                                                          1. 3

                                                            Lack of intent and due diligence are not defenses to copyright infringement. That’s a common misconception you’ll see on YouTube, in disclaimers people try to use when posting copyrighted content, but will not see in the Copyright Act.

                                                            I do think these disclaimers have value though: namely, I find them extremely funny because this is not how it works at all.

                                                            In general loads of people seem confused about this. Back when I edited on RationalWiki (many years ago) I tried to clean up the copyright mess of their images a bit, but this was met with significant resistance from some people. They would take some webcomic, slap that on a page, and claim “fair use” as “parody” or “criticism”. But … you’re not actually criticising or parodying the copyrighted work, it’s just used in the course of parodying something else. That’s not how fair use works at all. This mostly fell of deaf ears though 🤷

                                                            That entire site is a copyright lawsuit waiting to happen. I’m surprised it hasn’t already happened given that lots of people would just love to see the site shut down.

                                                            1. 5

                                                              Yeah, I used to kind of “collect” badly misconceived copyright disclaimers I’d run into online, like some folks stockpile memes. And it was fun, once or twice, to trade best-ofs with fellow copyright lawyers. But I wouldn’t have any fun hyuck-hyucking about it these days, especially in public. In the end, it’s at least partly a failure of the copyright bar that there’s so much bad information out there. It’s got to the point where we’re flooded with bunk second-order information, like those disclaimers, based on more fundamental misconceptions.

                                                              Basically: We’ve really flubbed public education. We didn’t scale up good copyright information with application and enforcement of copyright online.

                                                              On the flip side, there’s what the law allows and there’s what copyright holders allow. Plenty of copying, sharing, and even “remixing” we see online probably wouldn’t hold up in court, or would cost so much to defend that nobody reasonable would try. But also falls beneath cost-benefit or concern for the copyright holders. Some of them even welcome it, so long as they don’t have to formally license it. I know some Star Wars fans who’ve spelled out the rules of the road for fan media and the like, basically a stricter noncommercial, with a few nuances. Those rules are nowhere written, but broadly understood.

                                                              That’s a very normal situation in law. Theory and reality combine where they conflict. But the mismatch also creates opportunities to prey on expectations developed from experience, rather than formal study. So we have photographers running around suing people for reusing their stuff on social media, in all honesty just seeking fair comp and creative control, often against people convinced they’ve done nothing wrong. But we also have folks enforcing copyrights—or even acquiring copyrights to enforce—where the only real financial value in the IP is the power to shake others down for small dollars, even against folks who might win fair use if they could afford to fight. And every shade of grey between.

                                                              I often suspect it’s the really frustrating experiences of folks on the receiving end of claims under rules that don’t match lived experience, moreso than the rules themselves, that makes people so cynical about the legal system. I don’t say that to absolve lawyers. There’s lawyers on every side of this.

                                                        2. 1

                                                          It shifts the burden to the developer that contributes the code. My understanding is that in the case of a copyright lawsuit, the contributor is now the only person liable to pay for damages.

                                                          That’s why, as a developer, you should never sign a CLA. Unless you are ready to pay a lawyer that can advise you on exactly what it means.

                                                        1. 9

                                                          Does it mean that the promise to not break API doesn’t extend to CLI? https://golang.org/doc/go1compat#expectations

                                                          Keeping things stable is what makes the success of Go.

                                                          1. 7

                                                            Indeed, the final section of that page you linked says that tools are exempt. I can’t think of any previous examples that broke the tooling as much as this will, though.

                                                            1. 6

                                                              It seems short-sighted.

                                                              go get is invoked by a ton of other programs. For example, VSCode plugins love to run it to install missing developer tools. It’s effectively an API, but that’s going through the CLI instead of accessing a Go API directly.

                                                              1. 8

                                                                There’s been loads of subtle breakage and changes in the Go tooling ever since modules were introduced. It rather sucks, but it’s better than the alternative of keeping it full of all sorts of legacy behaviour where commands do something different depending on the environment and/or which directory you’re in, which is super-confusing.

                                                                It’s easy to say it’s “short-sighted”, but all options suck – they just suck in different ways.

                                                            2. 0

                                                              I’ve been listening to the gotime podcast. Go get is a feature to people new to programming – not a bug.

                                                            1. 5

                                                              It would take me longer to find and type the emoji than the actual HTML tag. I’m not sure it really helps in terms of readability?

                                                              One idea to shorten the tag is to introduce a notion of default keys. For the tag, href is the default key. This would allow writing <a https://example.com>this</a>.

                                                              1. 1

                                                                Oh that’s an interesting idea. Perhaps even:

                                                                this<example.com/>
                                                                
                                                                1. 2

                                                                  It really depends on what you are trying to achieve. Is typing links a major issue in HTML? Sugar is nice but usually writing speed is not the main bottleneck to production-ready code.

                                                                  1. 1

                                                                    Goal is to have a simple way of writing links that would fit in a single cell of a spreadsheet (so more 2D lang friendly).

                                                              1. 2

                                                                Since Curses is an API, has anybody explored building a GTK/Curses or other TK mappings? Having a UI that can be navigated 100% with the keyboard is a good thing!

                                                                1. 3

                                                                  Hey, I mentioned PDCurses in the blog post as primarily being used on Windows. It also supports X11 and SDL, but is mostly a way of printing text in a graphical window, since that’s what Curses does.

                                                                1. 2

                                                                  That looks great. It’s part of the list of projects that I want to tackle and had a similar design in mind. With similar ideas around localhost ACME as well.

                                                                  Two things that come to mind:

                                                                  • .localhost doesn’t resolve on all the machines. I think it depends on the NSS config. TBI.
                                                                  • the CA can be created with a name constraint. So even if it gets leaked, the attacker cannot MITM other domains than .localhost.
                                                                  1. 2

                                                                    I know that it do not resolved to loop back everywhere by default. I strongly believe that it should, that would make life of everyone much easier, but the RFC died in drafts. I have configured DNSmasq on my Mac to do so. systemd-resolved does so by default AFAIK. I was thinking about adding built in DNS into Dolores that will help with such configuration on macOS, but I am not sure if it is good idea.

                                                                  1. 10

                                                                    I wonder about several courses of action.

                                                                    We could double down on the concept of copyleft. Treating corporations as people has led to working-for-hire, a systematic separation of artists from their work. We could not just extend the Four Freedoms to corporations, but also to artists, by insisting that corporations are obligated to publish their code; they could stop publishing their code only if they stopped taking that code from artists and claiming it as their own. A basic transitional version of this is implemented by using licenses like AGPLv3, and it does repel some corporations already.

                                                                    We could require decentralization. Code is currently delivered in a centralized fashion, with a community server which copies code to anybody, for free. This benefits corporations because of the asymmetric nature of their exploitation; taking code for free is their ideal way of taking code. Systems like Bittorrent can partially remedy the asymmetry by requiring takers to also be sharers.

                                                                    We could work to make languages easier to decompile and analyze. This partially means runtime code auditing, but it also means using structured language primitives and removing special cases. In the future, corporations could be forced to choose between using unpleasant eldritch old languages or using languages that automatically publish most of their API and logic in an auditable and verifiable manner to any requestor. And they’ll do anything we recommend, as long as it comes with an ecosystem; look at how many folks have actively embraced C, PHP, JS, etc. over the years.

                                                                    1. 15

                                                                      I don’t think that there is anything that can be accomplished by messing around with licenses and in fact trying to keep those sane and not too exotic is the one good thing big tech has done in my opinion.

                                                                      What’s missing is something different that can break the “get vc money”, “acquire users”, “build a moat”, “return money to vc” dance. I personally have no idea what that could be. The one thing I know, is that it produces unlovable software and that there are enough people out there that can do better with a fraction of the money.

                                                                      I also don’t think that the answer lies in more Free software zealotry.

                                                                      1. 14

                                                                        What’s missing is something different that can break the “get vc money”, “acquire users”, “build a moat”, “return money to vc” dance. I personally have no idea what that could be.

                                                                        I would encourage you to look into the model of worker-owned cooperatives.

                                                                        1. 8

                                                                          I would encourage you to look into the model of worker-owned cooperatives.

                                                                          I’ve seen this work for consultancies. Everyone involved has to actually be of like mind though, and that can be harder than it appears to actually manifest and sustain.

                                                                          1. 4

                                                                            Why would that change the quality of the software? In order to do it right, you’d need money coming in and a small enough team, and if you have a small team and money coming in you can probably make quality software, no matter who holds the company shares.

                                                                          2. 8

                                                                            I appreciate your thoughts. I agree that things could be better.

                                                                            As the saying goes, “if there were no copyright, then there would be no need for copyleft.” (Who first said this? I think it’s from an RMS essay.) The current focus on copyleft is because of the judo which licensing allows us to leverage against corporations. As another saying goes, “corporations are golems before the law;” licenses are made of the same substance as corporations, and form effective weapons.

                                                                            There are two implicit ideas in your post. I don’t fully understand them and I don’t want to put words in your mouth or construct strawmen, so instead I’ll have to be vague. The first idea starts with compensating folks for producing code. Since compensation requires a market of purchasers, and software can be copied at marginal cost, there is a natural misalignment of incentives: The producers want to be paid for the labor of production, which tends to increase; but the purchasers want to only pay for the cost of copying, which tend to decrease.

                                                                            The second idea is that the politics of programming languages are important. On one hand, anybody can create a programming language. On the other hand, there are tendencies for big things to get bigger, including communities expressing themselves with popular languages. But on the gripping hand, every new language is built from the tools of old languages. Rather, it’s a question of which possible new languages we choose to build, and which lessons we choose to learn from the past, and those choices are political since people write expressive code in order to communicate with each other.

                                                                            The answer to breaking the cycle of capitalism involves either democratizing ownership of the cloud hardware, or democratizing the development and maintenance of the cloud software. The only thing which keeps the capitalists in control is the ownership of property. Free Software is optional but hard to avoid if we want to do anything about it.

                                                                            1. 3

                                                                              The current focus on copyleft is because of the judo which licensing allows us to leverage against corporations. As another saying goes, “corporations are golems before the law;” licenses are made of the same substance as corporations, and form effective weapons.

                                                                              True, but I think that this is a war that is being played on many more levels and IMO, as effective as a license can be, Free software is losing the war on all other fronts. One example is branding. “Open Source” is a much more popular term than “Free software” and surely big tech has helped make that happen.

                                                                              My point is that big tech has already learned how to win against licenses and it’s through marketing and a myriad of other activities. The FSF from my perspective has no chance at beating that unless it becomes willing to rebuild itself from the ground up, and we’re seeing that that’s not the case.

                                                                              The answer to breaking the cycle of capitalism involves either democratizing ownership of the cloud hardware, or democratizing the development and maintenance of the cloud software.

                                                                              Democratizing the development of software IMO has little to do with capitalism nowadays, and a lot more with being competent at shaping up communities around “principled” software projects and by keeping software simple and clean, so that new generations can quickly ramp up and fight against bad software. I leave it to you to judge how GNU is doing in that regard.

                                                                              1. 4

                                                                                “Open Source” is a much more popular term than “Free software” and surely big tech has helped make that happen.

                                                                                The change happened a little earlier, but it’s not surprising that corporations would endorse a corporate-friendly bastardization of a community-grown concept. That’s what it means to be exploitative.

                                                                                My point is that big tech has already learned how to win against licenses and it’s through marketing and a myriad of other activities.

                                                                                You have no evidence with which to support this assertion. I intentionally linked to my pile of evidence that corporations systematically avoid certain licenses, including licenses which cover popular software with ecosystems of users. As I have previously explained:

                                                                                The goal is to enumerate those licenses which are well-known, as a matter of folklore and experience, to designate Free Software which corporations tend to avoid. None of the information that I linked in my answer is new information, but it is cited and sourced so that folks cannot deny the bulk of the thesis for lack of evidence.

                                                                                The FAANGs are indebted to GNU/Linux, for example, and while they have made efforts to get rid of GNU userlands, they are not yet ready to get rid of Linux. As I said at the beginning of the thread, we asked corporations to use C, and they used C; they chose irrationally because they’re not actually capable of technical evaluations, and this shackled them to our kernel of choice.

                                                                                Democratizing the development of software IMO has little to do with capitalism nowadays…

                                                                                This will have to be where we agree to disagree. You have pointed out twice, in your own words, that capitalism matters to producing software. First, you noted that the current cycle is driven by venture capitalists; these are the same sorts of capitalists that, a century ago, were funding colonial projects and having political cartoons made about them. Second, you surely would admit that it’s not possible to develop software without development hardware, which forms operating capital; whoever owns the computers has great control over software developers.

                                                                            2. 6

                                                                              There are other capitalistic software endeavors that are considerably more gentle than the current VC insanity. For example the SQLite folks. I’m not even sure it’s incorporated. But dr. Hipp is definitely doing it for the money.

                                                                              Edit: looked it up, SQLite is incorporated as a limited partnership of a small number of people. Corporate contribution results in a very well defined boundary of “what you get”. The “funny” thing about SQLite is that it’s unlicensed. SQLite is In the public domain.

                                                                              1. 1

                                                                                But dr. Hipp is definitely doing it for the money

                                                                                Eh this is very simplistic, and I’m not sure how you can be so certain that you know the motives of others. Do you know him?

                                                                                If you look around, you can find various origin stories behind sqlite, which shed some light on the matter. Any project, and particularly large/long-lived ones, are going to have a mix of motivations, and they can change over time. Money could be one reason but it’s certainly not the whole story.

                                                                                1. 2

                                                                                  Dr. Hipp has said so himself in some of his lectures. So, sure, he could be lying or saying it for dramatic effect, but I’m going to take him at his word, and I find it hard to believe that “making money” is zero percent of his incentive for doing it. That money wasn’t the only motivation is exactly my point. Just that “making money” does not automatically taint a project, in fact in many cases it’s a good signal that you are at least building something that someone wants. We are just living in times where other societal superstructures make it so that the type of capitalism that Loris is talking about is favored. My personal take is that it’s ironic that some of the factors that brought about what we have now were concieved of specifically to restrict or “strategically guide” capitalism, and have either spectacularly backfired or had some gnarly unintended, but perfectly predictable, if you were listening to the right people, consequences.

                                                                              2. 2

                                                                                My theory is that saying the problem is “profit motive” is almost right - the fundamental problem is trying to sell anything other than “what the user wants”, and receiving money from anywhere except directly from the user.

                                                                                For instance, the “try free” button mentioned in the article is usually from someone trying to fund software development with cloud-services revenue. Cloud services revenue is not the software (or rather, it’s the software plus some other stuff), so they need to maintain the not-software that is not necessarily what the users need, and that distracts and gets in the way.

                                                                                Ads/tracking, open core, all fall into the fundamental problem of prioritizing not-software over software.

                                                                                So basically, I’m saying the future is patreon or liberapay or a libre app store.

                                                                                There are two main ways we can make this happen:

                                                                                1. We make paying for Free Software more convenient. There’s a lot of low-hanging fruit here. For instance, open up F-Droid on your phone, and look for an app called Phonograph. It’s GPL3, and offers a paid version ($5) called Phonograph Pro. P Pro is available from the github (if you compile it yourself) or the Google Play store, but not from F-Droid. F-Droid doesn’t support purchasing Free Software nor conditionally-available binaries, see. Selling Free Software is about selling convenience, so we damn well better make it convenient to buy Free Software. But more than that, it’s hardto figure out who or where to give money or even if it’s possible. I like Mesa, if I want to give them money I should be able to do so before the random impulse wears off.

                                                                                And to go even further, if we’re ambitious, in the long term we should try to handle identity and payment on the desktop (which come to think of it is too long for this paragraph or post, I’ll gladly elaborate though) so as to make it easier in the long term for people to pay. 2. We should foster an attitude of “if you like it, put money towards it. anything.” Because IIRC, currently only 0.01%ish of users donate money. That is insanely low.

                                                                                This is super weird and tightropey, since freedoms aren’t supposed to be conditional and realistically Free Software is fundamentally tied to voluntarism, and we really don’t want to make room for people to justify proprietary software by saying “well you ought to be paying anyway, and as long as you’re paying you’re not losing anything anyway”.

                                                                                So, we need people to voluntarily pay within an order of magnitude or two of what the proprietary alternatives receive. I don’t see how anyone can sustainably compete on quality with Google, unless their revenue is at least 1% of Google’s. I just don’t see a primarily volunteer-programmer project ever scaling that high.

                                                                                1. 1

                                                                                  Yeah, I’m with you there. I’m searching for an alternative path as well for https://arbor.chat. It takes money to grow your software, but there has to be a better model for funding than the traditional one. We’re thinking we might establish a nonprofit that accepts donations, but also provides a hosted set of infrastructure with a sourcehut-style subscription. I’d love to talk more about this kind of thing with anyone who is interested.

                                                                                  1. 2

                                                                                    As both an owner in a free software small business and also a small-time investor with a software freedom bent, I’m very interested in these kinds of topics and more collaboration between the people/projects/companies trying to find the way.

                                                                                    1. 1

                                                                                      I found this to be an interesting approach: https://squidfunk.github.io/mkdocs-material/insiders/

                                                                                      It seems like it’s working for them. For a theme, it seems to have quite a bit of financial support.

                                                                                      1. 1

                                                                                        Thanks for sharing that! I’m not yet sure how I feel about the approach taken, but it’s certainly a very interesting data point.

                                                                                  2. 7

                                                                                    We could double down on the concept of copyleft. Treating corporations as people has led to working-for-hire, a systematic separation of artists from their work. We could not just extend the Four Freedoms to corporations, but also to artists, by insisting that corporations are obligated to publish their code; they could stop publishing their code only if they stopped taking that code from artists and claiming it as their own. A basic transitional version of this is implemented by using licenses like AGPLv3, and it does repel some corporations already.

                                                                                    Doubling-down on the concept of copyleft is basically the agenda of the free software movement, which is the thing that @kristoff states is a “disaster on too many fronts and its leadership has failed so badly that I don’t even want to waste words discussing it”. I don’t think it’s obvious that the free software movement has failed - certainly not so obvious that it’s not worth words discussing it. But certainly it’s the case that lots of software is not published under copyleft licenses, some free and some non-free. If the free software movement is a failure so long as anyone at all is publishing non-free software or even free but non-copyleft software, then sure, it’s a failure so far; but that seems like an awfully stringent requirement for success.

                                                                                    We could require decentralization. Code is currently delivered in a centralized fashion, with a community server which copies code to anybody, for free. This benefits corporations because of the asymmetric nature of their exploitation; taking code for free is their ideal way of taking code. Systems like Bittorrent can partially remedy the asymmetry by requiring takers to also be sharers.

                                                                                    We already have this. Redis is a BSD-licensed piece of free software whose source code is publicly-available here on GitHub. Anyone can legally fork this and redistribute it, without asking anyone’s permission and without even doing all that much work. If GitHub deplatforms the project for any reason, it’s very easy to set up alternative git hosting on some other service. If someone really doesn’t like the fact that the official redis website has too big of a try free button, nothing is stopping them from setting up a website for their own fork of redis that doesn’t have that button.

                                                                                    We could work to make languages easier to decompile and analyze. This partially means runtime code auditing, but it also means using structured language primitives and removing special cases. In the future, corporations could be forced to choose between using unpleasant eldritch old languages or using languages that automatically publish most of their API and logic in an auditable and verifiable manner to any requestor. And they’ll do anything we recommend, as long as it comes with an ecosystem; look at how many folks have actively embraced C, PHP, JS, etc. over the years.

                                                                                    A lot of organizations using unpleasant eldrich old languages are stable and stodgy ones that have been around for decades, and aren’t necessarily even for-profit corporations. MUMPS is primarily used by hospitals, and COBOL has plenty of use in banks and government bureaucracies. A lot of the reason for this is that these organizations have software requirements that don’t change very much, and have made the trade-off that having a software stack that few people understand is better than updating that software stack and risking introducing bugs. Corporations that haven’t gotten big and institutional yet have more incentives to use newer technology stacks - and if they refuse to anyway and that choice contributes to the company failing in the marketplace, whatever, it’s just one more of many failed companies.

                                                                                    1. 1

                                                                                      We already have [decentralization]. Redis is a BSD-licensed piece of free software whose source code is publicly-available here on GitHub. Anyone can legally fork this and redistribute it, without asking anyone’s permission and without even doing all that much work. If GitHub deplatforms the project for any reason, it’s very easy to set up alternative git hosting on some other service.

                                                                                      This is the “we have food at home” fallacy. To use words more carefully: GitHub is the “community server” from which “code is currently delivered in a centralized fashion”. You are saying that if one point of centralization vanishes, then the community can establish another. Yes, but it takes time and effort, and the community is diminished in the meantime; removing those centralized points is damage to the communities.

                                                                                      A properly-decentralized code-delivery service would not be so fragile. It would not have any Mallory who could prevent a developer from obtaining code, save for those folks in control of the network topology. (A corollary is that network topologies should be redundantly connected and thickly meshed, with many paths, to minimize the number of natural Mallory candidates.) Any developer who wanted to use a certain library would only need to know a cryptographic handle in order to materialize the code.

                                                                                      Note that these services would only work as long as a majority of participants continue to share-alike all code. So corporations have a dilemma: Do they join in the ecosystem and contribute proportional resources to maintaining the service while gaining no control over it, or do they avoid the ecosystem and lose out on using any code which relies upon it? Of course they could try to cheat the network, but cryptography is a harsh mistress and end-to-end-encrypted messages are black boxes.

                                                                                      1. 3

                                                                                        This is the “we have food at home” fallacy. To use words more carefully: GitHub is the “community server” from which “code is currently delivered in a centralized fashion”. You are saying that if one point of centralization vanishes, then the community can establish another. Yes, but it takes time and effort, and the community is diminished in the meantime; removing those centralized points is damage to the communities.

                                                                                        GitHub isn’t the community server. There is no the community. Lots of separate open-source projects with their own communities exist, and they can individually choose to host the authoritative version of their code on whatever git platform they want, whether that’s GitHub, Gitlab, Gitea, the ssh-based hosting built into git, or some other option.

                                                                                        I agree that if a given open-source project deliberately chooses to host their code and issues and documentation and so on on GitHub, rather than on a platform that they have control over, they are vulnerable to community disruption and damage if GitHub decides to stop serving them. And insofar as GitHub is popular, lots of projects exist that are making this choice. I agree that this is a bad idea, and that these projects shouldn’t do this. Personally, I no longer host my own open-source code on GitHub, and I only interact with it in order to contribute to projects that do use it.

                                                                                        But individually getting a lot of separate organizations to switch away from a useful-but-nonfree software platform to a free one that maybe doesn’t have as much UI polish as the nonfree choice is a hard collective action problem (it’s actually pretty much the same problem as getting people to switch from Mac OS or Windows to Linux on their desktop computers). You can’t compel large numbers of people to value freedom from GitHub’s disruptive product choices over the value they currently get from GitHub. You can’t compel a bunch of different people to do the work to switch off GitHub all at once.

                                                                                        A properly-decentralized code-delivery service would not be so fragile. It would not have any Mallory who could prevent a developer from obtaining code, save for those folks in control of the network topology. (A corollary is that network topologies should be redundantly connected and thickly meshed, with many paths, to minimize the number of natural Mallory candidates.) Any developer who wanted to use a certain library would only need to know a cryptographic handle in order to materialize the code.

                                                                                        Radicle is a great idea, I’m a fan. If some project currently using GitHub as their authoritative git repo decided to switch to Radicle and abandon their GitHub-based infrastructure, I think that would be great.

                                                                                    2. 3

                                                                                      One route that has been under-explored is to pay for software distribution.

                                                                                      On some level software has the same issue as music, copying it is super easy. It doesn’t matter if the source is open or not if the distribution is made convenient enough that people are willing to pay for it.

                                                                                      1. 2

                                                                                        I like to call this model “libre-non-gratis” and there have been a small but strong set of examples over the years. Conversations (android app) is one currently active example

                                                                                    1. 4

                                                                                      This is a story about how Go is awesome at creating these super small HTTP servers. Most of the time you can get away with just using the stdlib. Instead of spending hours learning how to config Nginx or some other webserver, it can be as efficient to write your own specialized server.

                                                                                      For example, two months ago, one customer was serving their frontend using nodejs, and it was taking quite a bit of memory in the cluster. The docker image was also quite large with all the runtime. Two hours later, I had thrown together a statically built Go program that is specialized to serve SPA1. They have been using it happily ever since. And if they need some extra feature, I know that it will be as easy, or even easier for me to add exactly what they need.

                                                                                      1. 8

                                                                                        For what it’s worth I could have probably gotten away with something like this for Nginx config (I haven’t tested this but I’m at least 98% certain it would only need minor adjustments to work properly):

                                                                                        server {
                                                                                        	listen [fda2:d982:1da2:180d:b7a4:9c5c:989b:ba02]:43705;
                                                                                        	location ~ ^/(?<service>[a-zA-Z]+)$ {
                                                                                        		proxy_pass http://unix:/srv/within/run/$service.sock:/metrics;
                                                                                        	}
                                                                                        }
                                                                                        

                                                                                        However doing it with the Go standard library does get to show off how easy Go makes it to do amazingly hacky things without using anything but the standard library. Go is nice for these things. I wish that level of simplicity in usage was true about other aspects of the tooling like Go modules, but that’s a rant for another day.

                                                                                        1. 3

                                                                                          I wish that level of simplicity in usage was true about other aspects of the tooling like Go modules, but that’s a rant for another day.

                                                                                          My thoughts as well. Reading your Go really reminded me of its (perhaps former?) “cultural agenda of radical simplicity”. Also, thanks to Mara for the NixOS service. Also love to see Nix get involved with anything :-).

                                                                                      1. 1

                                                                                        It might be good, but the way they demanded donations in the early days put me off it for life.

                                                                                        1. 24

                                                                                          Isn’t it possible to extend some forgiveness? They are trying to fund their development, and they are doing it with one hand tied in their back by making it open source. That level of polish is hard to reach without some sort of consistent funding.

                                                                                          1. 3

                                                                                            I would argue that; for what they were going for; it is only fair. I can imagine without donations they saw the death march the project would be on.

                                                                                            Besides, as qqlq said, free as in beer vs free as in speech.

                                                                                            1. 2

                                                                                              That article seems to confuse free as in beer with free as in speech.

                                                                                            1. 8

                                                                                              I wonder why ZeroTier isn’t more popular. It already does all of this and more, is open-source, and has been working for years now.

                                                                                              1. 7

                                                                                                ZeroTier doesn’t build on wireguard, for one. And I’ve seen people having lots of issues with it: https://old.reddit.com/r/zerotier/ .

                                                                                                1. 4

                                                                                                  Another thing in the genre of “Hamachi for not gamers”.

                                                                                                  1. 9

                                                                                                    Hamachi

                                                                                                    There’s a name I have not heard in a long time

                                                                                                    1. 3

                                                                                                      True enough, but it works very well for gaming too. I played perfectly good “LAN” CS1.6 over 1000km.

                                                                                                    2. 2

                                                                                                      We looked pretty heavily at ZeroTier for a project at my day job a while back, but ultimately walked away from it because it could not be entirely self hosted. There was always a connection to their plane at some level.

                                                                                                    1. 12

                                                                                                      Can we please stop using tabs altogether (the last vestigial remain of MDI) and move towards BeOS’s Stack paradigm in which each window title is “a tab” and you can stack together different windows?

                                                                                                      The stack paradigm is easier for the users: one concept (windows) instead of two similar-but-different concepts (windows and tab-inside-windows).

                                                                                                      A graphical example: https://www.haiku-os.org/docs/userguide/en/images/gui-images/gui-s+t.gif

                                                                                                      1. 7

                                                                                                        Every time I see tabs mentioned, I’m thinking about window management. The window manager is too weak, and therefore the application themselves had to step in and invent their own.

                                                                                                        So basically agreeing :)

                                                                                                        1. 5

                                                                                                          Counterpoint: there are two major kinds of tabs, which the article seems to think about as dynamic and static. I would call them task-windows and multi-rooted trees.

                                                                                                          A task-window is the kind of tab that MDI and browsers use: effectively a complete copy of the application main window, but space-compressed. A perfect window manager might be the best way to handle these, but it would have to be good enough for every application’s needs. I haven’t met a perfect window manager yet, but I haven’t seen them all.

                                                                                                          A multi-rooted tree is most often found in giant config/preference systems, e.g VLC and LibreOffice. It could be represented as a single-rooted tree, but the first level branches are trunk-sized and so independent that a user will often only want to tweak things in one branch. Separating them out into tabs is a pretty reasonable abstraction. It’s not the only way of breaking the tree up, but it maps nicely from category to tab, subcategory to delineated section.

                                                                                                          1. 3

                                                                                                            Another counterpoint is Firefox with a lot of tabs. There are some optimizations that Firefox can do because it has access to domain knowledge. Like not loading all of the tabs on start. It could probably unload tabs as well. In order to do that the window manager needs to expose a richer interface.

                                                                                                        2. 4

                                                                                                          Former BeOS fan here.

                                                                                                          Please no. :-(

                                                                                                          This is all IMHO, but…

                                                                                                          There are at least 2 different & separate usage cases here.

                                                                                                          № 1, I am in some kind of editor or creation app & I want multiple documents open so I can, say, cut-and-paste between them. If so, I probably mainly want source & destination, or main workpiece & overflow. Here, title-bar tabs work.

                                                                                                          № 2, I’m in a web browser, where my normal usage pattern goes: home page → lots of tabs (50+) → back down to a few → back to lots of tabs (and repeat)

                                                                                                          In this instance, tabs at the top no longer work. They shrink to invisibility or unreadability. In this use case, I want them on the side, where I can read lots of lines of text in a column of a fixed width. Hierarchical (as in Tree-Style Tabs) is clever, yes, but I don’t need I already have a hierarchy: a browser window, and inside that, tabs. Those 2 levels are enough; I rarely need more than 2 or 3 browser windows, so I don’t need lots of levels of hierarchy in the tabs and TST is unnecessary overload and conceptual bloat.

                                                                                                          The fact that Chrome can’t do this is why I still use Firefox. Or on machines where I don’t have to fight with Github, Waterfox, which is a fork in which XUL addons still work & I don’t need to lose another line of vertical space to the tab bar. In Waterfox as in pre-Quantum Firefox, I can combine my tabs sidebar with my bookmarks sidebar, and preserve most of those precious vertical pixels.

                                                                                                          We have widescreens now. We have nothing but widescreens now. Vertical space is expensive, horizontal space is cheap. Let’s have window title bars wherever we want. How about on the side, like wm2? https://upload.wikimedia.org/wikipedia/commons/3/3b/Wm2.png

                                                                                                          That worked well. That can mix-and-match with BeOS-style tabs very neatly.

                                                                                                          1. 4

                                                                                                            Microsoft was working on a feature called Sets for Windows 10 that would basically do this. I was very sad to learn that the project was axed though even after making it into an Insiders build :(

                                                                                                            1. 2

                                                                                                              Compare with tabbed application windows in current macOS. In almost any Cocoa app, tabs can be torn off to make their own window, or merged with another window. I’m not as familiar with Be, but the main differences seem to be that tabs still go in a bar under the title and can only be joined when they’re the same kind. I’m curious how stacking windows of different kinds would feel. Maybe a window would become more like a task workspace.

                                                                                                              1. 2

                                                                                                                I like the idea, and have tried it in Haiku, but in practice it was harder to use for me.

                                                                                                                Maybe I missed some shortcuts? I was dragging windows to each other manually.

                                                                                                                Maybe it’s just a matter of getting used to it? I don’t know.

                                                                                                                1. 3

                                                                                                                  Applications, like web browsers, could create shortcuts for creating a new window as a tab of the current window. I think that would make it near identical in terms of behavior.