Threads for alexandria

  1. 1

    Git has exhausted its potential in my eyes. God be merciful, I’ll write my own vcs. For myself. Maybe not even going to make it publicly available, but only to those who actually get it.

    1. 2

      Good luck! You’ll be following in the footsteps of many dead or antiquated VCS systems, like (off the top of my head…) Fossil, BitKeeper, Mercurial, Bazaar, and Darcs.

      1. 1

        I sort of want to break out and become the next big thing, but I worry it’s not better enough to overthrow the consensus choice.

      2. 2

        You could also write a new porcelain on top of git. git’s internals are a pretty straightforward set of primitives about a content addressable file system and commits.

      1. 47

        Or maybe rants get more engagement and people are ranting mostly to feel good.

        or maybe the entire structure of gamified discussion boards based on upvotes/downvotes incentivizes people to rant and the discussions being had are actually only proximately about their topics but ultimately about servicing the specific incentive structures that mediates the conversations in question and as a community we face a moral imperative to critique how the incentive structures of communications mediums alter the communications they facilitate?

        I’ve been on these systems since about 2005 or so, and every time the communities start out with a bunch of people interested in some topic, the platform facilitates that topic, and people’s interest shifts from the topic to the platform itself. Over time, every one of these platforms devolves into people playing the algorithm to maximize their “score”, and so the things being said are not what the people want to be said, they’re the thing the scoring algorithm wants to be said. No amount of human moderation changes this evolution and every democratic discussion board approaches critical insularity past some threshold of user size. In the past seventeen or so years I’ve participated in these systems I’ve watched this cycle repeat itself on digg, reddit (where the phenomenon is largely recognized to exist), HN (where the phenomenon clearly exists but people are mostly unwilling to acknowledge it), and here (where the phenomenon is nascent but in its early stages).

        How many times are we going to build this discussion board format and see it devolve the same way before we as a community truly come to terms with the idea that maybe democracy as a system doesn’t actually produce meaningful, deep, and nuanced conversations, but instead always tends towards tribalism and conformance? Anyway the laptop looks neat.

        1. 9

          What if the scores were simply never shown to anyone (including authors)? I think it would make a difference.

          1. 3

            I think it would make a difference too! As a game designer, my immediate reaction to the question is “that sounds like a great thing to playtest”.

            I wonder how severe the difference would be, whether it would make the experience more enjoyable or less enjoyable, whether the discussions get better or worse, etc. If it makes the discussions better but makes the population collapse so that they just go to somewhere that does show them the score, that’s probably bad. Would that happen? Honestly it’s too tough to predict without trying it, experiencing it with others, and talking to people when they use it. But definitely something worth considering (or asking if people have tried this before and what sort of results they found).

          2. 4

            “Gamification” looks like will happen without and algo as well. Consider “last comment to this topic”, “amount of comments”, comment notifications which hit OP tenfolds if they post some rants compared to some fun weekend project experience.
            Algos amplify that feedback loop, for sure, but till there is feedback, there will be a guidance towards what is worth to be posting.
            Removing this feature leaves us with RSS, which is also fine, but strips these excellent discussions like what you started :) I’d definitely feel bad if we couldn’t have that.

            1. 2

              How many times are we going to build this discussion board format and see it devolve the same way before we as a community truly come to terms with the idea that maybe democracy as a system doesn’t actually produce meaningful, deep, and nuanced conversations, but instead always tends towards tribalism and conformance?

              As long as you can make money with it.

              Anyway, it may look neat, I just never had confidence in HP laptops’ reliability.

              1. 1

                Which major PC manufacturer do you have confidence in? I certainly have enough experience with Dell to know they’re not to be trusted to be reliable either.

                1. 1

                  Lenovo would be one. But that’s my experience, personal and close one.

                  1. 1

                    I don’t know much about Lenovo’s hardware, it’s possible that it’s universally fairly reliable. However, I’d have a hard time buying anything from the kind of company which would install malicious TLS root certificates onto their machines.

                    1. 1

                      Yep, but they all actually do similar things, especially on consumer devices. ThinkPads as developer machines are awesome, even delivered clean from the factory. In fact, you can just get them with Linux.

                2. 1

                  As long as you can make money with it.

                  I’m not under the impression that makes any money or exists to make money; I think people build this structure because people like to create and participate in communities and the upvote/downvote structure is intuitively a great idea that you expect to work. In theory, it’s a great structure! In practice … well, history seems to have a way of repeating itself.

                  and yeah I don’t mess with HP myself. For a non-apple laptop I’ve actually found the Razer Blade to exceed my expectations, although it’s not cheap. Haven’t run Linux on one myself.

                3. 2

                  This is an important subject, and I’d love to have a high quality discussion about this, where carefully considered long form positions and critiques are posted over the course of weeks. I don’t think that is the place for that. If anybody has relevant links for this subject area, please post!

                  1. 2

                    It’s why I joined Something Awful a few years back.

                    A lot has changed since it’s heyday – it depends on subforum of course, but the mods are pretty vigilant and just taking a look down the “leper’s colony” shows probations and bans for racism, sexism, etc. (things that are rife to both Hacker News, and Reddit). It has consistent threads with regulars, most of the topic-based threads have been going for about 6+ years, and while there are sometimes debates being rehashed, a lot of the things people post are reasonably new. Whatever interest you have, there is a thread for it. And of course, there are no upvotes or updoots or karma system – nobody there cares for it anyway, because everyone knows if you post then that post is automatically bad :). Entry to post is a one-time payment of $10, which isn’t too costly but it does fund the site and means that getting banned actually has ate into the person’s wallet, which disincentivizes shitty behaviour. The primary userbase these days is in the 30 - 60 age range, and the age of the site means that most of the “novel” jokes have already been done to death 15 years ago.

                    The only problem with Something Awful is, if you see me, you’re reading my posts! And whether or not you feel that punishment worth it is only up to you :)

                    There are threads dedicated to poking gleeful fun at Hacker News, and indeed Reddit, for not only the things you mentioned, but also the sheer banality of them, and the complete and utter tripe that is produced en masse by both (Not to mention, Reddit’s particularly unsavory history – e.g. most of the users of r/teenagers being outed as predators, Reddit’s long love dance with misogynists (A post like this categorically would not survive on Something Awful), Hacker News’ long love of VC bullshit and neoliberalism, etc.)

                    1. 2

                      No internet upvotes required: get any group of otherwise unfamiliar software nerds together in person (say, at $JOB) and say something about laptop hardware, and all these takes come out! Although, they’ll be more self-moderated for polite company.

                    1. 8

                      I love the Heroku experience, it’s a shame what’s happening to them :/

                      I’ve used Dokku a few times to achieve a similar deployment style and found it to be pretty good!

                      1. 7

                        The main problem with Dokku is that it gets the first 90% of Heroku (getting apps into the cloud) but not the next 90% of Heroku (gracefully handling your app server catching on fire).

                        1. 1

                          yeah totally. It’s definitely a nicer experience than just running and building docker containers yourself, but in no means a replacement :(

                        2. 2

                          Yep! We use dokku at work and it’s been a really powerful and lovely system to get to use. I’m thinking of refactoring my own servers to use it

                        1. 7

                          I kind of feel that using several different integer sizes is “cheating”, even though I’m not really sure if cheating is a thing that can apply to this. I don’t know. As a reader, when I see “4 integers are enough to write a snake game”, I expect at least 4 uint16_ts, or 4 uint8_ts, or something smaller than a 64 bit integer. Really the title should be “136 bits is enough to write a snake game”.

                          Like, I clicked on this to see if I could apply a similar technique in some bootloader code I’m writing, but the technique is just - “use really large integers” and “use bitmasks”. That feels anti-climactic and disappointing.

                          At the same time, I don’t feel that this is the author’s fault, or the fault of the article. It’s just a dissonance of what I expected when I clicked on the article, which the author couldn’t have possibly known. At the same time, I can’t get past the fact that I feel cheated by this - “I made a snake game in 17 8-bit integers” isn’t nearly as interesting an article title, and it feels clickbaity because of that.

                          1. 2

                            I normally expect integer to mean 32 bits, but I guess it’s been long enough that 64 really is the standard now.

                            1. 2

                              Funnily enough, the total bits (32 + 64 + 20 + 2 + 8) do add up to less than 4 * 32. So perhaps you would have preferred it to be phrased as:

                              • We will store the game map in a uint32_t where 1s will form the reptile’s body. The map will contain 4x8 positions. Enough to have fun!
                              • We will keep two more uint32_ts as a directions array - this will be useful to move the snake around, while keeping its growing shape intact;
                              • In the final uint32_t we will squeeze in:
                                • four 5-bit integers for the positions of the head, the tail, the apple, and the (current) length.
                                • 2 bits for input from the keyboard
                                • 8 bits for looping.
                              1. 2

                                You are right, I believe that would’ve been a better choice of words.

                              2. 2

                                I think the title was unintentionally click baity, and may have created fake epectations. Didn’t meant to be extra-clever, I just wanted to use as few variables as possible and squeeze everything in as little as possible, just like some people in the embedded world are doing.

                                The same feeling feeling of dissonance was shared by other people on Reddit, who downvoted the hell out of me and wrote some negative comments. Some guy even hate message me in the PM. Next time I will be more attentive with the titles.

                                1. 2

                                  Yeah I mean, like I said I don’t blame you for this at all – it’s entirely me doing the leverage here. I’m really sorry you saw abuse from Reddit. TBH it’s not unexpected because I regard Reddit as a complete trashfire anyway and keep tabs on the SA thread mocking the hell out of them / alternately getting super shocked about the shit Redditors do. Fucked up that they went to your DMs too. Urgh.

                              1. 8

                                I kind of feel that the author, intent on proving a point, himself misses the entire point of Hare as a language

                                1. -2

                                  Well, the author is being polite. The point of Hare is to aggrandize its inventor.

                                  1. 26

                                    I have mercilessly flagged rants and sourcehut spam, as well as gotten into slapfights with Drew here. Believe me when I say, without any love or affection for the fellow, that I’m pretty sure your take here is wrong.

                                    1. 16

                                      Oof. You’ve now convinced bunch of onlookers never to share their projects here. Aren’t we all here to learn new things via sharing?

                                      1. 13

                                        The point of Hare is to aggrandize its inventor.

                                        I’m genuinely curious how you arrived that conclusion.

                                        1. 6

                                          Corbin doesn’t like Drew

                                          1. 4

                                            I hope ad hominem attacks don’t become the norm here.

                                        2. 2

                                          Working hard on something for years is the best way to aggrandize yourself. Shit posting on the other hand…

                                      1. 1

                                        Thirteeen megabytes! Holy hell that’s huge!

                                        1. 2

                                          I looked into making a communal radio towards the end of 2021. It seemed like liquidsoap was the best in this space, but I lost a lot of time due to other committments

                                          1. 1

                                            Liquidsoap looks really interesting! Thank you for the pointer :)

                                          1. 5

                                            Interesting post! Did you consider Common Lisp? I’m not contesting the choice of Standard ML, but CL is something I’ve heard people mention when the question of a “100 year language” comes up. I’m not a CL user myself, but reports indicate a similar experience to yours, eg the language is stable and there’s very little breakage in the ecosystem

                                            1. 1

                                              CL would seem to be discounted for the same reasons as Scheme – it carries many of the same flaws

                                              1. 1

                                                Good point; any Lisp you pick you’ll have to deal with a lot of parentheses. However, as opposed to Scheme there aren’t that many CL implementations that I know of and there’s an ANSI standard that I guess all current implementations follow.

                                                I’m not really a good CL advocate as I haven’t used it, but Steve Losh puts forth some good arguments for it here:

                                            1. 1

                                              Working. lmao (or do you mean outside of the dayjob?)

                                              1. 19

                                                “Reasons to have a weird desktop on linux #153”

                                                1. 9

                                                  Unlike JSON, Nickel is programmable

                                                  IIRC* this was a deliberate decision by Crockford. Because the entire point of JSON is to not be a programming language, and to be universally compatible with all programming languages.

                                                  This is also why it doesn’t have comments – people would have used comments to add extensions to the language (comments as pragma directives) and suddenly you don’t have JSON, you have 20 different varieties of the language JSON, and the language is utterly useless as a universal language data format.

                                                  IMO this is what people trying to replace JSON just don’t get. We already had a good executable interchange format 20, 30 years ago, it was called an “S-Expression” (Or XML, or YAML). Lisps are super easy to embed and they are super easy to write on a programming side (Which is why we have Greenspun’s Tenth Rule). They are easy to read and parse mechanically (inb4 “parentheses!!” - Vim from 1970 supports % to jump between brackets, and highlights matching brackets, so why doesn’t your editor?), but they also totally lack any discrete form of interoperability between languages, because now everything that parses your data format also needs to execute it, and to do that it has to execute it in the same way, and now you have fifty different specifications masquerading as one.

                                                  As mentioned, you can see this with YAML and XML too, although there are additional problems there like “Why am I writing so many damn angle brackets” and “Why is my configuration reliant on whitespace?”. And all of them suffer from “Why has my configuration file’s parser blown up my computer when handed this suspicious config file I copy pasted from IRC/Discord/SO”.

                                                  So fundamentally, this is a bad idea IMO and it comes from not respecting the journey and history that led to JSON. Personally, I really really hate writing JSON, but the alternatives are worse and there’s a reason why those alternatives are worse that goes beyond syntax alone. The executability and the universality of all of them leave them vulnerable to say, the billion laughs attack, among others. If I’m not remembering incorrectly (I read this in a book whose title I have forgotten :(), in the 90s this was one of the major problems with either Postfix or Sendmail (that might have been them having an accidentally executable configuration file).

                                                  We learned and Crockford’s inspiration was adopted everywhere because it tangibly fixed those problems by:

                                                  • Not making a data format executable

                                                  • Making it simple as hell while still retaining utility

                                                  • Deliberately making sure that it would be irritating to create variations (to the point of not even supporting comments).

                                                  All so that any language, any program, and any system can read it and understand the contents, rather than having slightly different versions for every system under the sun, and then doubling that for proprietary extensions and all the fun we used to have with configuration files.

                                                  And now some people come along and go “Wait why aren’t our configuration files executable! Why don’t they have comments?!” and the cycle unfortunately repeats, again.

                                                  When will we learn for good?

                                                  * - I remember the design justification used to be listed on but the site has changed somewhat since I saw it last, and the only alternative source I can find goes to a Usenet / Google Groups post that has since been purged.

                                                  See also:

                                                  1. 7

                                                    JSON is a (mostly) reasonable data interchange format but it’s not a great configuration language. A data interchange format definitely should not be programmable. The degree of programmability that you want is still a bit of an open question to me.

                                                    I generally think UCL strikes a pretty good balance: it has simple macros and it also has built-in logic for merging different sources, including the ability to delete nodes from the tree that were present in an earlier version. It has the problem of being a single implementation of the specification (which is therefore largely defined by the implementation) and it’s not clear that the parsing logic for the combination modes could be properly abstracted.

                                                    Comments definitely are useful in a configuration language because it’s intended to be human readable and it’s useful to be able to store why you made a particular configuration change. The degree of programmability, in part, depends on the flow of configuration information from the user to the program. In a classical UNIX system, config files were files in the filesystem and you’d deploy a service by installing it, editing its config file, and then starting it. This is nice and simple because the config file is just a file and so you can version it as you would any other file. If it’s too complex to write by hand then you can write a program to generate it (if you’re Sendmail then this is your recommended way of writing a config file). There are two important things here:

                                                    • The person writing the config file is trusted (and so won’t be writing malicious configuration files).
                                                    • The code that runs to generate the static config file does not have to run with the privileges of the tool and the tool can parse a much simpler version of the config.

                                                    It’s quite easy, for example, to write a stand-alone tool that takes a set of UCL config files and spits out minified JSON of the combined result. That’s fine if you assume that the only things that need to edit the config are a text editor for the input and the main program for the output.

                                                    If you want to be able to deploy containerised versions of the service with small tweaks to the config then you need something else to take your generic config and tweak it. This probably wants to operate on the simplified JSON but you might want to use some of the file separation bits of UCL (or whatever) to be able to split the instance-specific config, rather than doing that as a tree transform later. If you want to provide a graphical tool for editing the config then it needs to preserve comments and whitespace in the input so that diff tools work well, which means that it needs to operate on the source material (or possibly needs to just provide new override files).

                                                    I suspect that JSON or even something like BSON is what you want for the final version of the config that a program loads. It can be parsed very quickly and has an in-memory size that’s proportional to the size of the file (unlike XML, with entities) and so you can restrict yourself to parsing config files of a plausible size. If you want to do something more clever then you add some tooling in front.

                                                    To my mind, the biggest problem with configuration at the moment has nothing to do with the file format. The problem is the lack of schemas. This is why I wrote a tool that takes a JSON schema and generates C++ classes reflecting that format for use with UCL. This forces you to have a schema, which ends up embedded in your final binary (configs are validated against the schema before being used) and so can be trivially exported for other tools to use. JSON Schema does have comments (as special nodes) and so you can embed the description of the meaning of configuration options in the schema and then expose it in configuration editing tools. There’s also the problem of how you get configurations to stateless VMs / containers, though I believe etcd is trying to address that.

                                                    By the way, nlohmann JSON lists this URL as the source for your claim about comments but it asks me for a Google account so I can’t verify that it actually does say what you and they quote.

                                                    1. 3

                                                      All so that any language, any program, and any system can read it and understand the contents

                                                      I agree with this in broad strokes but have to disagree in the specifics. Parsing JSON is a minefield and every language, program and system has its own ad-hoc, non-documented and buggy way of doing it.

                                                      1. 2

                                                        Yep, this is a great comment. I can’t wait for my solution to be mature enough for people to understand what I am on about but I think I have the answer.

                                                      1. 11

                                                        I think it’s debatable whether this is a bug or not, specifically on Unix (I don’t know enough about other OSs to know). The point of “hello world” is to put a string on the screen (well, terminal). If you were to design a minimal C program to write a string to a file you’d probably use C functions for that , and those would probably return the correct error when trying to write to a non-empty file system. This “bug” is a symptom of the composability of the Unix shell, rather than in the program itself.

                                                        1. 14

                                                          Well, really the bug here is not checking the return value of puts and just assuming it succeeded. Programs are allowed to fail, they just shouldn’t lie about it :)

                                                          1. 9

                                                            Well, there’s another bug here, which is assuming that nobody’s secretly swapped out or overwritten the bit of the system’s standard C library that defines EXIT_SUCCESS and EXIT_FAILURE. Simply assuming that a correct stdlib is present is a source of bugs, you know.

                                                            (yes, this is slightly satirical, but also at a certain point you do actually have to give up and say “these things I accept as my program’s responsibility to watch out for, but not those things”, because otherwise you end up with impractical quantities of defensive programming and never get anything done, and something nearly always missing from these types of articles and discussions is an acknowledgment of this and an attempt to figure out where to usefully draw that line)

                                                            1. -2

                                                              This is inane.

                                                              1. 8

                                                                So, let’s take an actual real example. There are articles that make the rounds every so often about filesystems, and about the incredible difficulty, for a programmer, of writing code that 1) actually commits data to the physical medium, and 2) verifies afterward that this has happened.

                                                                You’d think it’s a thing that ought to be possible. But no matter how careful you are, no matter how clever you are, no matter how defensively you write and no matter how many cases you account for, someone will always be able to pop up and tell you that actually the REALLY_FLUSH_FOR_REAL_I_MEAN_IT_THIS_TIME flag doesn’t flush buffers, and it was your fault for thinking it did. Actually the this_is_the_real_error_check_really() function isn’t the real error check function, and it was your fault for thinking it was.

                                                                Ultimately you have to accept that there is no solution which will be acceptable to the people on the internet. You have to accept that the only guarantee any filesystem provides is that it can, whenever it wants, corrupt or throw away your data and tell you that’s the documented behavior. You have to give up on the layers and layers of clever checks and defensive programming and trying to get it to actually do what you want, and just write something much closer to naïve code, because trying to write sufficiently-non-naïve code takes ten times as long and still provides no guarantee other than that it might corrupt or throw away your data.

                                                                Which is why I jump on the fact that the article being discussed here just takes the “this is wrong” approach, and never stops to consider that a truly safe and reliable implementation is not possible. There’s always another level of potential failure that isn’t being considered. There’s always another edge case that someone can and probably will make a “Well actually…” followup post about. So talking about “bugs” or “wrong” is not at all a useful way to go about it – what you have to talk about instead is what things should and reasonably can be your program’s responsibility, which basically never is what these articles talk about.

                                                                1. 2

                                                                  From a programmer perspective, OS X does not write to the filesystem when asked to. From an OS perspective, firmware doesn’t write to the hardware when you ask it to. The hardware itself can lie, too, or be buggy.

                                                                  I actually did about 6 months of research and concluded that based on pretty much exactly what you said, it’s surprising that computers function at all on any level, and wrote the whole thing off.

                                                          2. 3

                                                            I’d argue that software wiring to stdout or stderr and doesn’t support pipes is buggy especially in Unix.

                                                            Also given that in Unix there is a pipe() system call I would not necessarily tie it to shells. They are just the most common interface but maybe only because they are the most commonly used interface

                                                          1. 39

                                                            I can never decide when I look at SerenityOS whether writing an OS or a web browser from scratch is more impressive but I’m increasingly leaning towards the latter. Fantastic milestone!

                                                            1. 7

                                                              Browsers are easy, all the behaviour is specified, you just need to implement the specs. There only like 500 of them, so nothing too hard :D

                                                              1. 14

                                                                1.2k specifications for a total of 114 million words. For reference, the average length of a novel is 90 thousand words, so you could feasibly get through about one thousand, one hundred novels before you reach the length of the web browser specifications

                                                                1. 5

                                                                  I was joking, I know browsers are absurdly complex :D

                                                                  1. 1

                                                                    Where did you get those numbers?

                                                                    1. 2

                                                                      Drew DeVault, who did an analysis of this. I think it’s generally Verboten to link to his site here, though. The average books thing was just a search, which turned up a few publishers websites, which said most novels range from 50k to 150k words, and the average of most novels is 90k

                                                                      1. 1


                                                                        wait why?

                                                                        1. 1

                                                                          He was banned from lobsters on 2021-02-09 with the moderation log entry “Please go be loudly disappointed in the entire world (and promote sourcehut) somewhere else.”. At the same time it was made impossible to create a new story on lobsters with a URL pointing at his website.

                                                                          1. 3

                                                                            Mod log entry for “”, on 2021-02-09 12:32 -0600:

                                                                            Reason: I’m tired of merging hot takes, or cleaning up after the results of his trolling and sourcehut promotion.

                                                                            1. 1


                                                                          2. 1

                                                                            It’s fine to link to DeVault’s site in a comment, but the domain is blocked from submissions.

                                                                  1. 3

                                                                    Photography is not all-seeing in the sense that the eyes see. Our vision, a binocular one, is in a continuous state of flux, while the camera captures and fixes forever … a single, isolated, condition of the moment. Besides, we use lenses of various focal lengths to purposely exaggerate actual seeing, and we often “overcorrect” color for the same reason. In printing, we carry on our willful distortion of fact … —Edward Weston, 1932

                                                                    This, and the article, is exactly why hyperrealistic painting cannot match the true depth of the eye. Any painting or art style that is based on photographs alone cannot match how we perceive reality (it always has a sort of skewed perspective when matched with the actual scene, and once you’ve been trained to see it, it’s impossible to un-see this skewing), and it is why botanical artists and others of their ilk are still paid large sums of money to produce their work.

                                                                    1. 9

                                                                      I’m working on the OCaml compiler. The runtime code in C has been similarly stuck with c89 for MSVC support, but we recently merged the “Multicore OCaml” project which relies on C11 atomics. For now the plan is to stick with C11-aware compilers, and let our MSVC users hope that Microsoft adds support for atomics quickly enough (I hear that it has been announced as a feature coming soon for some years now). I spend most of my own time outside the C runtime, but I still find it super relaxing to be able to declare variables wherever, and in particular for (int i = 0; ...). Yay!

                                                                      1. 4

                                                                        MSVC, GCC, and Clang all have pretty good support for C++20 and the gaps in C++17 support are so small that I’ve not encountered them in real-world code that has to build with all three. I believe XLC and ICC are in a similar state, though I’ve not used either. C11 atomics are a port of C++11 atomics to C, with some very ugly corner cases. I don’t know how much effort it would be to make the OCaml compiler build as C++ but you’d have at least 3 production-grade compilers to choose between.

                                                                        1. 2

                                                                          C++ is a totally different standard and code can be safe in C, but unsafe in C++, and vice versa (IIRC there was a malloc difference such that C’s interpretation of the code is safer, and a zeroing related bug, too, it’s been about a half decade since I’ve seen them come up though and apparently my google-fu does not exist anymore). The languages are close enough lexically to trick you that they are compatible, but they are not. Such a change is likely to unnoticably break semantics meaning OCaml might in later years be found to be less secure, safe, and stable.

                                                                        2. 1

                                                                          The runtime code in C has been similarly stuck with c89 for MSVC support

                                                                          MSVC support C17 for few years.

                                                                          1. 4

                                                                            Actually the “declarations after statements” feature I mentioned was already available in Visual Studio 2013 (which still didn’t have all of C99, of course), but the problem is that we VS2013 was released, most Windows machines around did not have it installed. I don’t use Windows myself, but my understanding is that some OCaml users sell software that packages/extends the OCaml compiler, and they want to be able to compile their software on their clients machines, and those may only have old versions of MSVC / Visual Studio available.

                                                                            Long story short: for years Microsoft has been lagging a decade behind on C compiler support, and Windows users routinely use decades-old operating systems (even enterprise users, thanks to long-term-support from Microsoft), and the combination of the two creates incentives to stick with super-old versions of C.

                                                                            (Again, now we need C11 atomics, and MSVC support for C11 atomics is… not yet released? Well it’s only been 11 years now for the most important extension of C in the last two decades… So Maybe Microsoft will support C11 atomics in a year or so, and then it’s only ten more years of Windows users complaining that the software doesn’t build on their own systems.)

                                                                        1. 3

                                                                          I stumbled upon this ongoing series while looking into the Crystal language (Ary Borenszweig is one of its co-creators). It’s very instructive for me as I have no experience with Ruby. The comparisons with other languages are quite fair.

                                                                          1. 1

                                                                            I tried using Crystal to write a webserver related project. Kemal’s documentation is piss-poor, and most of my time was spent uselessly subverting the type system because they don’t have generic types, and because it kept expecting nil everywhere, because it kept forcing me to put things into unsafe containers (Example: A thing I created that was in a type safe container, had to get cast to a non-type safe hash simply to get the damn thing to work properly, then later it complains when trying to retrieve those attributes, because the container isn’t type safe! This isn’t a direct fault of the type system, it’s a fault of the workflow and the functions they provide for working with that type system).

                                                                            Not to mention, trying to extract attributes in a “type safe” way. You can verify that the thing is not nil, but you still need to explicitly cast after providing that guarantee, because it doesn’t seem to do any control flow modelling. Even then, an exception can still be thrown, which destroys any guarantee created by type safety in the first place.

                                                                            Your code can be entirely type safe enough to compile but can still display horrible, wretched behaviour, or outright do the equivalent of segfault, simply because an exception was thrown (Kemal will continue if an exception is thrown, but will malfunction afterwards and not properly process anything, which took a few whole days in production before it was actually noticed by a user).

                                                                            It’s the most horrifying, horrific, and disgusting experience I’ve had using a type safe language. I hope it gets better in the future because the promise it makes is wonderful (A C-level language! Completely type safe! That feels like ruby! how wonderful), but it is almost certainly not there yet.

                                                                            1. 2

                                                                              Thanks for your feedback!

                                                                              they don’t have generic types

                                                                              Keep in mind that I’ve just started with Crystal, but I think that they do now.

                                                                              About the documentation, I haven’t used packages/shards yet but I did notice that the language docs are spotty, especially in the tutorials section (they clearly often assume the reader to be a Ruby programmer, which I can understand actually!). However for the moment I found the specification quite good for learning!

                                                                              I’m bookmarking your comment to come back to it later, thanks again.

                                                                          1. 4

                                                                            Very interesting! A small aside, just so folks can know, Lena has officially requested people stop using her image for these sorts of things:

                                                                            1. 33

                                                                              TextMate and Transmit being “better than anything apt-get could give me” sounds rather amusing, considering that both vim and emacs have exploded in popularity in the last decade by taking in lots of those TextMate users :) And TextMate 2 is GPL, haha.

                                                                              Some programmers use proprietary software, sure. Outside of game dev though they more often than not absolutely despise it.

                                                                              The number one practical problem with using closed proprietary software is that you’re literally going back to basically where Stallman started – with that printer driver that he couldn’t just fix because it was closed.

                                                                              doing open source because that’s what we want to do, what we’re reinforced in doing, all the while invoking generalized, thoroughly hypothetical “users” to lend importance and nobility to our hobbies, compulsions, and fancies.

                                                                              I generally don’t think that much about users when working on hobby projects and don’t care about nobility. My projects are open source just because why the hell would I keep them to myself? They would just go to waste there and probably be lost forever. The public is the best backup/preservation system there is. If I helped someone by doing that, well, that’s just a nice bonus to me, not the goal.

                                                                              1. 22

                                                                                My reference to better-than-apt referred to that earlier time, when TextMate was hot new stuff. The day I bought my license, there wasn’t any comparable substitute in open source. And certainly nothing like the filesystem-based integration with Transit.

                                                                                Folks cloned the snippet system for Vim and Emacs pretty quickly, at least partway. But that wasn’t really even half the TextMate proposition. It was just the most visible bit, from the screencasts. It took a long time before anyone really went after the bundle system, the configuration flow, the UI, and the command namespace. When they did, they actually maintained TextMate bundle compatibility—direct clone. Eventually, Atom. More or less a GitHub founder’s pet project, so I’m told.

                                                                                I’m back on Debian now. UltiSnips for Vim, in the terminal. But the kind of work I do has changed. And it’s been 17 years. If Allan Odgaard had kept up pace with new ideas, rather than diverting into a big, HURD-style rewrite, I wonder where editors would be today.

                                                                                I think it’s fair to set games somewhat apart as its own world. It’s not really the same industry. Ditto film. But my experience doesn’t track yours beyond that. People despise bad software. Despite the hype, open ain’t always better. Mako Hill had a good bit on that.

                                                                                As for what people despise, I wouldn’t take that as any indication. Twitter’s full of folks venting about open source, too. Especially when they’re made to use it. That’s not to draw any equivalence. It’s just to say samples of grousing don’t tell us much.

                                                                                The Stallman printer story is canon. But I don’t think that makes it real. Most people, especially these days, don’t want to dive into an unfamiliar system for a feature add. They want to call somebody who knows the system, who’s committed to deliver. Or, failing that, drive-by some GitHub repo with a #feature issue, and miraculously see it closed by a PR on the double.

                                                                                For good, closed software done right, the end user experience is actually better. You ask, someone capable responds. No one calls you a noob, tells you RTFM, or throws the work to open a pull request back on you. The work gets done by the person best positioned to do it. The experience of the software honors the value of your time.

                                                                                I have more than a thousand GitHub repos, and have publicly referred to the platform as a shellmound. I’m not sure my random doodle repos counts as open source, for any meaningful sense of the term. GitHub don’t even insist on a license for free storage, as long as you’re comfortable hanging your laundry in public.

                                                                                1. 17

                                                                                  The Stallman printer story is canon. But I don’t think that makes it real. Most people, especially these days, don’t want to dive into an unfamiliar system for a feature add.

                                                                                  Counterpoint: For a developer or company with little money, which has been the case for the better part of my career (notably excluding my few years at Microsoft), if they want a feature, fix, or integration for an open-source dependency, they can make it happen given enough time, effort, and skill, but with a closed-source dependency, they’re stuck, unless perhaps they’re good at reverse engineering. That’s a big reason why I prefer open source for libraries, unless there just isn’t a good open-source solution for the problem at hand (e.g. speech synthesis or optical character recognition). Maybe I’m better than most at diving into an unfamiliar codebase and bending it to my will. I find it entirely plausible that Stallman was, or would have been, good at that too.

                                                                                  1. 8

                                                                                    Arguably, the possible spaces of software and the way it was interacted with and written were smaller, so Stallman probably would have been good at it. He was a systems programmer, in a systems programming environment, who wanted to hack on a systems progam/driver/firmware.

                                                                                    That doesn’t necessarily mean that most or even all developers can or should be able to say, step out of systems programming and instantly know how to fix a React bug that is plaguing them. Software is more diverse and more specific, and programming systems are more layered and orientated towards the problem, and out of that comes subfields that are non-transferrable even if some of the basic concepts are.

                                                                                    1. 10

                                                                                      I think the problem Stallman faced was that it was illegal to fix the driver. You technically don’t have to have knowledge to fix a React problem, it’s enough you can find someone who can and is allowed to (for payment, if need be).

                                                                                      FLOSS development doesn’t have to be a net drain on money. The FSF’s standard answer is “support and training”, and that’s fine as far as it goes, but it’s really hard to realize in an age where a project without good docs seldom gets traction and many developers choose burnout handling issues rather than asking for money.

                                                                                  2. 8

                                                                                    As for what people despise, I wouldn’t take that as any indication. … The Stallman printer story is canon. But I don’t think that makes it real. Most people, especially these days, don’t want to dive into an unfamiliar system for a feature add.

                                                                                    I think that, for folks who agree with these points, this makes sense and contextualizes the rest of the post. But not everybody will agree with this. Personally, I have written a Free Software driver in anger, regretting my hardware purchase and petitioning the vendor for documentation. It was a choice made not just from ability, but from desperation.

                                                                                    For good, closed software done right, the end user experience is actually better.

                                                                                    And for bad closed software done wrong? It can destroy hardware and hide malware, just to pick on one particularly rude vendor. Note that I would not be able to publish this sort of code in the Free Software ecosystem and convince people to use it, because folks would complain that the software doesn’t provide any functionality to the users. And this is a foundational weakness of proprietary software vendors: they are incentivized to make harmful software experiences due to privileged legal status. (Or, to be blunt: if I published this sort of malware, I would be arrested and jailed for crimes.)

                                                                                    1. 4

                                                                                      Haven’t done any real systems hacking in a long while. I did when I was young, and had more time. I definitely had to do some driver and firmware work, to get Linux working with various things. I’m not sure if I was angry going into those projects, but I remember being pretty frustrated coming out of them!

                                                                                      A lot of that came about from buying cheap hardware. I remember one Acer laptop in particular, the one I chose for college: great specs, great price, terrible build quality, total bodge-job, component- and firmware-wise. I eventually bought the MacBook, and came back to Linux on ThinkPads. I pay a premium for ThinkPads, but I get what I pay for, Linux hardware support very much included. It makes way more sense than spending hours brushing up and hacking patches.

                                                                                      As for bad proprietary software: oh yeah, it’s out there. But the idea that software vendors have some inherently privileged legal position doesn’t fly. They have copyright, and can require customers to buy licenses. But the terms of those licenses can and do vary. I have advised on several software license deals, for substantial money, on terms that basically boiled down to Apache 2.0 plus a payment clause, limited to just the paying customer.

                                                                                      If all you’re doing is buying licenses on take-it-or-leave-it terms, or negotiating with highly aggressive companies much bigger than yours, yeah, you’re likely to see terms that strongly favor the vendor. That’s how leverage works. But proprietary software sales get done on sane, fair terms all the time. Perpetual licenses. Modification rights. Meaningful warranties. Accountable maintenance commitments. Sometimes the less impressive product wins out, because the terms offered for it are better.

                                                                                    2. 7

                                                                                      Most people, especially these days, don’t want to dive into an unfamiliar system for a feature add

                                                                                      I think that is observably untrue, given the massive number of extensions available for all of the popular editors, for platforms such as GitHub, or even MS Office. The key point to remember is that being able to modify the behaviour of a program does not necessarily depend on its source being available. Somewhat counter-intuitively, it’s often easier in proprietary programs because they’re forced to maintain (and document) stable interfaces for third-party extensions, whereas open source projects can often just tell people to go and hack on the source directly. Specifically on editors, Vim, Emacs, and VS Code all have extension ecosystems that are significantly larger than the core product, which exist because people who were missing a feature decided to dive into an unfamiliar ecosystem and add it. VS Code and Emacs both did well by making that system less unfamiliar to their early userbase by building it on top of a language (Lisp, TypeScript) that this audience used.

                                                                                    3. 22

                                                                                      considering that both vim and emacs have exploded in popularity in the last decade by taking in lots of those TextMate users :) And TextMate 2 is GPL, haha.

                                                                                      Some programmers use proprietary software, sure. Outside of game dev though they more often than not absolutely despise it.

                                                                                      Get out of your bubble. Outside that bubble a lot of developers use JetBrains IDEs or Visual Studio. Visual Studio Code has gained a lot of traction in recent years, but initially mostly because Code was much better for web development than the competition and it is free. Not because it is open source [1].

                                                                                      In the most recent Stack Overflow developer survey, Visual Studio Code is used by 71.07% of developers, Visual Studio by 32.92%, IntelliJ by 29.69%. The most popular fully (?) open source editor is actually Notepad++ with 29,09%. And vim takes the next place at 24,82%, but I wouldn’t be surprised that is because people use vim when doing quick edits remote Linux machines. Emacs dangles somewhere at the bottom of the list with only 5,25%, surpassed by many proprietary applications like Xcode, PyCharm, or Sublime Text.

                                                                                      The number one practical problem with using closed proprietary software is that you’re literally going back to basically where Stallman started – with that printer driver that he couldn’t just fix because it was closed.

                                                                                      I agree that this is a major downside of closed source software. But most people want to fix the things they are working on, not their tools.


                                                                                      1. 10

                                                                                        proprietary applications like […] PyCharm

                                                                                        PyCharm/IntelliJ IDEA are Apache2 and most devs use the free software version available at

                                                                                        1. 2

                                                                                          PyCharm/IntelliJ IDEA are Apache2 and most devs use the free software version

                                                                                          I have no reason to doubt this, but are you aware of any usage statistics? I’m curious whether “most devs” is more like “just over half” or “over 99%.”

                                                                                          Anecdotally, every company I’ve worked at where the devs used JetBrains IDEs has paid for the commercial version, but totally willing to believe those companies aren’t typical.

                                                                                          1. 1

                                                                                            From my anecdotal experience, no company has paid for the commercial JetBrains version, even when most of the devs use it. It might very well be a cultural thing.

                                                                                            1. 3

                                                                                              At the two companies where I used it, we paid for the whole toolbox subscription for every developer who wanted it. Most of us used IDEA Ultimate and one or more of CLion, AppCode or PyCharm Professional. Many of us also used DataGrip.

                                                                                              I still maintain a subscription for my consulting work now, too.

                                                                                              1. 1

                                                                                                Can’t speak for PyCharm particularly but every other flavor of IDE based on IntelliJ, I only know of companies who have paid, be it PHPStorm or more likely Ultimate (if working on many languages).

                                                                                          2. 5

                                                                                            I don’t really disagree with you, but your arguments seem kind of weak.

                                                                                            Get out of your bubble.

                                                                                            In the most recent Stack Overflow developer survey […]

                                                                                            What now? It’s just another bubble.


                                                                                            I haven’t ever used any of those “best parts” and never seen anyone using them.

                                                                                            1. 2

                                                                                              I haven’t ever used any of those “best parts” and never seen anyone using them.

                                                                                              I’ve used the remote stuff. That and PlatformIO are the only things that ever cause me to use VS Code over emacs or one of the JetBrains tools.

                                                                                              The extension marketplace is proprietary too, and I’d call it one of the best parts of VS Code.

                                                                                          3. 10

                                                                                            Some programmers use proprietary software, sure. Outside of game dev though they more often than not absolutely despise it.

                                                                                            I mean, there’s Vivado, and then there’s Visual Studio, just like there’s, I dunno, a steaming, rotten pile of horse shit and then there’s pancakes.

                                                                                            There are many bubbles in the tech world and game dev is only one of them. I worked in an embedded shop where the state of Linux was that we had one colleague who tried Fedora and he thought it was like a beta or something because he couldn’t put things on the desktop and, in his own words, he expected some things not to work as well as Windows but that was years away from being useful. The thought of writing code in a text editor after finishing college, where they put you through the ritual of compiling stuff you wrote in vim by writing gcc incantations, seemed about as foreign to these guys as the idea of sailing to America on a steam ship.

                                                                                            There are plenty of bubbles where programmers use both kinds of tools, too. Way back when I was doing number crunching, everyone at the lab was using emacs, vim, nedit or notepad, but also Matlab, which everyone hated for various reasons but nowhere near as much as they hated, say, gdb. We worked a lot with another research group at another university where it was the other way around: someone had figured Octave was good enough and they had just one Matlab installation for things Octave really couldn’t do or to port their code, and used the money they saved on Matlab licenses to buy a bunch of Windows and Visual Studio licenses.

                                                                                            I don’t have much in the way of numbers here but you shouldn’t take a tweet about Vivado as the standard about what people think about closed source tools. Vivado is successful because it barely works and there are no alternatives that work (for any non-hobbyist definition of “works”) – it’s successful largely by vendor lockdown.

                                                                                            1. 4

                                                                                              Speaking of bubbles, I have literally not even heard of Vivado before today.

                                                                                              1. 3

                                                                                                Well, what can I say, not every case of acute horse diarrhea deserves to be famous :-D.

                                                                                                But seriously, this is one of the things I love about our work. Vivado is huge. I suspect it’s already old enough that virtually everyone who finishes an EE or CompEng degree has seen it at least once (it’s about ten years old, I think, and it replaces another suite called ISE which was also all sorts of horrible in its own way). It’s very likely that it’s been involved in one way or another in dozens of stories that popped up here on, like stories about RISC-V or cryptography or FPGA implementations of classical systems. And it’s perfectly possible for someone to be an excellent programmer and earn a living writing code and never hear about it. No matter how good you are at anything computer related, there’s always something out there big enough that it’s got tens of thousands of people behind it that you had no idea about.

                                                                                                If you keep an open mind, computer engineering will surprise you in all sorts of fresh ways, all the time – not all of them good but oh well. Dogmatism is fun and it feels like you’re right all the time but it’s really fscking boring. I’ve done it and it sucks.

                                                                                              2. 1

                                                                                                By reputation, another reason Vivado is successful is because all the other FPGA toolchains are reportedly even worse. Don’t get me wrong, Vivado is a tyre fire that segfaults, but the others are apparently even less reliable.

                                                                                                e.g. I’ve heard that at some shops, people writing FPGA code targeting competing FPGAs will actually write and debug their entire project on Xilinx FPGAs with Vivado and then port the code to the other toolchain for the originally intended target FPGA.

                                                                                                1. 6

                                                                                                  I’ve done too little real work on Altera’s stuff to have had first-hand experience but from the little I’ve done I can certainly say Quartus sucked at least as much as Vivado back when I last touched it (2015-ish?). Maybe it’s changed in the meantime but somehow I doubt it :-D. I heard Lattice’s stuff is tolerable but I never tried it. I did try Microsemi’s Libero thing though and it makes Vivado feel like Visual frickin’ Studio. Porting designs between toolchains is not quite like porting program code and it sounds like a really bad idea on paper but, indeed, given how bad some of these tools are, I can imagine it’s just the only way to do things productively sometimes.

                                                                                                  But it’s really a lot more complicated than how good the toolchain is. A big – probably the biggest – reason why Vivado and Quartus are so successful is simply that Xilinx and Altera… well, Intel, are really successful. The next version of Vivado could suck ten times as bad as the current one and it would barely put a dent in their market share, just because it’s what you use to do things with Xilinx’ devices. Developer souls are a lot more fungible than silicon.

                                                                                                  Also, being so big, they both have roots in the academic world and they run deep, and it’s simply what lots and lots of people learn in school. They’re not very good but as long as the bitstream flows out, who you gonna call?

                                                                                                  A competitor with better development tools could, in theory, steal a chunk of this market, but that chunk would be exactly as big as how many programmable logic devices they can sell, and there are constraints – both technical (as in, performance) and non-technical – that dictate that long before anyone even considers the quality of development tools. The usual retort is that developer tools are important for productivity. And they are, but the best designs, from the most productive teams, won’t be worth crap if there are no physical devices for them, or if these devices cannot be obtained on time and in the required quantity and at the right price and so on.

                                                                                                  I also secretely suspect that it’s just a case of the audience of these tools being a little more tolerant to weirdness and poor quality. I mean, they taught me how a transistor works in my second year of uni. I then spent the other half of my undergrad years (and I could’ve spent a whole two years of masters’ on that, too) learning about all the ways in which it doesn’t quite work exactly like that. Software segfaulting under your nose is just a tiny drop of weird shit in a very big bucket of weird shit which people way smarter than you reverse-engineered out of nature. Your entire job revolves around manipulating all sorts of weird but inevitable things. So you just learn to chalk up the fact that Vivado crashes if you have more than 64 mux instances whose names start with the letter X under “inevitable” [1], somewhere between “all P-N junctions have leakage current” and “gate capacitance varies with gate oxide thickness”. What’s one more?

                                                                                                  [1] Note that this is something I just made up on the spot but it does sound like something Vivado would do…

                                                                                                  1. 2

                                                                                                    A competitor with better development tools could, in theory, steal a chunk of this market, but that chunk would be exactly as big as how many programmable logic devices they can sell

                                                                                                    You don’t exactly need to sell programmable logic devices to steal a chunk of FPGA development tool market. Symbiflow has already done that with Lattice’s FPGAs, and are slowly starting to bite into Xilinx FPGAs as well. Quicklogic just released their new FPGA product without their own software, just by giving Symbiflow their bitstream generator and FPGA definitions. There are signs that the new Renesas FPGAs are using Yosys (part of Symbiflow) too.

                                                                                                    The reason why these closed software tools are so entrenched is that they are tied in with hardware. And as of now, open source hardware is a lot more niche thing, than open source software. With time, that will probably change, but even then, the software landscape in places dealing with hardware will progress faster. Just remember, how a while ago working on microcontrollers almost always meant dealing with vendor-specific IDEs. That is basically gone now. With time, that will happen with most FPGAs as well.

                                                                                                    1. 1

                                                                                                      I haven’t tried Symbiflow since 2020 and it’s a project I’m really cheering for, so I’m not going to say anything bad or unenthusiastic about it. But it’s worth keeping in mind that the iCE40 line (the only one that it supports well enough to be usable for real life-ish projects) has a very straightforward, wrinkle-free architecture that lends itself easily to reverse-engineering. Even though the underlying technology is physically the same, as in, it’s based on the same technology (FPGA), the market Symbiflow can realistically target is practically different from the one where people are using Vivado and complaining about it. Its relative success in this field is important and useful, not to mention liberating to a lot of people (including yours truly) but I wouldn’t be too quick to generalize it.

                                                                                                      This approach will probably find some success at the low-power, low-cost end of the spectrum, where not only are customers rather unwilling to pay the licensing costs, but some companies, especially fabless vendors like Quicklogic, would be reasonably happy to be rid of software development cost. But this part of the FPGA market works in entirely different ways than the part of the FPGA market that’s bringing the big bucks for Xilinx (and Altera) and where the people who associate the word Vivado with an overwhelming feeling of dread work. For one, it’s not a field where architecture and fabrication technology are important competitive advantages, so there’s not that much value in keeping it closed and keeping the software tied to it.

                                                                                              3. 11

                                                                                                Some programmers use proprietary software, sure. Outside of game dev though they more often than not absolutely despise it.

                                                                                                I don’t know, I would far rather use Visual Studio than i.e. whatever editor + gdb again.

                                                                                                1. 6

                                                                                                  You’re right that systems programmers and hardware devs prefer small and lean tools, which are often released as open source, but walk into any corporate dev house and you’ll see a lot of Visual Studio and IntelliJ with Xcode and other IDEs sparkled in. The sole exception to this are web devs, whose first usable tool was VScode.

                                                                                                  If you have the skills and time to hack on your tools, open source is better, but for most people it’s just a better proposition to pay someone else for their tools and use the saved time to do their job and make that money.

                                                                                                  1. 4

                                                                                                    Actually most devs use proprietary software, and kemitchell even mentions this in the post. He switched to Mac, but Windows is still the most popular platform even amongst devs[1]. I suspect the Stack Overflow survey results are even skewed and that Linux likely has less market share than they found.


                                                                                                    1. 2

                                                                                                      I hope I made the point that devs do use proprietary software. It’s not true that devs just won’t use closed code. But I don’t have data to support the claim that most devs do. I suppose you could get there by arguing Windows and OS X are closed, and the number of folks on Linux is small. I’ve enjoyed looking at the Stack Overflow survey, but I have no idea how representative that is.

                                                                                                      For what it’s worth, when it comes to laptops and desktops, I’m back on Linux again. I did switch to Mac when I was younger. And I did my programming career that way, before going to law school.

                                                                                                      1. 1

                                                                                                        I have a trifecta! I have a Linux laptop (which I used when I first joined the company to do development), a Mac laptop (which I also do development on) and a Windows laptop (because our Corporate Overlords are Windows only) that I don’t use, and can’t return (I’ve asked).

                                                                                                      2. 2

                                                                                                        But how much of that is because companies require Windows? When I was hired at my current company, half the employees used Macs (mostly developers) and the other half Windows. We then got bought out by an “enterprise” company, and they use Windows exclusively. They even sent me a Windows laptop to use, even though I use a Mac. The Windows laptop sits unpowered and unused, only to be turned on when I’m reminded that I have to update the damn thing.

                                                                                                    1. 6

                                                                                                      Programmers use software in various shades of “closed” all the time. It’s not hard to find companies selling proprietary tools, libraries, frameworks, and other components galore, if you’re willing to look on Google, and not just on public GitHub, npm,, RubyGems, &c. College students, hobbyists, and unfunded startup types who pay for their laptops and stop paying there represent a small, transient sliver of the trade.

                                                                                                      Look in video games. Computer-aided drafting. 3D printing. Computer numerical control. Throw a rock.

                                                                                                      Exactly, Dragon Ruby is a good example of this, IMHO

                                                                                                      Since my software will target programmers, I can’t make it closed source, or it won’t get used. Simple as that.

                                                                                                      Objectively false. Unless your software—in Gavin’s case, a new build tool—just isn’t that much better than make. To literally anyone.

                                                                                                      And this is the crux of the thing, and the entire flaw with the original article about closed source software. People will only pay for closed source software if they can’t already acquire a ‘good enough’ alternative for free.

                                                                                                      The Make(1) example is well-put, I think LibreOffice/OpenOffice grew from the same effect, most people had used Microsoft in a business environment, however it was not free, so the closest free alternative was Libreoffice. Look at cancel and his “Ripcord” Discord client, for an example of how his closed source software took off on a small scale, but was quickly outclassed in market by “BetterDiscord”, which provides many of the same features for free, as a simple Javascript layer over the existing Discord client (The Ripcord Discord server has 464 people, whereas BetterDiscord’s Discord server has 82 thousand).

                                                                                                      To most users, it really doesn’t matter how open the software is, cost versus features is a harder hurdle to jump.

                                                                                                      1. 5

                                                                                                        Look at cancel and his “Ripcord” Discord client, for an example of how his closed source software took off on a small scale, but was quickly outclassed in market by “BetterDiscord”, which provides many of the same features for free, as a simple Javascript layer over the existing Discord client (The Ripcord Discord server has 464 people, whereas BetterDiscord’s Discord server has 82 thousand).

                                                                                                        To be fair, I think Ripcord is inherently a lot more niche than BetterDiscord, even if the free/proprietary side was swapped there. A replacement client for a specific kind of taste is gonna be a lot smaller than a do-everything bolt-on for the thing you already use.

                                                                                                        1. 3

                                                                                                          Also, in this specific case there is significant market pressure in the form of Discord banning people for using non-official clients, which heavily favors the JS plugin approach.