1. -2

    Language design is a vanity project. Why would anybody fund somebody else’s vanity project when they could use the money to fun their own vanity project?

    If somebody enjoys designing and implementing their own language, then good for them for being able to do something they are passionate about.

    The vanity (or strategic marketing, depending on your point of view) language development of corporate languages are invariably going to be better funded than individual, or group, projects.

    The world does not owe anybody a living. Be thankful for having the resources to spend time on a vanity project.

    1. 18

      Why would anybody fund somebody else’s vanity project when they could use the money to fun their own vanity project?

      Because you find value in it. The same reason people pay subscriptions to Netflix or their favorite YouTuber, or have subscriptions to Patreon’s of game modders or anyone else.

      The world does not owe anybody a living. Be thankful for having the resources to spend time on a vanity project.

      Where does this sentiment come from? I didn’t read anything about anyone owing anyone anything in the linked post.

      1. 9

        Can you define “vanity project” here? It seems you are making a value judgment, the phrase implies that such projects have little value aside from stroking one’s ego. I wonder what has value, in your eyes.

        Are you saying that because computer languages already exist, there is no value to having new languages?

        Do humans already communicate perfectly with computers? Do computers perfectly meet humanity’s needs? Are computer programs free of bugs and vulnerabilities? Are all programs fast and efficient, user-friendly, and easy+quick to develop properly? Is there no room for improvements over existing languages that might help address these issues?

        1. 9

          For elm specifically its designers seem to have very strong opinions on how to do things “right”, to the detriment of users (see e.g. https://dev.to/kspeakman/elm-019-broke-us--khn)

          A major way to have a software project create a steady income flow is to get companies on board (they’re much less cost sensitive than individual users) but pulling the rug under their feet is a sure way to make sure that this won’t happen.

          So for elm specifically, I think “vanity project” is an apt description.

          1. 3

            Agreed, and “getting companies on board” doesn’t necessarily mean compromising design decisions like he describes. If people are willing to invest in your alternative language that means that they largely agree with your design principles and values. But it does mean providing the kinds of affordances and guarantees that allow an organization to be in control of their own destiny and engineer a robust and maintainable system. Elm has had almost no energy invested into these concerns.

          2. 1

            I see nothing wrong with a project whose purpose is enjoyment, that includes some amount of stroking of ego.

            Finding out which language features have the greatest amount of some desirable characteristic requires running experiments. I’m all for running experiments to see what is best (however best might be defined).

            Creating a new language and claiming it has this, that or the other desirable characteristics, when there is no evidence to back up the claims, is proof by ego and bluster (this is a reply to skyfaller’s question, not a statement about the linked to post; there may be other posts that make claims about Elm).

            1. 9

              How would a person establish any evidence regarding a new language without first designing and creating that new language? I agree that evidence for claims is desirable, but your original comment seems to declare all new language design to be vanity (i.e. only good for ego-stroking), and that’s a position that requires evidence as well. Just because a language has not yet proven its value does not mean it has no value. Reserving judgment until you can see some results seems a more prudent tactic than, well, prejudice.

              1. 0

                First work out what language features are best, then design the language. There are plenty of existing languages to experiment with.

                Design/implement language, get people to learn it, write code using it, and then run experiments is completely the wrong way of doing things.

                1. 2

                  How do you work out which features are best if the ones you’re trying don’t exist yet? Wouldn’t that require designing and implementing them and then let people use them?

                  1. 1

                    To be able to design/implement a language feature that does not yet exist, somebody needs to review all existing languages to build a catalogue of existing features; or, consult such a catalogue if it already existed.

                    I don’t know of the existence of such a catalogue, pointers welcome.

                    Do you know of any language designer who did much more than using their existing knowledge of languages?

                    1. 3

                      You wouldn’t have to know all existing language features to invent a new approach, and the only way to test a new approach would be to build it and let people use it.

                      I think I’m lost as to where your argument is headed.

          3. 5

            Why would anybody fund somebody else’s vanity project when they could use the money to fun their own vanity project?

            Because they realise that there’s greater benefit in them having the other project with increased investment than in their own project. The invisible hand directs them to the most efficient use of resources.

            Because they realise an absolute advantage the other project has in producing a useful outcome, and choose to benefit from that advantage.

            Because they are altruists who see someone doing something interesting and decide to chip in.

            Because they aren’t vain.

          1. 1

            My solution:

            items
            |> Enum.sort_by(& &1.points * -1)
            |> Enum.map_reduce(nil, fn
              item, nil -> {Map.put(item, :ranking, 1), {1, item.points, 1}}
              %{points: points} = item, {rank, points, count} -> {Map.put(item, :ranking, rank), {rank, points, count + 1}}
              %{points: points} = item, {rank, _, count} -> {Map.put(item, :ranking, rank + count), {rank + count, points, 1}}
            end)
            |> elem(0)
            |> IO.inspect()
            
            1. 1

              Nice trick with that Enum.sort_by/2. I used tuple in my solution to not need to handle item, nil as a separate case. I thought about using pattern match in the closure, but I thought that separate helper function will be clearer.

            1. 19

              Cory Doctorow:

              You should care about privacy because privacy isn’t secrecy. I know what you do in the toilet, but that doesn’t mean you don’t want to close the door when you go in the stall.

              1. 2

                What’s the connection to Rust?

                1. 2

                  Jess and Bryan appear be be hedging their startup on Rust.

                  *edit: they talk about rust throughout the episode.

                  1. 2

                    I wonder if he has decided that writing a better low level programming language might be a more significant undertaking than he thought, especially if he hopes to primarily program video games…

                    1. 2

                      I don’t think so. You can find videos of him demonstrating the language in great detail on his YouTube page: https://www.youtube.com/user/jblow888/playlists

                      1. 1

                        Who knows. In the episode, Jonathan Blow doesn’t appear to indicate that he sees Rust solving his specific problems. I appreciated all the lamentations and the insights and the ranting. After 20 years I feel every pain point they ranted on.

                      2. 1

                        *edit: they talk about rust throughout the episode.

                        First mention I noted was somewhere around 1:31:14 (h:m:s) into the podcast or so.

                    1. 1

                      I agree with a lot of the points he makes, but testing is the fly in the ointment. It’s much harder to test a 200 line function as compared to a couple smaller functions.

                      1. 2

                        I use this style all the time for batch processing glue code that’s not easy to unit test anyway. It makes sense to limit the scope of variables as much as possible. I regularly promote variables to higher levels of scope than what I initially predicted when they’re heavily used. It’s cleaner, and easier to refactor than threading unrelated state values in and out of multiple functions with awkwardly constructed structs or tuples.

                        1. 1

                          He’s not talking about pure functions, where a granular separation of functionality improves testability, but rather cases where the program coordinates many stateful calls. Unit tests of functions split out from that kind of procedure don’t actually tell you much about the correctness of the program and generally become dead-weight change-detectors.

                          1. 1

                            I agree that change-detector tests are worthless. I guess if there are no pieces that can be separated out as pure functions then yes, inlining makes a lot more sense.

                        1. 73

                          It has a grandiose claim and and tries to attach itself to a well-respected coding standard, but it smells like a post-hoc justification for the unpalatable state of the code.

                          The code looks like a state machine. And a state machine can be written either as a spaghetti code of ifs, with omg-space-shuttle-will-crash-if-you-forget-an-else fear, or as a table with state transitions, which by construction ensures everything is accounted for.

                          1. 26

                            as a table with state transitions

                            I’ve the feeling that most developers (with a CS degree) forgot about this. And on the other side, there’s also a big component of lack of education on the topic. I’m not sure how many common programmers have been instructed or invested time learning about state machines.

                            That said, it is definitely a good mentoring/training topic. I think it will be well received by my team, and in any case should start circulating the knowledge more. Does anyone have good resources on this?

                            1. 1

                              I read this and thought, well, could you unit test this code to ensure correctness? I know unit testing threading behavior is tough, but if this is space shuttle levels of risk, might that effort be worth it?

                              1. -1

                                Perhaps. Perhaps you just crashed the ship.

                                1. 11

                                  Nope. Not buying it. This is cheesy schtick covering up some very questionable coding practices.

                                  I am a late stage beginning programmer struggling towards journeyman, and even I must ask “Why not AT LEAST use methods to collapse some of these 10 level deep conditional nests?”.

                                  Good software engineering practice strives to keep code easy to reason about and thus more readable and maintainable. As much as we all love to be entertained by seeing HERE BE DRAGONS in source code, nobody actually thinks this is a GOOD idea.

                                  This is an invitation to deviation of normalcy, and I can’t see any good at all coming out of it.

                                  1. 12

                                    I think the received wisdom about small functions and methods has gotten somewhat muddled. The small functions style has become an aesthetic preference (which I adopted and still observe in myself) that is applied arbitrarily without any objective understanding of its effects.

                                    For things that are actually functions in the mathematical sense (i.e., pure functions) a granular separation of functionality simplifies testing and composition. But procedures that mutate state or coordinate multiple stateful systems are not testable and composable in the same way. In this context, the small functions/methods style is actually an obstacle to understanding the system and ensuring correctness.

                                    See: http://number-none.com/blow/john_carmack_on_inlined_code.html

                                    1. 1

                                      I think the received wisdom about small functions and methods has gotten somewhat muddled. The small functions style has become an aesthetic preference (which I adopted and still observe in myself) that is applied arbitrarily without any objective understanding of its effects.

                                      Again, I am but an acolyte, but from my super simplistic perspective, having 8 levels of conditional nesting makes code SUPER hard to reason about, and when you break that into methods that signal the intent of the code contained within you increase readability.

                                      I guess I’d thought of that as beyond argument. I’ll read the Carmack article, thanks for the link.

                                      1. 2

                                        Yeah that’s definitely the accepted dogma but I’ve observed the opposite in large systems I’ve worked on (although it took a while for me to see it). If you look at game engines, which do some of the most complex coordination of stateful systems anywhere, you will see the large procedure/nested conditional style. This doesn’t come from an ignorance of the ability to make small methods.

                                        The intent communicated by factoring code into small methods is that these calls can be rearranged and reused at will, but for stateful calls this most often isn’t true.

                                        1. 1

                                          I can also imagine that in game engines simply eating the overhead induced by a method call (stack, heap, etc.) could be problematic.

                                          Lesson for me here is that there are almost no hard and fast rules where code is concerned, but I still think that for the class of very non computationally intensive process control (Devops) work I do, having small, readable, clearly named methods rather than giant nesting structures is a best practice I’ll stand by.

                                          1. 1

                                            I think it’s a mistake to think of it in terms of performance optimization. From the above article:

                                            In no way, shape, or form am I making a case that avoiding function calls alone directly helps performance.

                                    2. 1

                                      Also super interesting how people throw around down votes like candy.

                                      How can my failure to buy into the argument being purveyed by the author possible be incorrect ?

                                1. 2

                                  This is conflating a few things.

                                  First of all, I would argue that you can’t do engineering without understanding your company’s business. A software engineer has to balance lots of different factors when building a system, but the one factor that cannot be compromised is the amount of time and/or money that your organization can afford to spend on a given system in order to be sustainable. I agree this understanding is important, but it has very little to do with marketing.

                                  Secondly, there is a kind of marketing which is just finding a way to inform potential customers about your product and explaining how it could help them. I think you’d be hard-pressed to find anyone who thinks this is evil. Then there is a whole other class of activity also called marketing which is varying degrees of manipulative, dishonest, and ineffectual make-work (see: most of the ad-tech industry). I think you’d be hard-pressed to argue that these activities aren’t evil without resorting to nihilism.

                                  1. 15

                                    Multithreading usually requires a bit more programming work to distribute tasks properly, but hey, this is Tesla we’re talking about — it’s probably a piece of cake for the company.

                                    haha hahahaha oh oh oh yeah definitely this is Tesla Motors we’re talking yeah

                                    1. 1

                                      I don’t think that thread says anything about the expertise of the team that would have to implement multithreaded code, or anything about the overall level of development expertise at Tesla, really. If you’ve worked in software for a while, you should have plenty of stories like that yourself. (If you don’t, I contend you’ve been unusually lucky with your choice of employers.)

                                    1. 11

                                      Summary: author’s expectations of a young language exceed the actual implementation, so they write a Medium article.

                                      If you can’t tell: slightly triggering article for me, and I don’t use/advocate for Elm. I’d much prefer if the author either pitched in and helped, or shrugged and moved on to something else. Somehow, yelling into the void about it is worse to me, I think because there are one or two good points in there sandwiched between non-constructive criticisms.

                                      1. 34

                                        The article provides valuable information for people considering using Elm in production. The official line on whether Elm is production ready or not is not at all clear, and a lot of people suggest using it.

                                        1. 6

                                          I didn’t like that he makes unrelated and unsupported claims in the conclusion (“Elm is not the fastest or safest option”). That’s not helpful.

                                          1. 5

                                            I read “fastest” and “safest” as referring to “how fast can I can get work done” and “is this language a safe bet”, not fast and safe in the sense of performance. If that’s the right interpretation, then those conclusions flow naturally from the observations he makes in the article.

                                            1. 1

                                              Right, the author made the same clarification to me on Twitter, so that’s definitely what he meant. In that sense, the conclusion is fine. Those are very ambiguous words though (I took them to mean “fastest runtime performance” and “least amount of runtime errors”).

                                              1. 1

                                                Yeah definitely. I also was confused initially.

                                          2. 3

                                            TBF, I was a little too snarky in my take. I don’t want to shutdown legitimate criticism.

                                            The official line on whether Elm is production ready or not is not at all clear, and a lot of people suggest using it.

                                            That ambiguity is a problem. There’s also a chicken/egg problem with regard to marketing when discussing whether something is production ready. I’m not sure what the answer is.

                                            1. 4

                                              It’s even more ambiguous for Elm. There are dozens of 100K+ line commercial code bases out there. How many should there be before the language is “production ready”? Clearly, for all those companies, it already is.

                                              Perhaps the question is misguided and has reached “no true Scotsman” territory.

                                              1. 3

                                                That’s one reason why this topic is touchy to me: things are never ready until the Medium-esque blogosphere spontaneously decides it is ready, and then, without a single ounce of discontinuity, everyone pretends like they’ve always loved Elm, and they’re excited to pitch in and put forth the blood, sweat, and tears necessary to make a healthy, growing ecosystem. Social coding, indeed.

                                                In a sense, everyone wants to bet on a winner, be early, and still bet with the crowd. You can’t have all those things.

                                                1. 2

                                                  I like your last paragraph. When I think about it, I try to reach the same impossible balance when choosing technologies.

                                                  I even wrote a similar post about Cordova once (“is it good? is it bad?”). Hopefully it was a bit more considered as I’d used it for 4 years before posting.

                                                  The thing that bothers me with the developer crowd is somewhat different, I think. It’s the attempt to mix the other two unmixable things. On one hand, there’s the consumerist attitude to choosing technologies (“Does it work for me right now? Is it better, faster, cheaper than the other options?”). On the other hand, there are demands for all the benefits of open source like total transparency, merging your PR, and getting your favourite features implemented. Would anyone demand this of proprietary software vendors?

                                                  I’m not even on the core Elm team, I’m only involved in popularising Elm and expanding the ecosystem a bit, but even for me this attitude is starting to get a bit annoying. I imagine it’s worse for the core team.

                                                  1. 2

                                                    Hey, thanks for your work on Elm. I’m much less involved than you, but even I find the “walled garden” complaints a little irritating. I mean, if you don’t like this walled garden, there are plenty of haphazard dumping grounds out there to play in, and even more barren desert. Nobody’s forcing anybody to use Elm! For what it’s worth, I think Evan and the Elm core team is doing great work. I’m looking forward to Elm 1.0, and I hope they take their time and really nail it.

                                                  2. 2

                                                    The author of this article isn’t pretending to be an authority on readiness, and claiming that they’ll bandwagon is unwarranted. This article is from someone who was burned by Elm and is sharing their pain in the hopes that other people don’t get in over their heads.

                                                    Being tribal, vilifying the “Medium-esque blogosphere” for acts that the author didn’t even commit, and undermining their legitimate criticisms with “well, some people sure do love to complain!” is harmful.

                                              2. 3

                                                I’d like to push back on this. What is “production ready”, exactly? Like I said in another comment, there are dozens of 100K+ line commercial Elm code bases out there. Clearly, for all those companies, it already is.

                                                I’ve used a lot of other technologies in production which could easily be considered “not production ready”: CoffeeScript, Cordova, jQuery Mobile, Mapbox. The list goes on. They all had shortcomings, and sometimes I even had to make compromises in terms of requirements because I just couldn’t make particular things work.

                                                The point is, it either works in your particular situation, or it doesn’t. The question is meaningless.

                                                1. 7

                                                  Here are my somewhat disjoint thoughts on the topic before the coffee has had a chance to kick in.

                                                  What is “production ready”, exactly?

                                                  At a minimum, the language shouldn’t make major changes between releases that require libraries and codebases to be reworked. If it’s not at a point where it can guarantee such a thing, then it should state that fact up front. Instead, its creator and its community heavily promote it as being the best thing since sliced bread (“a delightful language for reliable webapps”) without any mention of the problems described in this post. New folks take this to be true and start investing time into the language, often quite a lot of time since the time span between releases is so large. By the time a new release comes out and changes major parts of the language, some of those people will have invested so much time and effort into the language that the notion of upgrading (100K+ line codebases, as you put it) becomes downright depressing. Not to mention that most of those large codebases will have dependencies that themselves will need upgrading or, in some cases, will be have to be deprecated (as elm-community has done for most of my libraries with the release of 0.19, for example).

                                                  By promoting the language without mentioning how unstable it really is, I think you are all doing it a disservice. Something that should be perceived as good, like a new release that improves the language, ends up being perceived as a bad thing by a large number of the community and so they leave with a bad taste in their mouth – OP made a blog post about it, but I would bet the vast majority of people just leave silently. You rarely see this effect in communities surrounding other young programming languages and I would posit that it’s exactly because of how they market themselves compared to Elm.

                                                  Of course, in some cases it can’t be helped. Some folks are incentivized to keep promoting the language. For instance, you have written a book titled “Practical Elm” so you are incentivized to promote the language as such. The more new people who are interested in the language, the more potential buyers you have or the more famous you become. I believe your motivation for writing that book was pure and no one’s going to get rich off of a book on Elm. But, my point is that you are more bought into the language that others normally are.

                                                  sometimes I even had to make compromises in terms of requirements because I just couldn’t make particular things work.

                                                  That is the very definition of not-production-ready, isn’t it?

                                                  Disclaimer: I quit Elm around the release of 0.18 (or was it 0.17??) due to a distaste for Evan’s leadership style. I wrote a lot of Elm code (1 2 3 4 and others) and put some of it in production. The latter was a mistake and I regret having put that burden on my team at the time.

                                                  1. 1

                                                    From what I’ve seen, many people reported good experiences with upgrading to Elm 0.19. Elm goes further than many languages by automating some of the upgrades with elm-upgrade.

                                                    FWIW, I would also prefer more transparency about Elm development. I had to scramble to update my book when Elm 0.19 came out. However, not for a second I’m going to believe that I’m entitled to transparency, or that it was somehow promised to me.

                                                    To your other point about marketing, if people are making decisions about putting Elm into production based on its tagline, well… that’s just bizarre. For example, I remember looking at React Native in its early stages, and I don’t recall any extensive disclaimers about its capabilities or lack thereof. It was my responsibility to do that research - again, because limitations for one project are a complete non-issue for another project. There’s just no one-size-fits-all.

                                                    Finally, calling Elm “unstable” is simply baseless and just as unhelpful as the misleading marketing you allege. I get that you’re upset by how things turned out, but can’t we all have a discussion without exaggerated rhetoric?

                                                    That is the very definition of not-production-ready, isn’t it?

                                                    Exactly my point: there is no such definition. All those technologies I mentioned were widely used at the time. I put them into production too, and it was a good choice despite the limitations.

                                                    1. 6

                                                      From what I’ve seen, many people reported good experiences with upgrading to Elm 0.19. Elm goes further than many languages by automating some of the upgrades with elm-upgrade.

                                                      And that’s great! The issue is the things that cannot be upgraded. Let’s take elm-combine (or parser-combinators as it was renamed to), for example. If you depended on the library in 0.18, then, barring the invention of AGI, there’s no automated tool that can help you upgrade because your code will have to be rewritten to use a different library because elm-combine cannot be ported to 0.19 (not strictly true, because it can be ported but only by the core team, but my point still stands because it won’t be). Language churn causes ecosystem churn which, in turn, causes pain for application developers so I don’t think it’s a surprise that folks get angry and leave the community when this happens given that they may not have had any prior warning before they invested their time and effort.

                                                      Finally, calling Elm “unstable” is simply baseless and just as unhelpful as the misleading marketing you allege. I get that you’re upset by how things turned out, but can’t we all have a discussion without exaggerated rhetoric?

                                                      I don’t think it’s an exaggeration to call a language with breaking changes between releases unstable. To be completely honest, I can’t think of a better word to use in this case. Fluctuating? In flux? Under development? Subject to change? All of those fit and are basically synonymous to “unstable”. None of them are highlighted anywhere the language markets itself, nor by its proponents. I’m not making a judgement on the quality of the language when I say this. I’m making a judgement on how likely it is to be a good choice in a production environment, which brings me to…

                                                      Exactly my point: there is no such definition. All those technologies I mentioned were widely used at the time. I put them into production too, and it was a good choice despite the limitations.

                                                      They were not good choices, because, by your own admission, you were unable to meet your requirements by using them. Hence, they were not production-ready. Had you been able to meet your requirements and then been forced to make changes to keep up with them, then that would also mean they were not production-ready. From this we have a pretty good definition: production-readiness is inversely proportional to the likelihood that you will “have a bad time” after putting the thing into production. The more that likelihood approaches 0, the more production-ready a thing is. Being forced to spend time to keep up with changes to the language and its ecosystem is “having a bad time” in my book.

                                                      I understand that our line of work essentially entails us constantly fighting entropy and that, as things progress, it becomes harder and harder for them maintain backwards-compatibility but that doesn’t mean that nothing means anything anymore or that we can’t reason about the likelihood that something is going to bite us in the butt later on. From a business perspective, the more likely something is to change after you use it, the larger risk it poses. The more risks you take on, the more likely you are to fail.

                                                      1. 1

                                                        I think your definition is totally unworkable. You’re claiming that technologies used in thousands upon thousands of projects were not production ready. Good luck with finding anything production ready then!

                                                        1. 7

                                                          I’ve been working with Clojure for almost a decade now, and I’ve never had to rewrite a line of my code in production when upgrading to newer versions because Cognitect takes backwards compatibility seriously. I worked with Java for about a decade before that, and it’s exact same story. There are plenty of languages that provide a stable foundation that’s not going to keep changing from under you.

                                                          1. 4

                                                            I am stating that being able to put something in production is different from said thing being production ready. You claim that there is no such thing as “production ready” because you can deploy anything which is a reduction to absurdity of the situation. Putting something into production and being successful with it does not necessarily make it production ready. It’s how repeatable that success is that does.

                                                            It doesn’t look like we’re going to get anywhere past this point so I’m going to leave it at that. Thank you for engaging and discussing this with me!

                                                            1. 1

                                                              Thank you as well. As I said in another comment, this is the first time I tried having an extended discussion in the comments in here, and it hasn’t been very useful. Somehow we all end up talking past each other. It’s unfortunate. In a weird way, maybe it’s because we can’t interrupt each other mid-sentence and go “Hang on, but what about?…”. I don’t know.

                                                            2. 4

                                                              This doesn’t respond to bogdan’s definition in good faith.

                                                              production-readiness is inversely proportional to the likelihood that you will “have a bad time” after putting the thing into production. The more that likelihood approaches 0, the more production-ready a thing is.

                                                              In response to your criticisms, bogdan proposed a scale of production-readiness. This means that there is no such distinction between “production-ready” and not “production-ready”. Elm is lower on this scale than most advocates imply, and the article in question provides supporting evidence for elm being fairly low on this scale.

                                                              1. 1

                                                                What kind of discussion do you expect to have when the first thing you say to me is that I’m responding in bad faith? Way to go, my friend.

                                                                1. 4

                                                                  Frankly, I don’t really want to have a discussion with you. I’m calling you out because you were responding in bad faith. You didn’t address any of his actual points, and you dismissed his argument condescendingly. The one point you did address is one that wasn’t made, and wasn’t even consistent with bogdan’s stance.

                                                                  1. 1

                                                                    In my experience, the crusader for truth and justice is one of the worst types of participants in a forum.

                                                                    We may not have agreed, but bogdan departed from the discussion without histrionics, and we thanked each other.

                                                                    But you still feel you have to defend his honour? Or are you trying to prove that I defiled the Truth? A little disproportionate, don’t you think?

                                                                    (Also: don’t assign tone to three-sentence comments.)

                                                      2. 5

                                                        I disagree that the question is meaningless just because it has a subjective aspect to it. A technology stack is a long term investment, and it’s important to have an idea how volatile it’s going to be. For example, changes like the removal the of the ability to do interop with Js even in your own projects clearly came as a surprise to a lot of users. To me a language being production ready means that it’s at the point where things have mostly settled down, and there won’t be frequent breaking changes going forward.

                                                        1. 1

                                                          By this definition, Python wasn’t production ready long after the release of Python 3. What is “frequent” for breaking changes? For some people it’s 3 months, for others it’s 10 years. It’s not a practical criterion.

                                                          Even more interestingly, Elm has been a lot less volatile than most projects, so it’s production ready by your definition. Most people complain that it’s changing too slowly!

                                                          (Also, many people have a different perspective about the interop issue; it wasn’t a surprise. I don’t want to rehash all that though.)

                                                          1. 5

                                                            Python wasn’t production ready long after the release of Python 3.

                                                            Python 3 was indeed not production-ready by many people’s standards (including mine and the core team’s based on the changes made around 3.2 and 3.3) after its release up until about version 3.4.

                                                            Even more interestingly, Elm has been a lot less volatile than most projects, so it’s production ready by your definition. Most people complain that it’s changing too slowly!

                                                            “it’s improving too slowly” is not the same as “it’s changing too slowly”.

                                                            1. 1

                                                              Sorry, this doesn’t make any sense.

                                                              By @Yogthos’s definition, neither Python 2 nor Python 3 were “production ready”. But if we’re going to write off a hugely popular language like that, we might as well write off the whole tech industry (granted, on many days that’s exactly how I feel).

                                                              Re Elm: again, by @Yogthos’s definition it’s perfectly production ready because it doesn’t make “frequent breaking changes”.

                                                              1. 5

                                                                By @Yogthos’s definition, neither Python 2 nor Python 3 were “production ready”.

                                                                Python 2 and 3 became different languages at the split as evidenced by the fact that they were developed in parallel. Python 2 was production ready. Python 3 was not. The fact that we’re using numbers to qualify which language we’re talking about proves my point.

                                                                It took five years for Django to get ported to Python 3. (1 2)

                                                                Re Elm: again, by @Yogthos’s definition it’s perfectly production ready because it doesn’t make “frequent breaking changes”.

                                                                You’re hanging on the wording here and “frequent” is not as important to Yogthos’ argument as “breaking changes” is.

                                                                1. 1

                                                                  I don’t think we’re going to get anywhere with this discussion by shifting goalposts.

                                                            2. 2

                                                              I think most people agree that Python 3 was quite problematic. Your whole argument seems to be that just because other languages have problems, you should just accept random breaking changes as a fact of life. I strongly disagree with that.

                                                              The changes around ecosystem access are a HUGE breaking change. Basically any company that invested in Elm and was doing Js interop is now in a really bad position. They either have to stay on 0.18, re-implement everything they’re using in Elm, or move to a different stack.

                                                              Again, as I noted there is subjectivity involved here. My standards for what constitutes something being production ready are different than yours apparently. That’s fine, but the information the article provides is precisely what I’d want to know about when making a decision of whether I’d want to invest into a particular piece of technology or not.

                                                              1. 1

                                                                I don’t think you are really aware of the changes to Elm because you’re seriously overstating how bad they were (“re- implement everything” was never the case).

                                                                I agree that there is useful information in the article – in fact, I try to read critical articles first and foremost when choosing technologies so it’s useful to have them. I never said that we should accept “random breaking changes” either (and it isn’t fair to apply that to Elm).

                                                                I still don’t see that you have a working definition of “production ready” – your definition seems to consist of a set with a single occupant (Clojure).

                                                                As an aside, this is the first time I’ve had an extended discussion in the comments here on Lobsters, and it hasn’t been very useful. These things somehow always end up looking like everyone’s defending their entrenched position. I don’t even have an entrenched position – and I suspect you may not either. Yet here we are.

                                                                1. 3

                                                                  Perhaps I misunderstand the situation here. If a company has an Elm project in production that uses Js interop, what is the upgrade path to 0.19. Would you not have to rewrite any libraries from the NPM ecosystem in Elm?

                                                                  I worked with Java for around a decade before Clojure, and it’s always been rock solid. The biggest change that’s happened was the introduction of modules in Java 9. I think that’s a pretty good track record. Erlang is another great example of a stack that’s rock solid, and I can name plenty of others. Frankly, it really surprises me how cavalier some developer communities regarding breaking changes and regressions.

                                                                  Forum discussions are always tricky because we tend to use the same words, but we assign different meanings to them in our heads. A lot of the discussion tends to be around figuring out what each person understands when they say something.

                                                                  In this case it sounds like we have different expectations for what to expect from production ready technology. I’m used to working with technologies where regressions are rare, and this necessarily colors my expectations. My views on technology adoption are likely more conservative than majority of developers.

                                                                  1. 2

                                                                    Prior to the 0.19 release, there was a way to directly call JS functions from Elm by relying on a purely internal mechanism. Naturally, some people started doing this, despite repeated warnings that they really shouldn’t. It wasn’t widespread, to my knowledge.

                                                                    All the way in 2017, a full 17 months before 0.19 release, it was announced that this mechanism would be removed. It was announced again 5 months before the release.

                                                                    Of course, a few people got upset and, instead of finding a migration path, complained everywhere they could. I think one guy wrote a whole UI framework based on the hack, so predictably he stomped out of the community.

                                                                    There is an actual JS interop mechanism in Elm called ports. Anybody who used this in 0.18 (as they should have) could continue using it unchanged in 0.19. You can use ports to integrate the vast majority of JS libraries with Elm. There is no need to rewrite all JavaScript in Elm. However, ports are asynchronous and require marshalling data, which is why some people chose to use the internal shortcut (aka hack) instead.

                                                                    So, if a company was using ports to interop with JS, there would be no change with 0.19. If it was using the hack, it would have to rewrite that portion of the code to use ports, or custom elements or whatever – but the rework would be limited to bindings, not whole JS libraries.

                                                                    There were a few other breaking changes, like removing custom operators. However, Elm has a tool called elm-upgrade which helps to identify these and automatically update code where possible.

                                                                    There were also fairly significant changes to the standard library, but I don’t think they were any more onerous than some of the Rails releases, for example.

                                                                    Here are the full details, including links to previous warnings not to use this mechanism, if you’re interested: https://discourse.elm-lang.org/t/native-code-in-0-19/826

                                                                    I hope this clarifies things for you.

                                                                    Now, regarding your “rock solid” examples by which I think you mean no breaking changes. If it’s achievable, that’s good – I’m all for it. However, as a counterexample, I’ll bring up C++ which tied itself into knots by never breaking backward compatibility. It’s a mess.

                                                                    I place less value on backward compatibility than you do. I generally think that backward compatibility ultimately brings software projects down. Therefore, de-prioritising it is a safer bet for ensuring the longevity of the technology.

                                                                    Is it possible that there are technologies which start out on such a solid foundation that they don’t get bogged down? Perhaps – you bring up Clojure and Erlang. I think Elm’s core team is also trying to find that kind of foundation.

                                                                    But whether Elm is still building up towards maturity or its core team simply has a different philosophy regarding backward compatibility, I think it’s at least very clear that that’s how it is if you spend any time researching it. So my view is that anybody who complains about it now has failed to do their research before putting it into production.

                                                                    1. 2

                                                                      I feel like you’re glossing over the changes from native modules to using ports. For example, native modules allowed exposing external functions as Tasks allowing them to be composed. Creating Tasks also allows for making synchronous calls that return a Task Never a which is obviously useful.

                                                                      On the other hand, ports can’t be composed like Tasks, and as you note can’t be used to call synchronous code which is quite the limitation in my opinion. If you’re working with a math library then having to convert the API to async pub/sub calls is just a mess even if it is technically possible to do.

                                                                      To sum up, people weren’t just using native modules because they were just completely irresponsible and looking to shoot themselves in a foot as you seem to be implying. Being able to easily leverage existing ecosystem obviously saves development time, so it’s not exactly surprising that people started using native modules. Once you have a big project in production it’s not trivial to go and rewrite all your interop in 5 months because you have actual business requirements to work on. I’ve certainly never been in a situation where I could just stop all development and go refactor my code as long as I wanted.

                                                                      This is precisely the kind of thing I mean when I talk about languages being production ready. How much time can I expect to be spending chasing changes in the language as opposed to solving business problems. The more breaking changes there are the bigger the cost to the business is.

                                                                      I’m also really struggling to follow your argument regarding things like Rails or C++ to be honest. I don’t see these as justifying unreliable tools, but rather as examples of languages with high maintenance overhead. These are technologies that I would not personally work with.

                                                                      I strongly disagree with the notion that backwards compatibility is something that is not desirable in tooling that’s meant to be used in production, and I’ve certainly never seen it bring any software projects down. I have however seen plenty of projects being brought down by brittle tooling and regressions.

                                                                      I view such tools as being high risk because you end up spending time chasing changes in the tooling as opposed to solving business problems. I think that there needs to be a very strong justification for using these kinds of tools over ones that are stable.

                                                                      1. 3

                                                                        I think we’re talking past each other again, so I’m going to wrap this up. Thank you for the discussion.

                                                          2. 4

                                                            The question isn’t even close to meaningless… Classifying something as “production ready” means that it is either stable enough to rely on, or is easily swapped out in the event of breakage or deprecation. The article does a good enough job of covering aspects of elm that preclude it from satisfying those conditions, and it rightly warns people who may have been swept up by the hype around elm.

                                                            Elm has poor Interop, and is (intentionally) a distinct ecosystem from JS. This means that if Elm removes features you use, you’re screwed. So, for a technology like Elm (which is a replacement of JS rather than an enhancement) to be “production ready” it has to have a very high degree of stability, or at least long term support for deprecated features. Elm clearly doesn’t have this, which is fine, but early adopters should be warned of the risks and drawbacks in great detail.

                                                            1. 0

                                                              What is “production ready”, exactly?

                                                              Let’s keep it really simple, to me ‘production-ready’ is when the project version gets bumped to 1.0+. This is a pretty established norm in the software industry and usually a pretty good rule of thumb to judge by. In fact Elm packages enforce semantic versioning, so if you extrapolate that to Elm itself you inevitably come to the conclusion that hasn’t reached production-release readiness yet.

                                                            2. 3

                                                              The term “production ready” is itself not at all clear. Some Elm projects are doing just fine in production and have been for years now. Some others flounder or fail. Like many things, it’s a good fit for some devs and some projects, and not for some others – sometimes for reasons that have little to do with the language or its ecosystem per se. In my (quite enjoyable!) experience with Elm, both official and unofficial marketing/docs/advocates have been pretty clear on that; but developers who can’t or won’t perceive nuance and make their own assessments for their own needs are likely to be frustrated, and not just with Elm.

                                                              I agree that there’s valuable information in this article. I just wish it was a bit less FUDdy and more had more technical detail.

                                                            3. 9

                                                              I think there’s an angle to Elm’s marketing that justifies these kinds of responses: Those “author’s expectations” are very much encouraged by the way the Elm team presents their language.

                                                              Which criticisms do you find unfair, which are the good points?

                                                              1. 5

                                                                think there’s an angle to Elm’s marketing that justifies these kinds of responses

                                                                I’m sympathetic to both Elm and the author here. I understand Elm’s marketing stance because they ask devs to give up freely mixing pure/impure code everywhere in their codebase on top of a new language and ecosystem. (In general, OSS’s perceived need for marketing is pretty out of hand at this point and a bit antithetical to what attracts me to it in the first place). OTOH it shouldn’t be possible to cause a runtime error in the way the author described, so that’s a problem. I’d have wanted to see more technical details on how that occurred, because it sounded like something that type safety should have protected him from.

                                                                Fair criticisms:

                                                                • Centralized ecosystem (though this is by design right now as I understand)
                                                                • Centralized package repo
                                                                • Official docs out of date and incomplete

                                                                Unfair criticisms:

                                                                • PRs being open after 2 years: one example alone is not compelling
                                                                • Tutorials being out of date: unfortunate, but the “Cambrian explosion” meme from JS-land was an implicit acknowledgement that bitrot was okay as long as it was fueled by megacorps shiny new OSS libs, so this point is incongruous to me (even if he agrees with me on this)
                                                                • “Less-popular thing isn’t popular, therefore it’s not as good”: I understand this but also get triggered by this; if you want safe, established platforms that have a big ecosystem then a pre-1.0 language is probably not the place to be investing time

                                                                The conclusion gets a little too emotional for my taste.

                                                                1. 2

                                                                  Thanks for the detailed reply; the criticism of the article seems valid.

                                                                  (As a minor point, the “PRs being open” criticism didn’t strike me as unsubstantiated because I’ve had enough similar experiences myself, but I can see how the article doesn’t argue that well. Certainly I’ve felt that it would be more honest/helpful for elm to not accept github issues/prs, or put a heavy disclaimer there that they’re unlikely to react promptly, and usually prefer to fix things their own way eventually.)

                                                              2. 6

                                                                A lot of the things listed in the articles are things that have been explicitly done to make things harder for contributions to happen. The development of Elm has explicitly made choices to make things harder, and not in a merely incidental way.

                                                                This isn’t “the language is young” (well except for the debug point), a lot of this is “the language’s values go against things useful for people deploying to production”)

                                                                1. 2

                                                                  I don’t know, other than the point about the inability to write native modules and the longstanding open PR’s, all of the rest of the issues very much seem symptomatic of a young language.

                                                                  The native module point sounds very concerning, but I don’t think I understand enough about elm or the ecosystem to know how concerning it is.

                                                                  1. 4

                                                                    I’ve been vaguely following along with Elm, and the thng that makes me err on agreeing with this article is that the native module thing used to not be the case! It was removed! There was a semi-elegant way to handle interactions with existing code and it was removed.

                                                                    There are “reasons”, but as someone who has a couple ugly hacks to keep a hybrid frontend + backend stack running nicely, I believe having those kinds of tricks are essential for bringing it into existing code bases. So seeing it get removed is a bit red flag for me.

                                                                    Elm still has a lot of cool stuff, of course

                                                                    1. 2

                                                                      I never relied on native modules, so I didn’t really miss them. But we now have ports, which I think is a much more principled (and interesting) solution. I felt that they worked pretty well for my own JS interop needs.

                                                                      Stepping back a bit, if you require the ability do ugly hacks, Elm is probably not the right tool for the job. There are plenty of other options out there! I don’t expect Elm to be the best choice for every web front-end, but I do appreciate its thoughtful and coherent design. I’m happy to trade backward compatibility for that.

                                                                    2. 2

                                                                      If you spend any amount of time in the Elm community you will find that contributions to the core projects are implicitly and explicitly discouraged in lots of different ways. Even criticisms of the core language and paradigms or core team decisions are heavily moderated on the official forums and subreddit.

                                                                      Also how are we using the term “young”? In terms of calendar years and attention Elm is roughly on par with a language like Elixir. It’s probably younger in terms of developer time invested, but again this is a direct result of turning away eager contributors.

                                                                      I think it’s fine for Elm to be a small project not intended for general production usage, but Evan and the core team have continually failed to communicate that intent.

                                                                1. 14

                                                                  I guess by now it’s useless to complain about how confusing it is that OCaml has two (three?) “standard” package managers; the ecosystem around the language is kind of infamous for having at least two of everything. I trust the community will eventually settle on the one that works the best. At least it looks like esy is compatible with opam libraries (though the reverse is not true), so it might have a good chance against opam.

                                                                  Also this is kind of unrelated, but I’m really salty about ReasonML recommending JS’s camelCase over OCaml’s snake_case. This is one of the few rifts in the ecosystem that can’t really be fixed with time, and now every library that wants to play well with both OCaml and Reason/BS ecosystems will have to export an interface in snake_case and one in camelCase.

                                                                  1. 12

                                                                    I second the choice to use JS’s camelCase for ReasonML as a salty/trigger point. It seems like a minor syntactic thing to make it more familiar for JS developers making the switch, but as someone who primarily writes Haskell for day job - camelCase is just less readable, IMO. Something I constantly am irritated that I even have to think about is casing acronyms consistently - which is avoided by snake_case or spinal-case - ie. runAWSCommand or runAwsCommand, setHTMLElement vs setHtmlElement - run_aws_command, set_html_element, etc.

                                                                    1. 3

                                                                      The strangest thing for me is the “hey, there’s two mostly compatible syntaxes for this language we call ReasonML” but it’s mostly the same thing as Bucklescript from which we use the compiler anyway, except this, and this, and … oh and by the way, it’s all ocaml inside. What ?!

                                                                      1. 1

                                                                        “Oh and also the docs for all these things (which you need) are all in completely different places and formats”

                                                                      2. 2

                                                                        I think the ReasonML team wanted to match the conventions of JavaScript, where camel case is the norm.

                                                                        I can see the annoyance though… and I have to wonder, is ReasonML syntax much better than OCaml’s? Was it really worth the break?

                                                                        1. 6

                                                                          It’s not “better.” Yes, there are some cases where they’ve patched up some syntactic oddities in OCaml, but it’s mostly just change for the sake of being near JS.

                                                                          Is it worth it? Depends. ReasonML and its team believe that OCaml failed to catch on because of syntax. If you agree, then yes, it’s worth it. And based on the meteoric rise I’ve seen on ReasonML, they may be right. That said, I believe, with good company, think OCaml didn’t catch on because it had two of everything, had really wonky package managers (and again, two of them), and still lacks a good multithreading story. In that case, no, the syntax just is change for no reason, and the only reason ReasonML is successful is because Facebook is involved.

                                                                          1. 2

                                                                            I’m all for functional alternatives displacing JavaScript but my main frustration with ReasonML is that any niceities you gain from using it are outweighed by the fact that it’s just one more layer on top of an already complex, crufty, and idiosyncratic dev environment. I think that’s what’s holding OCaml back as much as anything else.

                                                                          2. 4

                                                                            Some people seem to think that OCaml’s syntax is really ugly (I quite like it) and unreadable. I’m guessing they’re the same who complain about lisps having too many parenthesis.

                                                                            ReasonML does fix a few pain points with OCaml’s syntax, mostly related semicolons (here, here, here), and supports JSX, but it also introduces some confusion with function call, variant constructor and tuple syntax (here, here, here) so it’s not really a net win IMO.

                                                                            I think ReasonML was more of a rebranding effort than a solution to actual problems, and honestly it’s not even that bad if you disregard the casing. Dune picks up ReasonML files completely transparently so you can have a project with some files in ReasonML syntax and the rest in OCaml syntax. The only net negative part is the casing.

                                                                          3. 1

                                                                            Esy and bsb are build orchestration tools, not package managers.

                                                                            Esy is not OCaml-specific, it can e.g. include C++ projects as build dependencies. This is how Revery ( https://github.com/revery-ui/revery ) is being developed, for example. Esy also solves the problem of having to set up switches and pins for every project, with commensurate redundant rebuilds of everything. Instead, it maintains a warm build cache across all your projects.

                                                                            Bsb specifically supports BuckleScript and lets it use npm packages. It effectively opens up the npm ecosystem to BuckleScript developers, something other OCaml tools don’t do (at least not yet).

                                                                            Having ‘two of everything’ is usually a sign of a growing community, so it’s something I’m personally happy to see.

                                                                            Re: casing, sure it’s a little annoying but if C/C++ developers can survive mixed-case codebases, hey, so can we.

                                                                          1. -5

                                                                            “Semantic” and “HTML” don’t belong in the same sentence. HTML is a presentational markup — it describes things like headings and emphases and tables — and it was never really designed to carry meaning.

                                                                            In a way it is disappointing that XSLT never took off, because then we could have served meaningful data through XML (which, for all its evils, is very easy to define, standardise and validate against schema definitions) and transform it into something pretty for humans using XSLT and then we wouldn’t have to worry so much about whether a11y devices or search engines can make sense of it.

                                                                            1. 7

                                                                              Headings and emphases and tables describe semantic relationships. I’m not sure there are any presentational tags left in HTML5. Even <b> and <i> were redefined in terms of semantic usage.

                                                                              1. 5

                                                                                In a way it is disappointing that XSLT never took off,

                                                                                I actually worked on old IE app that was all in on xsl and xslt server and client side. Xslt is an abomination. It works great for simple stuff. Start adding namespaces and versions to the schema and it falls apart completely. Has to do with having to match input namespaces in your xslt for whatever xml input you’re given iirc. I recall we had to add a step to all our inputs to strip namespaces off tags.

                                                                                1. 3

                                                                                  I have also worked with XSLT. I cannot blame anyone, as I chose that because It seemed the right tool for the task. It wasn’t. :)

                                                                                  I dodn’t even get to use namespaces, I already hit some hard walls and had to do terrible hacks to overcome its limitations.

                                                                                  I remember NetBeans had a somewhat adequate editor and maybe debugger for XSLT…

                                                                                  I’m happy XSLT didn’t take off.

                                                                                  1. 3

                                                                                    A colleague of mine at Lonely Planet wrote a Ruby DSL (called RSLT, if memory serves) specifically to avoid having to deal with XSLT :)

                                                                                    1. 3

                                                                                      If I’d understood XSLT better, I’d have made the DSL generate XSLT - the ruby-in-ruby DSL was a performance bottleneck we didn’t need.

                                                                                      The main problem I was trying to solve was ‘how do I encode several thousand similar rules, many of which are not yet known’. That’s a problem where the answer is basically always “create a new language”.

                                                                              1. 3

                                                                                And since when having multiple repos implies using git submodules to handle them? In my experience, proper packaging and semantic versioning is what makes it easy to work with multiple repositories.

                                                                                Of course that comes with additional bureaucracy, but it also fosters better separation of software components.

                                                                                Sure, the mono-repository approach allows for a fast “single source of truth” lookup, but it comes with a high price, as soon as people will realize that they can also cut corners. Eventually it gets a pile of spaghetti.

                                                                                (For the record, just in case you could not tell, I’ve got a strong bias towards the multi-repo, due to everyday mono-repository frustration.)

                                                                                1. 3

                                                                                  The flip side is with multi-repo you will amplify the Conway’s law mechanism where people tend to introduce new functionality in the lowest friction way possible. If it would be easier to do it all in one project that’s what will happen, even if it would be more appropriate to split the additions across multiple projects.

                                                                                  Introducing friction into your process won’t magically improve the skills and judgement of your team.

                                                                                  1. 1

                                                                                    I once proposed an alternative to git-subtree that splits commits between projects at commit-time: http://www.mos6581.org/git_subtree_alternative. This should help handling of tightly-coupled repositoties, but requires client changes.

                                                                                    1. 1

                                                                                      Why not just use a monorepo and make no client changes?

                                                                                      1. 1

                                                                                        Because you want to share libraries with other projects.

                                                                                    2. 1

                                                                                      Yes, there’s wisdom in what you say.

                                                                                  1. 32

                                                                                    Each side of this debate classifies the other as zealous extremists (as only developers can!), but both of them miss the crux of the matter: Git and its accompanying ecosystem are not yet fit for the task of developing modern cloud-native applications.

                                                                                    So, let me get this straight: Because your source control system doesn’t have innate knowledge of the linkages between your software components, that means it’s not up to the task of developing modern “cloud native” (God that term makes me want to cringe) applications?

                                                                                    I think not. Git is an ugly duckling, its UX is horrible but the arguments the author makes are awfully weak.

                                                                                    IMO expecting your VCS to manage dependencies is a recipe for disaster. Use a language that understands some kind of module and manage your dependencies there using the infrastructure that language provides.

                                                                                    1. 11

                                                                                      well said. I dislike Git too but for different reason - the source code is somewhat of a mess

                                                                                      a hodgepodge of C, Python, Perl and Shell scripts

                                                                                      Git is the perfect project for a rewrite in a modern language like Go, Rust, Nim or Julia. A single Git binary similar to Fossil would make adoption and deployment much better.

                                                                                      1. 18

                                                                                        I think at this point Git demonstrates that skipping on the single binary rhetoric doesn’t actually hamper adoption at all.

                                                                                        1. 8

                                                                                          Bitkeeper was a single binary - and it had a coherent command set. I miss it.

                                                                                          1. 6

                                                                                            It still exists and is licensed under Apache 2.0: https://www.bitkeeper.org/

                                                                                            The only issue you have is no public host other than bkbits supporting bk.

                                                                                            1. 1

                                                                                              Also no support in most IDEs.

                                                                                              I know many will point to the command line but having integrated blame/praise, diff, history etc is awesome.

                                                                                              1. 2

                                                                                                Honestly, the bigger beef I have with it is how little it comes with an installer and is difficult to package.

                                                                                            2. 5

                                                                                              I think fossil has that…

                                                                                            3. 0

                                                                                              I thought you are not supposed to use python because that would mean more dependencies… :P

                                                                                            4. 3

                                                                                              Arguments are indeed weak, as what is “cloud native”? However, I think he’s onto something – maybe the problem is not just Git, but everything around it as well? I mean, one could create a big giant monorepo in Git, but the rest of the tooling (CI especially) will still do the full checkout and won’t understand that there are different components. Monorepos make a lot of sense, however, it seems to me that we’re trying to use popular tools to tackle the problem they are not meant to solve (that is, Git being a full replacement for SVN/SVK/Perforce and handling monorepos).

                                                                                              1. 3

                                                                                                I don’t personally think monorepos make a lot of sense, and I think multi-repos are the way to go. If each separate piece is its own project and you let the language’s packaging / dependency management system handle the rest, I don’t see the problem.

                                                                                                Examples I can think of where my point applies are Python, Ruby, Perl or Java. Unless maybe you’re using a language with no notion of packages and dependencies - C/C++ perhaps? I don’t see the issue.

                                                                                                1. 8

                                                                                                  The friction in coordinating branches and PRs across multiple repos has been an issue on every team I’ve worked on. Converting to a monorepo has been a massive improvement every time I’ve done it. Either you’ve used hugely different processes or you’ve never tried using a monorepo.

                                                                                                  1. 1

                                                                                                    The friction in coordinating branches and PRs across multiple repos

                                                                                                    That’s a symptom that the project is not split across the correct boundaries. This is not different from the monolith-vs-services issue.

                                                                                                    Amazon is a good example of splitting a complex architecture. Each team runs one or very few services each with their repos. Services have versioned APIs and PRs across teams are not needed.

                                                                                                    1. 1

                                                                                                      If you have a mature enough project such that every repo has a team and every team can stay in its own fiefdom then I imagine you don’t experience these issues as much.

                                                                                                      But even so, the task of establishing and maintaining a coherent split between repos over the lifetime of a project is non-trivial in most cases. The multi-repo paradigm increases the friction of trying new arrangements and therefore any choices will tend to calcify, regardless of how good they are.

                                                                                                      I’m speaking from the perspective of working on small to mid-sized teams, but large engineering organizations (like Amazon, although I don’t know about them specifically) are the ones who seem to gain the most benefit from monorepos. Uber’s recent SubmitQueue paper has a brief discussion of this with references.

                                                                                                    2. 1

                                                                                                      That’s interesting. Every team I’ve ever worked on had its architecture segmented into services such that cross branches and PRs weren’t an issue since each service was kept separate.

                                                                                                    3. 6

                                                                                                      The advantage of a monorepo is that a package can see all the packages depending on it. That means you can test with all users and even fix them in a single atomic commit.

                                                                                                      The alternative in a large organisation is that you have release versions and you have to support/maintain older versions for quite some time because someone is still using them. Users have the integration effort whenever they update. In a monorepo this integration effort can be shifted to developer who changes the interface.

                                                                                                      I don’t see how you could do continuous integration in a larger organization with multiple-repos. Continuous integration makes the company adapt faster (more agile with a lowercase a).

                                                                                                      1. 4

                                                                                                        Even if you use a language that has good (or some) package support, breaking a project into packages is not always easy. Do it too soon, and it will be at the wrong abstraction boundary and get in the way of refactoring, and to correct you’ll have to either loose historic, or deal with importing/exporting, which ain’t fun.

                                                                                                        But if all your packages/components are in a single repo, you’ll still might get the boundaries wrong, but the source control won’t get much in the way of fixing it.

                                                                                                      2. 1

                                                                                                        100% on the surrounding tooling. CI tooling being based around Git means that a lot of it is super inflexible. We’ve ended up splitting repos just to get CI to do what we need it to do, and adding friction in surrounding processes.

                                                                                                        A rethink of the ecosystem would be very interesting

                                                                                                    1. 14

                                                                                                      What you would do is, instead of having that data being diverted to third-party servers that you have no control over, you would either set up your own server or pay for a service by a trusted third party to store that data yourself.

                                                                                                      Peak silicon valley capitalism: dying because the doctors couldn’t access very important info about you because the server with that info was turned off because you didn’t pay for the hosting.

                                                                                                      1. 17

                                                                                                        I think peak Silicon Valley capitalism would be a free medical record host that profits off the data.

                                                                                                        1. 15

                                                                                                          Or one that you pay but which sells the data anyway (23andMe).

                                                                                                        2. 3

                                                                                                          Heh. Do me a favor, and do a quick search of software for your average doctor’s office or hospital, and let me know which one is the best.

                                                                                                          1. 25

                                                                                                            I’m currently on my third stint in health care.

                                                                                                            The stuff in a typical doctor’s office is not great, but I’d still take it over the average blockchain solution-in-search-of-a-problem any day of the week. The fundamental properties of a blockchain are the opposite of what you want for medical data. Blockchains have everything public and immutable by default and design. Medical data is private by law and must support corrections and errata. In fact, properly handling medical data often requires that you implement a time machine and be able to change history, then replay the new timeline forward.

                                                                                                            Here’s an example: suppose there’s some ongoing treatment that requires documentation before claims on it can be paid, and the documentation doesn’t come in until after the first 4 claims. The first 4 claims would have been rejected, and now you have to rewind time, then replay those 4 claims and pay them.

                                                                                                            Or say there’s a plan with a deductible: the first $500 of costs in the year are the patient’s responsibility, then the plan pays all claims after that. But a claim for something that happened early in the year doesn’t come in until later, after you think the deductible has been met. On many plans – including some of the US government-backed ones – you now have to start over, rewind time to the start of the year, and replay all the claims in chronological order, processing things according to what the deductible situation would have been if the claims had arrived in that order, and pull refunds from doctors you weren’t supposed to pay, order refunds to the patient from doctors who should have been paid by you, and reconcile the whole thing until the correct entities have paid the correct bills.

                                                                                                            An append-only structure is fundamentally terrible at this unless you build a whole bunch of specialized stuff on top of it to treat later entries as addending, modifying or replacing earlier ones. And since at that point you’ve gone and built a mutable history structure on top of your immutable blockchain, why didn’t you just build the mutable history software in the first place and skip the blockchain? You’re not using it for any of the unique things it does.

                                                                                                            And that’s just the technical/bureaucratic part of the problem. The social side of the problem is even worse. For example: sometimes it is incredibly important that a patient be able to scrub data out of their medical history, because that data is wrong and will influence or even prejudice doctors who see the patient in the future. Doctors who just ignore obvious symptoms and write down in the notes “it’s all in their head, refer to a psychiatrist” are depressingly common, and every future doctor will see those notes. When it turns out that doctor was wrong and there was a real problem, you do not want to have to fight with the next doctor who says “well, it’s here in your file that this was found to be psychosomatic”. You have to get that fixed, and it’s already hard enough to do without people introducing uncorrectable-by-design medical records (and no, merely putting a big “that doctor was wrong” addendum in the medical blockchain is not a real solution to this).

                                                                                                            Compared to how much worse it could get with blockchain, the crappy hairballs of only-run-on-Windows-XP (or worse) software in a typical doctor’s office are downright pleasant.

                                                                                                            1. 5

                                                                                                              this is the sort of thing I heard from Americans who work in health care when they reviewed the article ahead of time, yeah.

                                                                                                              The big problem they flagged was data silos - lots of patient data trapped in systems that don’t talk to each other, and the ridiculous dificulty and expense of extracting your health record from your doctor (though passing your stuff to another doctor is apparently fine). You can see the blockchain pitch in there - “control your own data!” … not that it can offer a solution in practice.

                                                                                                              1. 8

                                                                                                                though passing your stuff to another doctor is apparently fine

                                                                                                                It absolutely is not, at least technically, unless both doctors happen to use the same EMR, in which case it’s merely painful; or, if you’re extremely lucky, the same instance of the same EMR (for instance, half the health care in eastern Massachusetts uses Mass General’s EMR), in which case the experience is basically reasonable. Otherwise, you end up with some of the most absurd bullshit imaginable, that makes mailing paper charts seem reasonable in comparison; the best I’ve heard is a mailed CD containing proprietary viewing software in order to send imaging.

                                                                                                                Interestingly, while “patients should own their own data” is a nice pitch, it’s actually somewhat problematic in practice. Health care providers may need to share information about a patient that patient would object to or should be kept unaware of (for instance, if a patient has been violent towards providers in the past, that information absolutely must be conveyed to any future providers that see them); and, like all professionals, health care providers use a lot of jargon in order to communicate clearly and precisely, which tends to make the chart incomprehensible to laypeople.

                                                                                                                1. 3

                                                                                                                  In the US, HIPAA provides a right to your medical records, similar (but not identical) to what a European would be familiar with from the GDPR. The gist of it is that you can make a request to any medical provider who’s treated you, and they have 30 days from the time of the request to provide you with a copy of your records. There are some exceptions (the most common exception is therapists’ notes), but not many.

                                                                                                                  I would guess that a lot of people probably don’t know they have this right, and probably a lot of medical providers aren’t forthcoming about making sure patients really understand their rights (they have to provide a notice of their privacy-related policies in writing, but a written notice in legalese is not the same as genuine understanding). A bigger problem is just that most people aren’t really able to look at medical records in their “standard” form and understand what they’re seeing.

                                                                                                                  And like the other commenter points out, interoperability between medical providers is not great. HIPAA allows medical providers to share information for treatment purposes, though, and the rules produce results that sometimes seem odd to modern tech people (for example, in the US the medical industry relies heavily on fax for sharing documents, because it’s often both the technically and legally simplest way to do so).

                                                                                                                2. 3

                                                                                                                  Maybe I’m missing something, but examples you give are related to health insurance, not medical records per se – those are two different concerns that are related, but the latter can exist without the former. Medical records are immutable if they store facts, even wrong diagnoses – after all, how do you figure our that some diagnosis is wrong – by someone else claiming the otherwise and providing supporting evidence. Further, medical records are not a single blob of information, they are more like tiny databases, for which we can have various ACLs for various pieces of information – IBM did quite a lot of work in that direction, IIRC. Nevertheless, blockchain is not the right tool, at least not for this domain.

                                                                                                                  1. 5

                                                                                                                    Claims are medical records just like everything else.

                                                                                                                    1. 1

                                                                                                                      But that depends on the definition what a medical record is, no? In socialist countries with universal healthcare, there is no such thing as claim that should be reimbursed or a plan with deductible. However, what is universal across the board is the state of body and mind, that is, all diagnoses and prescribed medications.

                                                                                                                      1. 6

                                                                                                                        From this comment by @ubernostrum further up the chain:

                                                                                                                        The social side of the problem is even worse. For example: sometimes it is incredibly important that a patient be able to scrub data out of their medical history, because that data is wrong and will influence or even prejudice doctors who see the patient in the future.

                                                                                                                        This applies even without the baroque details of the US health insurance system. And even in countries with universal coverage, you still need to look out for fraud, fraudulent prescription of drugs, etc. The money comes from somewhere and it shouldn’t be wasted.

                                                                                                                        1. 3

                                                                                                                          Here in Finland “universal” claims for things like medical pensions (whatever it’s called, disability retirement) are routinely denied. It’s tough, because people do try to abuse the shit out of it, but sometimes proper claims get denied. The processes for countering these claims are long and costly.

                                                                                                                          We also have systems within the same public health-care district that don’t talk to each other. The private franchises have handled that better, by asking for permission to share data, because it gives a better customer experience.

                                                                                                                          This is fortunately changing, but the data is now within a single point of failure, also duplicated in part for every relevant franchise.

                                                                                                                          Getting your data into the unified system incurs a cost. I don’t know if you can opt out of it, but you probably don’t want to, as the cost is not high, I think insurances cover it (transfer of wealth style) and it’s more convenient to check the records online than papers in a binder somewhere.

                                                                                                                          1. 3

                                                                                                                            That is, for me, the key point. I have had a close relative get the wrong treatment for years because a doctor hastily put in an incorrect diagnosis and everyone after that just assumed it was correct.

                                                                                                                            Why did it take so long to have it edited out of her records? Because one symptom of that diagnosis is denying it. Once that diagnosis is in your records, whatever you say, the next doctor will just put in a note saying, “patient does not think she is suffering from X”.

                                                                                                                            So as far as I’m concerned, mutability of medical records is absolutely crucial. (Of course with a detailed log of operations visible only on court order or something.)

                                                                                                                    2. 1

                                                                                                                      Blockchains are indeed append-only logs, albeit ones constructed in an interesting way.

                                                                                                                      And yet within a blockchain-based system state changes are made over time (Bitcoin balances change, CryptoKittes get new owners) by parsing the data contained within those logs.

                                                                                                                      In a medical system this means that records are indeed mutable/scrubbable. Want to fix a record? Post an update to the system’s blockchain. The record is the result of parsing the logs, so this updates the record. If you want a scrubbable log that’s also doable, although it does affect trust in the system in ways that take more thinking through than just “but GDPR!!!”.

                                                                                                                      All that said, like the OP I’m very wary of “control your data” pitches of all kinds. Don’t get me started on data-ownership UBI. ;-)

                                                                                                                1. 1

                                                                                                                  Too much technical debt will prevent features and bug fixes from shipping in a reasonable amount of time.

                                                                                                                  The Tetris analogy does not work here. Having a buried gap forces you to play faster instead and thus increases risk for more buried gaps.

                                                                                                                  Also, why can’t we chop the pieces in reality? In Tetris we can imagine the silver bullet to only use 1-block pieces.

                                                                                                                  1. 3

                                                                                                                    The analogy does work insofar as technical debt (depending on its location) requires you to make more hacks to work around it which can spread throughout the system and eventually become unsustainable. You can think of the time pressure as representing the increase in effort required to ship a feature.

                                                                                                                    The equivalent of a one block piece would be a software component with no interrelationships or dependencies. If you can build a useful product all out of components like that then good on you.

                                                                                                                  1. 5

                                                                                                                    I’m currently in the middle of rewriting a bunch of Elixir FP-ish code from a “functional” approach to look more OOPy, because the maintenance burden is just beyond stupid.

                                                                                                                    Everybody talks about how magical functional programming in, but nobody seems to be really speaking up yet about functional programming as she is practiced:

                                                                                                                    • “functional” programming means, programs with loads and loads of functions! yay!
                                                                                                                    • “functional” programming with pattern matching, where if enough of something matches, hey, we can run it through the function! no need for types! (looking at you, Elixir maps)
                                                                                                                    • “functional” programming where clever tricks with apply and map and reduce and filter and lambdas/closures substitute for clean, documented methods
                                                                                                                    • “functional” programming where instead of fixing an interface and automatically getting to see where to clean up your objects, you chase through the entire pipeline of functions where the objects get shoved and look for where you’ll have to expand/contract things
                                                                                                                    • “functional” programming where people just grab functions off of unrelated domain modules and use them because they need a one-off display function
                                                                                                                    • “functional” programming where other people decide to duplicate the same function in multiple places because they never had to think about the domain

                                                                                                                    For all of its very many excesses, it’s so much easier to partition and expand on an OOP codebase than this “functional” nonsense. To wit:

                                                                                                                    “Young developer, go forth and create a new widget object, conforming to the widget interface. You can extend BaseWidget and just update the display method and price estimating function. Serialization is handled by that class already.”

                                                                                                                    Compare with:

                                                                                                                    “Young developer, we’re adding a new widget type. You’ll need to learn about the overloaded functions in the cost module, in the display module, and update all the tests accordingly. You’ll also need to either use the serialization library, or you’ll need to manually add those overrides to the code. Oh, also, make sure you don’t set the market_price in your arguments, or something else will match on that and you’ll need to refactor that too, or maybe it’ll just fail silently.”

                                                                                                                    OOP has so many problems, but I find it so much easier to get the size of a system and the page in and page out the parts I need into my working memory than to trace spaghetti for hours. I’m sick of people touting FP as a silver bullet when most of the shooters are cross-eyed.

                                                                                                                    1. 8

                                                                                                                      I’ve long wondered when we’d figure out how to write FP so poorly we undo all of it’s supposed benefits. The same thing happened to OOP.

                                                                                                                      Unfortunately, there are very few computing paradigms out there for all the Medium thinkpieces that need to be written about how X paradigm is the worst.

                                                                                                                      1. 2

                                                                                                                        Maybe programming isn’t the answer. Maybe we should just roll the clock back and have desks upon desks of people pushing paper around. It’d give more jobs for people that are not qualified to program, and reduce homelessness.

                                                                                                                        Of course, that’d make it harder to concentrate wealth in the hands of founders and execs and investors, but since I’m not seeing much of that, fuck’em.

                                                                                                                      2. 7

                                                                                                                        Almost all of those bullet points are arguments in favor of static typing. Not arguments in favor of object oriented programming.

                                                                                                                        I’m speaking as someone who is terrible enough at programming to have written spaghetti code in both styles. It’s spaghetti code. Of course it sucks, and you don’t realize how much it sucks until several months later when you have to re-remember your terrible “design” choices, and, worse, have to extend it in a way that you did not plan for.

                                                                                                                        1. 3

                                                                                                                          Static typing helps a great deal, but being able to define classes of objects and duplicate and tweak them is enormously useful–vulgar OOP isn’t totally wrong. Being able to communicate via messages, dispatch messages, inspect messages, store and replay messages–theoretical (Kay-esque) OOP also has a lot to offer.

                                                                                                                          I agree on the spaghetti code, but again will point how exasperating it is to see people celebrating FP as a cureall when most of the common devs seemingly can’t be trusted to scale it beyond a few tutorials. At least with OOP stuff you get a coloring book and if the devs are smart enough not to eat the crayons they can produce something that looks like the source material.

                                                                                                                          1. 3

                                                                                                                            In other words, functional isn’t a programming paradigm. It isn’t a template for designing your system; it’s just a synonym for “computation without mutation and without backtracking*.” Which happens to contradict vulgar OOP, which has mutation, but that doesn’t change the fact that the proper counterpart to OOP would probably be something like Reactive Programming or Data-Oriented Design.

                                                                                                                            * With backtracking would be logic programming.

                                                                                                                        2. 6

                                                                                                                          What has convinced you that the team that made your list of mistakes when attempting to follow the FP paradigm will do any better when attempting to follow the OOP paradigm?

                                                                                                                          1. 4

                                                                                                                            Most programming problems are people problems. You’re only going to get truly good code if you commit to paying for it, up to and including formal code reviews wherein people can say “no, you can’t do that.”

                                                                                                                            Also: unityped functional programming is a special type of Hell. Learned that from my one (small) Clojure project and will never do it again.

                                                                                                                            1. 2

                                                                                                                              This perfectly sums up the nagging feeling I’ve been having about FP, but haven’t been able to express. I have only ever heard people laude FP as a better paradigm, but I always felt that it would be so difficult to maintain the projects I see at scale in the real world and I see how difficult OOP is… I do not envy the hacks that are in place for large FP codebases. I can grok a OOP codebase (hell I can grok dissassembly), but the moment someone has given me FP code I spend more time trying to keep the entire thing in my head. To this day I don’t think I’ve been able to understand a single decently sized FP codebase.

                                                                                                                              1. 1

                                                                                                                                There’s benefits and costs to both paradigms but the idea that either is “unusable” or “doesn’t scale” is genuinely laughable. The fact that you don’t use it, so you can’t figure out how to use it, isn’t actually any kind of argument for anything. Typed functional programming has been around since 1973, C was invented in 1972. People both less and more talented than either of us have used both OOP and FP, strongly and dynamically typed for decades at both small and gargantuan scales.

                                                                                                                                1. 4

                                                                                                                                  I said that entirely from my personal perspective and meant nothing of offense, your reaction and tone is exactly the reason that I tend to avoid even discussing my hesitation about programming paradigms. This could (and most likely is) be an entire failing on my end, but I have actively tried to learn and read large projects from both and friendlysocks experience mirrored mine. I wasn’t trying to slander, just merely mention that I struggle personally massively with the paradigm more than most everything in computer science. I can’t use it. I can’t understand how it scales to large teams.

                                                                                                                                  1. 3

                                                                                                                                    In my experience it’s harder to teach an OOP programmer FP than a beginner. Part of this I believe has to do with how learning new paradigms is inherently humbling. The things that made you feel smart before now make you feel dumb. Dynamic typing for example makes me think, “Well I don’t know how anyone makes anything useful with this.”. In reality though the reason I feel this way is almost certainly because I’m missing pieces of knowledge of how to use languages like that effectively.

                                                                                                                                    I think you could use it with practice. I think you could learn how to scale it to large teams. It’s okay that you don’t want to do or learn how to do either of those things but I wouldn’t internalize that decision as an inability. The people who are using functional programming at scale almost certainly aren’t smarter than you, just more patient and willing to feel dumb. Or more likely they didn’t happen to deep dive into an entire other paradigm where their previous intuitions are less useful.

                                                                                                                                    While your post may have hurt my feelings to an extent and I’m sure that leaked out in my tone, my overarching goal was to dispel illusions of inadequacy.

                                                                                                                            1. 4

                                                                                                                              You don’t have to write JavaScript, you have to write Elixir - which has a much smaller community around it than JavaScript does.

                                                                                                                              This does look cool though, I just wish there were some live examples I could play with in my browser.

                                                                                                                              1. 12

                                                                                                                                On the other hand, the Elixir community is very friendly. :)

                                                                                                                                Supposedly something like LiveView is coming to .NET - https://codedaze.io/introduction-to-server-side-blazor-aka-razor-components/ - but the post says:

                                                                                                                                We don’t really know yet how well server-side Blazor (Razor Components) will scale with heavy use applications.

                                                                                                                                In principle, people could take this approach in other languages as well. But I think Elixir / Erlang are uniquely positioned to do it well, as LiveView is built on Phoenix Channels, which (because they use lightweight BEAM processes) can easily scale to keep server-side state for every visitor on your site: https://phoenixframework.org/blog/the-road-to-2-million-websocket-connections

                                                                                                                                1. 2

                                                                                                                                  On the other hand, the Elixir community is very friendly. :)

                                                                                                                                  Is that comment supposed to contrast the friendly Elixir community with the JS community? Is the JS community considered unfriendly? It’s way, way bigger than the Elixir community, so there are bound to be some/more unfriendly people. Maybe it’s so big that the concept of a “JS community” doesn’t even make sense. It’s probably more like “Typescript community”, “React community”, “Node community”, etc… But there are a lot of friendly people and helpful resources out there in JS-land, in my experience. I hope others have found the same thing.

                                                                                                                                  1. 12

                                                                                                                                    The Elixir community is still in the “we’re small and must be as nice as possible to new people so they’ll drink the koolaid” phase. The “community” such as it is is also heavily pulled from job shops and the conference circuit, so there’s a big factor too.

                                                                                                                                    Past the hype it’s a good and servicable language, provided you don’t end up on a legacy codebase.

                                                                                                                                    1. 5

                                                                                                                                      Sounds like Rails, all over again.

                                                                                                                                      Who hurt you @friendlysock?

                                                                                                                                      1. 4

                                                                                                                                        legacy codebase

                                                                                                                                        How would you define ‘legacy codebase’? I’m assuming it’s something other than ‘code that is being used to turn a profit’..

                                                                                                                                        1. 4

                                                                                                                                          Ha, you’re not wrong! I like that definition.

                                                                                                                                          From bitter experience, I’d say it would be an Elixir codebase, written in the past 4 or 5 years, spanning multiple major releases of Ecto and Phoenix and the core language, having survived multiple attempts at CI and deployment, as well as hosting platforms. Oh, and database drivers of varying quality as Ecto got up to speed. Oh oh, and a data model that grew “organically” (read: wasn’t designed) from both an early attempt at Ecto as well as being made to work with non-Ecto-supported DB backends, resulting it truly delightful idioms and code smells.

                                                                                                                                          Oh, and because it is turning a profit, features are important and spending time doing things that might break the codebase are somewhat discouraged.

                                                                                                                                          Elixir for green-field projects is absolutely a joy…brown-field Elixir lets devs just do really terrible heinous shit.

                                                                                                                                          1. 3

                                                                                                                                            Elixir for green-field projects is absolutely a joy…brown-field Elixir lets devs just do really terrible heinous shit.

                                                                                                                                            Totally agree, but I would say that significantly more heinous shit is available to devs in Ruby or another dynamic imperative language. The Elixir compiler is generally stricter and more helpful, and most code is just structured as a series of function calls rather than as an agglomeration of assorted stateful objects.

                                                                                                                                            The refactoring fear is real though. IMO the only effective salve for that sickness is strong typing (and no, Dialyzer doesn’t count).

                                                                                                                                            1. 2

                                                                                                                                              So you’re saying that Elixir is just another programming language? It’s not the Second Coming or anything?

                                                                                                                                              1. 1

                                                                                                                                                I mean, it’s really quite good in a number of ways, and the tooling is really good. That said, there’s nothing by construction that will keep people from doing really unfortunate things.

                                                                                                                                                So, um, I guess to answer your question: yep. :(

                                                                                                                                        2. 7

                                                                                                                                          😊 I can see how it sounded that way, but I didn’t mean to imply anything about anyone else. The parent post said the Elixir community is small, so I was responding to that concern.

                                                                                                                                          1. 4

                                                                                                                                            Is the JS community considered unfriendly?

                                                                                                                                            I feel you’re just trying to polemic on the subject… The author of this comment probably didn’t mean harm, don’t make it read like so.

                                                                                                                                            1. 2

                                                                                                                                              I’m not what you mean by “trying to polemic”, that doesn’t make sense to me as a phrase, but it was a genuine question about whether the JS community is considered to be unfriendly. I’d be happy to be told that such a question is off-topic for the thread, and I certainly don’t want to start a flame war, but I didn’t bring up the friendliness of the community. I’m sure the author didn’t mean harm, but I read (perhaps incorrectly) that part of their reply as part of an argument for using Elixir over JS to solve a problem.

                                                                                                                                              1. 6

                                                                                                                                                What I meant to say was: “If this looks like it could be a good fit for thing you want to do, but you’re daunted by the idea of learning Elixir, don’t worry! We are friendly.”

                                                                                                                                                1. 3

                                                                                                                                                  I meant starting a controversy, sorry for my poor English! I’m sorry if it felt harsh, that wasn’t what I tried to share. I really thought your goal was to start this flame war.

                                                                                                                                                  Every community has good and bad actors. Some people praise a lot some communities, but I don’t think they mean the others aren’t nice either.

                                                                                                                                                  The only thing that I could think of is that smaller communities have to be very careful with newcomers, because it helps to grow the community. JS people don’t need to be nice with each other, the community and the project are way pas that need. So I guess you would find a colder welcome than with a tiny community.

                                                                                                                                                  1. 0

                                                                                                                                                    Hey there, polemic is a legit English word, so don’t be sorry for someone else’s ignorance! :)

                                                                                                                                                    1. -2

                                                                                                                                                      I’m not ignorant (well I am, but not about this): polemic is indeed an English word, but it’s not a verb. The phrase “trying to polemic” doesn’t make sense in English, it requires interpretation, which makes the meaning unclear. I can think of two interpretations for “trying to polemic” (there may be others) in the context of the comment:

                                                                                                                                                      1. My comment was polemic
                                                                                                                                                      2. I was attempting to start a polemical comment thread, aka a flame war. With the later clarification that seems like what the author was thinking.
                                                                                                                                                      1. 1

                                                                                                                                                        The thing is that not everyone is at your level of English proficiency. You’re having a discussion here with people from around the world, you’ll need to make a couple of adjustments for expected quality of English and try to get the rough meaning of what they’re saying, otherwise you’ll be stuck pointing out grammatical errors all day.

                                                                                                                                                        1. 2

                                                                                                                                                          I wasn’t really trying to point out an English error, and perhaps I did a poor job of that. I stand by the claim that it is an English error though.

                                                                                                                                                          I work with non-native English speakers all day, I’m aware of the need to try and understand other people and to make sure we’re on the same page. I’ll give a lot of slack to anyone, native or non-native, who’s trying to express themselves. The problem with the phrase “I feel you’re just trying to polemic on the subject’ is that at least some of the interpretations change the meaning. On the one hand, it could be saying that my comment was polemic, on the other it could be saying that my comment was trying to start a polemical thread. It’s not the same thing. And, for what it’s worth, if you’re going to throw an uncommon (and quite strong) English word like “polemic” out there it’s best if you correctly understand the usage. If the author had accused me of trolling, which is I think what they meant, that would have been both clearer and more accurate (though my intent was not to troll)

                                                                                                                                        1. 4

                                                                                                                                          It’s all easy to tell people to switch from X to Y (browser, OS, antivirus, etc.) but you can’t just go preaching when the alternatives aren’t quite the same. Sure you have Firefox (or any other flavour) and while I’d love to fully switch, it isn’t quite there yet. You can tell people to switch to some Linux distro or to install LineageOS but that comes with losing certain features or apps (try doing gamedev from Linux for example).

                                                                                                                                          And Firefox won over IE because it was better not for the fact IE back in the XP days was crap with its ActiveX madness. And same with the general switch to Chrome, it performed better.

                                                                                                                                          The bottom line for me is: make better alternatives to cover the general use case and people WILL switch (because their “techy” friend installs it for them) but they probably won’t just to get away from privacy issues if it gives them less headaches.

                                                                                                                                          1. 7

                                                                                                                                            same with the general switch to Chrome, it performed better

                                                                                                                                            Most people did not care that it performed “better”.

                                                                                                                                            They just saw the ads. On every google page. Including the search front page.

                                                                                                                                            1. 6

                                                                                                                                              Pretty sure Chrome grew its popularity when Firefox became quite sluggish, together with its strong presence in smartphones.

                                                                                                                                              1. 8

                                                                                                                                                Yeah, it is easy to forget how amazing Chrome was versus the competition in 2008. Other browsers were covered in garbage and layers of UI, Chrome was minimalist. When other browsers would crash when you went to a bad webpage, chrome just lost a tab due to the process separation. Even at initial release, Chrome was much faster than the competition. It also had the omnibar which felt like the “right way”.

                                                                                                                                              2. 3

                                                                                                                                                Watch the Google Chrome announcement video

                                                                                                                                                They compare it side-by-side with Internet Explorer. It shows that, for JavaScript, Chrome was around 100 times faster. For rendering it was around 3 times faster. The tab isolation, simpler user experience etc was also a serious win.

                                                                                                                                                These types of improvements did matter to a lot of people.

                                                                                                                                                1. 2

                                                                                                                                                  The ads gave Google an opportunity to win people over, but ads alone don’t convince anyone to commit to a product. IMO by the time Chrome ads started popping up on Google properties, Chrome had already won.

                                                                                                                                                  When Chrome came out it had superior UX to Firefox on every front. Performance, extensions, sync, transparent auto-updates, omnibar: everything was better and simpler for the 90% use-case. I specifically remember switching my parents and grandparents to Chrome because they kept getting stuck on old versions of Firefox and/or extensions would randomly stop working (namely ABP; about once a quarter I would get a call complaining that “the ads are back”). Chrome solved that problem for me.

                                                                                                                                                  I’m a big fan of Mozilla but Firefox has always been a funky browser for nerds. It dominated IE because Microsoft had made zero technical investments for years and years. Firefox has made great strides competing with Chrome, but it hasn’t made any huge leaps and it still has rough edges. I think Mozilla as an organization struggles to put out products that are uncompromisingly great for the non-technical user.

                                                                                                                                                  1. 2

                                                                                                                                                    It dominated IE because Microsoft had made zero technical investments for years and years.

                                                                                                                                                    Uh, when did Firefox “dominate IE”? Even after major EU legal wins, etc, Firefox was second until Chrome came with an even bigger backer that the regulators hadn’t smacked yet and ate everyone’s lunch.

                                                                                                                                                    1. 1

                                                                                                                                                      Uh, maybe it was too strong a word. But the market-share numbers are distorted by the incapability of corporate IT to move off IE at that time. That’s why the lifecycles of IE 6/7/8 were so drawn out.

                                                                                                                                                      My recollection of that era is that anyone who understood what a browser was and had the ability to choose whichever one they wanted was using Firefox.

                                                                                                                                                    2. 2

                                                                                                                                                      Wow, I had forgotten auto-update, that might have been the most important feature!

                                                                                                                                                      When Chrome was released, it actually lacked both extensions and sync, but the per-tab process and auto-update were killer features – plus general performance.

                                                                                                                                                      1. 1

                                                                                                                                                        When Chrome was released, it actually lacked both extensions and sync

                                                                                                                                                        It got them in 2010, shortly before the first release for macOS, which is probably what I’m remembering as the initial release. It didn’t surpass Firefox and IE in market share until 2012.

                                                                                                                                                    3. 2

                                                                                                                                                      Most people did not care that it performed “better”.

                                                                                                                                                      I don’t think this is true. At the time, both IE and FF were very slow and frustrating for people. A crash in either would take down the entire browser. “Updating their browser” was something their tech friends would tell them to do, and they wouldn’t do. Chrome was automatically updated, simpler, faster, more stable (re: crashing) and it was less complicated (at least in UI – omnibar, better on smaller screen). I think it won due to fitness for purpose, not ads.

                                                                                                                                                    4. 6

                                                                                                                                                      What about Firefox “isn’t quite there”?

                                                                                                                                                      1. 5

                                                                                                                                                        Firefox is not “quite there” because developers today mostly create Chrome apps, and consider other browsers as an afterthought. On desktop, and even more on Android, I often need to switch back to Chrome because the app I’m using doesn’t work on Firefox or is way too slow.

                                                                                                                                                        Technically it’s very easy to get a website to work on any browser, but we don’t create websites anymore, often even plain text articles are “apps”, with JS all over the place and this is mostly designed to work on Chrome only.

                                                                                                                                                        1. 1

                                                                                                                                                          Firefox isn’t quite there because developers don’t target it. Developers don’t target Firefox because it isn’t quite there.

                                                                                                                                                          I understand and agree with your point, but this isn’t really something Mozilla can do much about (other than actually gaining back market share).

                                                                                                                                                        2. 4

                                                                                                                                                          I’ve tried to adopt Firefox seriously many times over the years, but every time the support for multi-user didn’t cut it for me.

                                                                                                                                                          I maintain two profiles in Chrome, a professional and a personal one. I’ve tried to replicate it with Firefox profiles, then later with containers, but the UX is not fitting my use case.

                                                                                                                                                          1. 2

                                                                                                                                                            Firefox lacks Chrome’s --app switch for example. That launches a window without the tab bar and the URL bar (essentially, only a webview). It’s super-sweet. Firefox does not support it out of the box, and all solutions I found involved setting up a separate profile. Chrome allows me to have these “apps” in the same profile, so they have access to the same extensions, I can open tabs from them, in my main browser window.

                                                                                                                                                            It’s a stupidly powerful feature if you have a few webapps you want to treat as apps instead of tabs.

                                                                                                                                                            1. 12

                                                                                                                                                              That sounds like a very very specific feature though, that maybe 1% of the people might use.

                                                                                                                                                              For the rest, Firefox is a perfectly good browser which (so far) seems to follow better privacy practices than Chrome.

                                                                                                                                                              1. 2

                                                                                                                                                                That sounds like a very very specific feature though, that maybe 1% of the people might use.

                                                                                                                                                                You’d be surprised how many people use this. Makes it so much easier to use a website as an app, and unlike the common Electron apps, allows one to use extensions with it. But even if only 1% used it, for that 1%, Firefox is not quite there.

                                                                                                                                                                Also, Electron. Tons of stuff is built on it, and it uses Chrome under the hood.

                                                                                                                                                                Firefox is a perfectly good browser which (so far) seems to follow better privacy practices than Chrome.

                                                                                                                                                                Yeah, like those experiments, or DNS-over-HTTPS which sends all DNS requests to Cloudflare. Or the integrated Pocket. Those might spy on me less, but it’s only marginally better.

                                                                                                                                                                1. 2

                                                                                                                                                                  I hope for your sake that it’s way more than 1% usage. Google has a history of removing features that not many people use [1].

                                                                                                                                                                  [1] I still prefer using Google Maps over anyone else but over time, I’ve had features I use removed due to lack of utilization. It’s annoying. Second only to the UI constantly changing.

                                                                                                                                                                  1. 1

                                                                                                                                                                    I believe a place that chrome apps are more commonly used is enterprise. It basically gives an easy way to put your internal CRUD webapp on the start menu with an icon and if you use the extended support some additional features. I suspect this is what keeps –app alive more than the at-home users use of it.

                                                                                                                                                                    I have seen orgs with 30+ “chrome apps” in the default image. Actually probably the biggest category of apps on those deploys. Nevermind of course Chromebooks.

                                                                                                                                                                  2. 1

                                                                                                                                                                    But even if only 1% used it, for that 1%, Firefox is not quite there.

                                                                                                                                                                    That’s nonsense. 1% might use it, and that’s probably an overestimate. For how many of them is it a dealbreaker? Even fewer. Probably far fewer. It’s a really insignificant feature.

                                                                                                                                                                    Yeah, like those experiments

                                                                                                                                                                    I don’t know what this means, could you elaborate?

                                                                                                                                                                    or DNS-over-HTTPS which sends all DNS requests to Cloudflare.

                                                                                                                                                                    DNS-over-HTTPS does not send all DNS requests to Cloudflare, and even if it did it would still be more secure than insecure DNS which sends all DNS requests to anyone listening, including Cloudflare if they wanted to.

                                                                                                                                                                    Or the integrated Pocket.

                                                                                                                                                                    Don’t like it? Don’t use it. I fail to see how this is ‘spying’ on you.

                                                                                                                                                                    1. 0

                                                                                                                                                                      It’s a really insignificant feature.

                                                                                                                                                                      For you, yes. For me, it is essential. It doesn’t matter how many use it, for those who do, Firefox is not quite there. For everyone else, it might be, good for them.

                                                                                                                                                                      I don’t know what this means, could you elaborate?

                                                                                                                                                                      Look for Firefox studies. Granted, you have to opt in to them right now (like you used to be able to opt in to logging into Chrome), but then you’re opting in to pretty much all studies. This is just a step away from what Chrome’s doing now, and sending your browsing data to third parties, disguised as studies is even less honest.

                                                                                                                                                                      DNS-over-HTTPS does not send all DNS requests to Cloudflare, and even if it did it would still be more secure than insecure DNS which sends all DNS requests to anyone listening, including Cloudflare if they wanted to.

                                                                                                                                                                      Err, yes, it does send all DNS requests originating from Firefox through Cloudflare. It does fall back to regular DNS, but if enabled, it first goes through them. Not saying I trust my ISPs DNS servers, but I do trust my ISP to be far less competent at mining my data than Cloudflare.

                                                                                                                                                                      1. 2

                                                                                                                                                                        Firefox studies are completely opt-in. They’re in an options window most people apparently never open. To compare this to Google forcing you to send them all your browsing data if you so much as log into GMail through their browser is ridiculous.

                                                                                                                                                                        DNS over HTTPS

                                                                                                                                                                        Doesn’t even look like this is out of nightly, it’s a feature you have to enable through the about:config page… I mean come on man, you cannot seriously be arguing this is a breach of privacy. They’re both completely opt-in.

                                                                                                                                                                        DNS over HTTPS sends your DNS traffic to a DNS-over-HTTPS provider. I’m sure it’s possible to change which provider it is. I wouldn’t be surprised if Google switched DNS in Chrome to go to 8.8.8.8 by default anyway. Certainly they widely encourage people to do so without telling them that this gives Google again all their browsing history, and more besides.

                                                                                                                                                                        1. 1
                                                                                                                                                                          1. 1

                                                                                                                                                                            Firefox studies are completely opt-in

                                                                                                                                                                            So was Chrome’s login until recently. I’m not going to trust a for-profit corporation to respect my privacy forever. Especially when those studies are marketed as harmless things, yet, send a whole lot of data to third parties (not even to Mozilla, but third parties).

                                                                                                                                                                            I’m sure it’s possible to change which provider it is

                                                                                                                                                                            It is, but there are currently two public DNS-over-HTTPS providers: Cloudflare and Google. Yay. You can run your own, yes, but not even 0.1% of users will ever do that. Besides you can also disable Chrome’s login thing if you really want to, with a flag: go to chrome://flags/#account-consistency, and set it to disabled.

                                                                                                                                                                            It’s an internal flag, and may or may not go away, but for the moment, it gets the job done, and I get to keep –app too.

                                                                                                                                                                            1. 1

                                                                                                                                                                              So was Chrome’s login until recently.

                                                                                                                                                                              It isn’t now. Now is what matters.

                                                                                                                                                                              I’m not going to trust a for-profit corporation to respect my privacy forever.

                                                                                                                                                                              Then why are you trusting Google to respect your privacy, given that they have never done so and Mozilla have nearly always done so. Mozilla has always acted in good faith wrt. privacy. Google has not. Yet you defend Google and attack Mozilla. Why?

                                                                                                                                                                              Especially when those studies are marketed as harmless things, yet, send a whole lot of data to third parties (not even to Mozilla, but third parties).

                                                                                                                                                                              So don’t enable them then. They’re completely optional and opt-in. I don’t understand why you think being able to opt into something is anywhere near comparable to being forced to give data.

                                                                                                                                                                              It is, but there are currently two public DNS-over-HTTPS providers: Cloudflare and Google. Yay. You can run your own, yes, but not even 0.1% of users will ever do that.

                                                                                                                                                                              So don’t enable it then. How is it Mozilla’s fault there aren’t more DNS-over-HTTPS providers? Get your ISP to provide it.

                                                                                                                                                                              Besides you can also disable Chrome’s login thing if you really want to, with a flag: go to chrome://flags/#account-consistency, and set it to disabled.

                                                                                                                                                                              It’s opt-out, in other words. Opt-out = might as well be mandatory for most users. On the other hand, opt-in = might as well not exist for most users. Most users are never ever going to enable anything opt-in and never ever going to disable anything opt-out.

                                                                                                                                                                              It’s an internal flag, and may or may not go away, but for the moment, it gets the job done, and I get to keep –app too.

                                                                                                                                                                              I’ve already explained how you can get the same functionality as --app in Firefox: go fullscreen, disable toolbars.

                                                                                                                                                                              1. 1

                                                                                                                                                                                Now is what matters.

                                                                                                                                                                                Now I can disable the sign-off in Chrome and Chromium. Chromium doesn’t send my data to Google. They both support the feature I want. If now is all that matters, then there is zero argument in favour of Firefox, as Chromium does precisely what I want, and am already using it.

                                                                                                                                                                                Thank you.

                                                                                                                                                                  3. 3

                                                                                                                                                                    Firefox and Chrome have different sets of features. They overlap significantly but not exactly. It’s easy to cherry-pick features either of them have that the other doesn’t. That doesn’t mean that Firefox isn’t a perfectly acceptable replacement for Chrome.

                                                                                                                                                                    I have no clue why you’d want to launch a window without a tab bar and URL bar. Oh no, a couple of bars at the top of my screen, that’s far worse than sending all my browsing history to Google.

                                                                                                                                                                    1. 1

                                                                                                                                                                      That doesn’t mean that Firefox isn’t a perfectly acceptable replacement for Chrome.

                                                                                                                                                                      It is, if you don’t need the features it does not have. If you do, it is a deal breaker. (No size fits all and all that)

                                                                                                                                                                      I have no clue why you’d want to launch a window without a tab bar and URL bar.

                                                                                                                                                                      And I have no clue why you’d want to launch more than one browser window with tab and URL bars. But, to illustrate: I have two screens, and on my secondary, I have Mastodon & Discord open, in a frame-less chrome window. Whatever link I click there, if it leads away from the domain, it opens in a new tab. I never leave the “app” itself. Why would I need a tab and an URL bar there? Those just make it too easy to navigate away. Not having them removes that problem, and also makes them look almost like a native app, which is great.

                                                                                                                                                                      Small thing, yes, but so convenient that I’d rather patch Chrome to remove the login requirement than to figure out how to do the same with firefox. The former is considerably easier.

                                                                                                                                                                      If you don’t need this feature, sure, use Firefox or whatever.

                                                                                                                                                                      (Note: I’m not saying Chrome is better. It isn’t. I’m saying Firefox lacks useful features Chrome has, and as such, is not quite there for those of us who want those features. I’d love to switch way from Chrome, but haven’t found a browser that supports the extensions I use, and app windows. As soon as I find one, I’ll be jumping ship. I’m pretty sure it won’t be Firefox though.)

                                                                                                                                                                      1. 2

                                                                                                                                                                        FF actually had the “apps” feature before Chrome even was released.

                                                                                                                                                                        Sadly it was killed off.

                                                                                                                                                                        1. 1

                                                                                                                                                                          Yeah, I remembered Firefox having it, and arrived at the same page, and was even more disappointed :/

                                                                                                                                                                          Mind you, Prism isn’t the same - it’s separate from the main browser, chrome’s –app is not (and that’s the great thing about it; I can get the separate think with Firefox with a kiosk add-on, but that’s not what I’m aiming for).

                                                                                                                                                                          1. 1

                                                                                                                                                                            It actually felt very similar, I would go so far as to say most of the way Chrome’s –app was inspired by the Prism extension. It used the same core in a different XULrunner and could be created just like you do in Chrome from the menu. Created desktop icons, had unique window idents, the whole deal. It had to be a bit more separate because back then there wasn’t process isolation per tab in FF, and one of prisms major goals was to avoid crashing the main browser.

                                                                                                                                                                        2. 0

                                                                                                                                                                          In Firefox in full screen mode you can hide toolbars (includes URL bar and tab bar). I use this to watch full screen videos sometimes. You don’t have to have it actually covering your full screen either, if you use a proper window manager like dwm that can resize windows that ask to be fullscreen.

                                                                                                                                                                          I really mean no offence when I say this, but your argument is bad. You can’t have everything you want. If you prioritise ‘app windows’ over security and privacy that’s your call, of course, but it’s a bad argument to claim that Firefox isn’t a satisfactory replacement for Chrome because it doesn’t have ‘app windows’. By that logic, Chrome is a wholly unsatisfactory replacement for Firefox, for the reason that it’s insecure crap that gives all my browsing data to Google…

                                                                                                                                                                          1. 1

                                                                                                                                                                            You just said they made a bad argument… then in literally the next sentence admitted that for their requirements it was a good argument… they DO prioritize ‘app windows’.

                                                                                                                                                                            Their argument was simply that it isn’t a “perfectly acceptable replacement” within the requirements they laid forth of “having app window support”. This makes their argument well reasoned and coherent. If you want to attack one of their premises, you can do that – but that is another argument.

                                                                                                                                                                            You then go on to attack the premise and claim their requirement is not an actual requirement, and can be replaced with some set of outside tooling. I don’t believe you proved your case on that front based on the short point you made about dwn. They referenced other features as well.

                                                                                                                                                                            I personally have unsuccessfully tried to replace chrome apps a number of times with FF or even other browsers. I never got it working the way I wanted it – window identification issues mostly, and in a few cases webapps not playing well with being forcefully resized. So currently I use chrome only for these “apps” and I use FF as my primary browser.

                                                                                                                                                                            As for Chrome not being a satisfactory replacement for FF for you – that also seems to be true. With your implied premise of being opposed to Google’s data collection practices, obviously Chrome is unacceptable for you. That argument is also coherent with those premises. I won’t say you have a “bad argument” because within the premises you implied, it is a good one. You value different things – neither argument is bad or wrong.

                                                                                                                                                                            1. 1

                                                                                                                                                                              In short: their argument was a response to a question asking why Firefox was not generally suitable as a replacement for Chrome. In that context it’s bad.

                                                                                                                                                                              1. 0

                                                                                                                                                                                That doesn’t mean that Firefox isn’t a perfectly acceptable replacement for Chrome.

                                                                                                                                                                                Your high bar of “perfectly acceptable” was simply not met. It lacks features the poster needs. If you claim features don’t matter then what does exactly?

                                                                                                                                                                                1. 1

                                                                                                                                                                                  In short: their argument was a response to a question asking why Firefox was not generally suitable as a replacement for Chrome. In that context it’s bad.

                                                                                                                                                                            2. 1

                                                                                                                                                                              But I don’t run those windows full screen - they’re clamped to a screen half, so fullscreen is not an option. Been there, tried it. I could change my WM, but that’s another workaround that doesn’t work, because then I’d have to switch to one that can resize fullscreen apps, and still do everything my current one does. No thanks. I’ll patch the login stuff out of Chrome instead.

                                                                                                                                                                              And yes, Chrome is crap. But I can work around its most recent stupid far more easily than I can add app windows to Firefox. So Chrome is still a better browser for me, unfortunately.

                                                                                                                                                                              Again, I’m not saying Firefox is not a satisfactory replacement for most people. I’m saying it is not suitable for me, that there are things in Chrome that Firefox does not have, yet, people depend on, and for those people, Firefox is not quite there yet.

                                                                                                                                                                              1. 0

                                                                                                                                                                                But I don’t run those windows full screen - they’re clamped to a screen half, so fullscreen is not an option. Been there, tried it. I could change my WM, but that’s another workaround that doesn’t work, because then I’d have to switch to one that can resize fullscreen apps, and still do everything my current one does. No thanks. I’ll patch the login stuff out of Chrome instead.

                                                                                                                                                                                So in other words the problem is that you’re using a crap window manager. How is that Firefox’s fault? You choose to use a crap WM, that’s fine, but don’t go around threads about browsers crapping on Firefox just because you make poor choices elsewhere in your setup.

                                                                                                                                                                                You can’t patch anything out of Chrome. Doesn’t work like that. You can patch Chromium, but Chromium isn’t Chrome.

                                                                                                                                                                                And yes, Chrome is crap. But I can work around its most recent stupid far more easily than I can add app windows to Firefox. So Chrome is still a better browser for me, unfortunately.

                                                                                                                                                                                No, you cannot work around Chrome sending all your browsing data to Google. Chrome is built from the ground up to send your browsing data to Google. It’s untrusted proprietary software. You cannot work around that.

                                                                                                                                                                                Again, I’m not saying Firefox is not a satisfactory replacement for most people. I’m saying it is not suitable for me, that there are things in Chrome that Firefox does not have, yet, people depend on, and for those people, Firefox is not quite there yet.

                                                                                                                                                                                You were defending the comment that said ‘It’s all easy to tell people to switch from X to Y (browser, OS, antivirus, etc.) but you can’t just go preaching when the alternatives aren’t quite the same. Sure you have Firefox (or any other flavour) and while I’d love to fully switch, it isn’t quite there yet.’ I’m sorry, but that’s a broad statement about Firefox that suggests it’s missing important core browsing features. Not that it’s missing some tiny obscure feature you personally use but which most people have never heard of and wouldn’t want anyway.

                                                                                                                                                                                (and which you can emulate in Firefox if you use a decent window manager)

                                                                                                                                                                                1. 2

                                                                                                                                                                                  So in other words the problem is that you’re using a crap window manager.

                                                                                                                                                                                  No, my problem is that Firefox does not implement a feature I use. My window manager is fine, thank you very much. That fact that the only way to make an app emulate a feature I use is to work it around in WM, by ignoring a full screen request and doing something else is not a solution. That is a crude hack.

                                                                                                                                                                                  You can’t just go around telling people “Go use a different browser and a different WM”. That’s about the same level of good advice as “Tired of systemd? Just go use OpenBSD!”. It doesn’t work like that.

                                                                                                                                                                                  You can patch Chromium, but Chromium isn’t Chrome.

                                                                                                                                                                                  Yeah, but I can patch it out from Chromium. Or disable with a flag. And still keep –app, and won’t have to switch to a whole new WM. If I used firefox, my task would be a whole lot harder.

                                                                                                                                                                                  You were defending the comment that said ‘It’s all easy to tell people to switch from X to Y (browser, OS, antivirus, etc.) but you can’t just go preaching when the alternatives aren’t quite the same. Sure you have Firefox (or any other flavour) and while I’d love to fully switch, it isn’t quite there yet.’

                                                                                                                                                                                  And I stand by my defense: you can’t tell people to change, when the alternatives lack important features. It just happens YOU don’t consider the same features important. I’ll give you an analogy:

                                                                                                                                                                                  • I’m tired of systemd, for reason X.
                                                                                                                                                                                  • Use OpenBSD.
                                                                                                                                                                                  • But OpenBSD does not support my hardware.
                                                                                                                                                                                  • It is your fault for making poor hardware choices, it is easy to run OpenBSD on proper hardware.

                                                                                                                                                                                  That’s how you sound like now.

                                                                                                                                                                                  1. 2

                                                                                                                                                                                    No, my problem is that Firefox does not implement a feature I use. My window manager is fine, thank you very much. That fact that the only way to make an app emulate a feature I use is to work it around in WM, by ignoring a full screen request and doing something else is not a solution. That is a crude hack.

                                                                                                                                                                                    It’s not a crude hack. It’s a normal expected feature of any window manager: to be able to resize windows.

                                                                                                                                                                                    1. 1

                                                                                                                                                                                      It’s not a crude hack. It’s a normal expected feature of any window manager: to be able to resize windows.

                                                                                                                                                                                      Not fullscreen ones. Very few can resize those.

                                                                                                                                                                                      1. 1

                                                                                                                                                                                        Most window managers are bad, I guess. Most things are bad.

                                                                                                                                                                        3. 1

                                                                                                                                                                          How do you use this feature? It sounds interesting, but it’s never occurred to me. When you say ‘webapps’, do you mean browser extensions or things that would ordinarily be packaged as android/iOS apps? Or something else entirely?

                                                                                                                                                                          1. 4

                                                                                                                                                                            It is even simpler than you are thinking. Basically when you create a “app” out of a website what happens is you get a shortcut that does the following:

                                                                                                                                                                            • opens a browser instance with no browser ui components, it is just the page loaded in a window.
                                                                                                                                                                            • gives that window a custom id (so your window manager can tell it apart from other windows for rules and such)
                                                                                                                                                                            • gives it a taskbar entry
                                                                                                                                                                            • gives it an icon
                                                                                                                                                                            • puts a link to it in your menu system if supported
                                                                                                                                                                            • puts a link to it on your desktop if supported

                                                                                                                                                                            I use a ton of them, right now I am running in “app” mode:

                                                                                                                                                                            • IRCCloud
                                                                                                                                                                            • WhatsApp Web
                                                                                                                                                                            • Google Keep
                                                                                                                                                                            • Google Music
                                                                                                                                                                            • Fastmail Inbox
                                                                                                                                                                            • Pocketcasts
                                                                                                                                                                            • Todoist
                                                                                                                                                                            • Trello
                                                                                                                                                                            • Tweetdeck
                                                                                                                                                                            • Dungeon Crawl Web Tiles
                                                                                                                                                                            • Youtube.TV

                                                                                                                                                                            I run these as “apps” because I have rules that put them on certain desktops or monitors, and I like them having their own taskbar entries.


                                                                                                                                                                            I actually use Firefox as my main browser – and one of my annoyances with you these chrome “apps” is that if I click a link from like IRCCloud – it always opens in chrome because well – it is already IN chrome. I wish I could set them up to use the system default browser.

                                                                                                                                                                            1. 2

                                                                                                                                                                              The latter, things that would be packaged as android/ios/electron apps. I use slack, discord, mastodon like this, because I want them always-on, without accidentally navigating away, but links still opening in my main window (on another screen), and with my extensions available so I can tweak my experience, block trackers, and so on. Since I want these always on, and separate from my main browser, there is zero purpose for a tab or url bar on them. They feel much more like an app than a browser window would, yet, I have more control than if I ran a (non-free, usually) native app.

                                                                                                                                                                              1. 1

                                                                                                                                                                                I segregate websites that are not good actors but that I still use (Facebook, LinkedIn, Instagram) using single-site browsers, via Fluid. Fluid uses a completely different local storage instance for every “app” you create, so you don’t have to worry about being tracked around. This allows me to ratchet up the level of privacy I ask for from my browser without worrying about breaking functionality on those web “apps” I use.

                                                                                                                                                                                As much as I despise it, this is also why I use the Electron versions of Spotify and Slack.

                                                                                                                                                                            2. 1

                                                                                                                                                                              I was going to say the memory footprint and its overall smoothness but I don’t have data to back that up, so it’s just a feeling.

                                                                                                                                                                              I try to go back to FF out of principle but I guess there is something in Chrome which keeps winning me over.

                                                                                                                                                                            3. 1

                                                                                                                                                                              Of course Firefox is “there”; it’s been “there” for longer than Chrome’s even existed.

                                                                                                                                                                              1. 1

                                                                                                                                                                                make better alternatives to cover the general use case and people WILL switch (because their “techy” friend installs it for them)

                                                                                                                                                                                This strategy has never worked.

                                                                                                                                                                              1. 65

                                                                                                                                                                                This blogpost is a good example of fragmented, hobbyist security maximalism (sprinkled with some personal grudges based on the tone).

                                                                                                                                                                                Expecting Signal to protect anyone specifically targeted by a nation-state is a huge misunderstanding of the threat models involved.

                                                                                                                                                                                Talking about threat models, it’s important to start from them and that explains most of the misconceptions in the post.

                                                                                                                                                                                • Usable security for the most people possible. The vast majority people on the planet use iOS and Android phones, so while it is theoretically true that Google or Apple could be forced to subvert their OSs, it’s outside the threat model and something like that would be highly visible, a nuclear option so to speak.
                                                                                                                                                                                • Alternative distribution mechanisms are not used by 99%+ of the existing phone userbases, providing an APK is indeed correctly viewed as harm reduction.
                                                                                                                                                                                • Centralization is a feature. Moxie created a protocol and a service used by billions and millions of people respectively that provides real, measureable security for a lot of people. The fact is that doing all this in a decentralized way is something we don’t yet know how to do or doing invites tradeoffs that we shouldn’t make. Federation atm either leads to insecurity or leads to the ossification of the ecosystem, which in turn leads to a useless system for real users. We’ve had IRC from the 1990s, ever wonder why Slack ever became a thing? Ossification of a decentralized protocol. Ever wonder why openpgp isn’t more widespread? Noone cares about security in a system where usability is low and design is fragile. Ever tried to do key rotation in gpg? Even cryptographers gave up on that. Signal has that built into the protocol.

                                                                                                                                                                                Were tradeoffs made? Yes. Have they been carefully considered? Yes. Signal isn’t perfect, but it’s usable, high-level security for a lot of people. I don’t say I fully trust Signal, but I trust everything else less. Turns out things are complicated when it’s about real systems and not fantasy escapism and wishes.

                                                                                                                                                                                1. 34

                                                                                                                                                                                  Expecting Signal to protect anyone specifically targeted by a nation-state is a huge misunderstanding of the threat models involved.

                                                                                                                                                                                  In this article, resistance to governments constantly comes up as a theme of his work. He also pushed for his tech to be used to help resist police states like with the Arab Spring example. Although he mainly increased the baseline, the tool has been pushed for resisting governments and articles like that could increase perception that it was secure against governments.

                                                                                                                                                                                  This nation-state angle didn’t come out of thin air from paranoid, security people: it’s the kind of thing Moxie talks about. In one talk, he even started with a picture of two, activist friends jailed in Iran in part to show the evils that motivate him. Stuff like that only made the stuff Drew complains about on centralization, control, and dependence on cooperating with surveillance organization stand out even more due to the inconsistency. I’d have thought he’d make signed packages for things like F-Droid sooner if he’s so worried about that stuff.

                                                                                                                                                                                  1. 5

                                                                                                                                                                                    A problem with the “nation-state” rhetoric that might be useful to dispel is the idea that it is somehow a God-tier where suddenly all other rules becomes defunct. The five-eyes are indeed “nation state” and has capabilities that are profound; like the DJB talk speculating about how many RSA-1024 keys that they’d likely be able to factor in a year given such and such developments and what you can do with that capability. That’s scary stuff. On the other hand, this is not the “nation state” that is Iceland or Syria. Just looking at the leaks from the “Hacking Team” thing, there are a lot of “nation states” forced to rely on some really low quality stuff.

                                                                                                                                                                                    I think Greg Conti in his “On Cyber” setup depicts it rather well (sorry, don’t have a copy of the section in question) and that a more reasonable threat model of capable actors you do need to care about is that of Organized Crime Syndicates - which seems more approachable. Nation State is something you are afraid of if you are political actor or in conflict with your government, where the “we can also waterboard you to compliance” factors into your threat model, Organized Crime hits much more broadly. That’s Ivan with his botnet from internet facing XBMC^H Kodi installations.

                                                                                                                                                                                    I’d say the “Hobbyist, Fragmented Maximalist” line is pretty spot on - with a dash of “Confused”. The ‘threats’ of Google Play Store (test it, write some malware and see how long it survives - they are doing things there …) - the odds of any other app store; Fdroid, the ones from Samsung, HTC, Sony et al. - being completely owned by much less capable actors is way, way higher. Signal (perhaps a Signal-To-Threat ratio?) perform an good enough job in making reasonable threat actors much less potent. Perhaps not worthy of “trust”, but worthy of day to day business.

                                                                                                                                                                                  2. 18

                                                                                                                                                                                    Expecting Signal to protect anyone specifically targeted by a nation-state is a huge misunderstanding of the threat models involved.

                                                                                                                                                                                    And yet, Signal is advertising with the face of Snowden and Laura Poitras, and quotes from them recommending it.

                                                                                                                                                                                    What kind of impression of the threat models involved do you think does this create?

                                                                                                                                                                                    1. 5

                                                                                                                                                                                      Who should be the faces recommending signal that people will recognize and listen to?

                                                                                                                                                                                      1. 7

                                                                                                                                                                                        Whichever ones are normally on the media for information security saying the least amount of bullshit. We can start with Schneier given he already does a lot of interviews and writes books laypeople buy.

                                                                                                                                                                                        1. 3

                                                                                                                                                                                          What does Schneier say about signal?

                                                                                                                                                                                          1. 10

                                                                                                                                                                                            He encourages use of stuff like that to increase baseline but not for stopping nation states. He adds also constantly blogged about the attacks and legal methods they used to bypass technical measures. So, his reporting was mostly accurate.

                                                                                                                                                                                            We counterpoint him here or there but his incentives and reo are tied to delivering accurate info. Moxie’s incentives would, if he’s selfish, lead to locked-in to questionable platforms.

                                                                                                                                                                                    2. 18

                                                                                                                                                                                      We’ve had IRC from the 1990s, ever wonder why Slack ever became a thing? Ossification of a decentralized protocol.

                                                                                                                                                                                      I’m sorry, but this is plain incorrect. There are many expansions on IRC that have happened, including the most recent effort, IRCv3: a collectoin of extensions to IRC to add notifications, etc. Not to mention the killer point: “All of the IRCv3 extensions are backwards-compatible with older IRC clients, and older IRC servers.”

                                                                                                                                                                                      If you actually look at the protocols? Slack is a clear case of Not Invented Here syndrome. Slack’s interface is not only slower, but does some downright crazy things (Such as transliterating a subset of emojis to plain-text – which results in batshit crazy edge-cases).

                                                                                                                                                                                      If you have a free month, try writing a slack client. Enlightenment will follow :P

                                                                                                                                                                                      1. 9

                                                                                                                                                                                        I’m sorry, but this is plain incorrect. There are many expansions on IRC that have happened, including the most recent effort, IRCv3: a collectoin of extensions to IRC to add notifications, etc. Not to mention the killer point: “All of the IRCv3 extensions are backwards-compatible with older IRC clients, and older IRC servers.”

                                                                                                                                                                                        Per IRCv3 people I’ve talked to, IRCv3 blew up massively on the runway, and will never take off due to infighting.

                                                                                                                                                                                        1. 12

                                                                                                                                                                                          And yet everyone is using Slack.

                                                                                                                                                                                          1. 14

                                                                                                                                                                                            There are swathes of people still using Windows XP.

                                                                                                                                                                                            The primary complaint of people who use Electron-based programs is that they take up half a gigabyte of RAM to idle, and yet they are in common usage.

                                                                                                                                                                                            The fact that people are using something tells you nothing about how Good that thing is.

                                                                                                                                                                                            At the end of the day, if you slap a pretty interface on something, of course it’s going to sell. Then you add in that sweet, sweet Enterprise Support, and the Hip and Cool factors of using Something New, and most people will be fooled into using it.

                                                                                                                                                                                            At the end of the day, Slack works just well enough Not To Suck, is Hip and Cool, and has persistent history (Something that the IRCv3 group are working on: https://ircv3.net/specs/extensions/batch/chathistory-3.3.html)

                                                                                                                                                                                            1. 9

                                                                                                                                                                                              At the end of the day, Slack works just well enough Not To Suck, is Hip and Cool, and has persistent history (Something that the IRCv3 group are working on […])

                                                                                                                                                                                              The time for the IRC group to be working on a solution to persistent history was a decade ago. It strikes me as willful ignorance to disregard the success of Slack et al over open alternatives as mere fashion in the face of many meaningful functionality differences. For business use-cases, Slack is a better product than IRC full-stop. That’s not to say it’s perfect or that I think it’s better than IRC on all axes.

                                                                                                                                                                                              To the extent that Slack did succeed because it was hip and cool, why is that a negative? Why can’t IRC be hip and cool? But imagine being a UX designer and wanting to help make some native open-source IRC client fun and easy to use for a novice. “Sisyphean” is the word that comes to mind.

                                                                                                                                                                                              If we want open solutions to succeed we have to start thinking of them as products for non-savvy end users and start being honest about the cases where closed products have superior usability.

                                                                                                                                                                                              1. 5

                                                                                                                                                                                                IRC isn’t hip and cool because people can’t make money off of it. Technologies don’t get investment because they are good, they get good because of investment. The reason that Slack is hip/cool and popular and not IRC is because the investment class decided that.

                                                                                                                                                                                                It also shows that our industry is just a pop culture and can give a shit about good tech .

                                                                                                                                                                                                1. 4

                                                                                                                                                                                                  There were companies making money off chat and IRC. They just didn’t create something like Slack. We can’t just blame the investors when they were backing companies making chat solutions whose management stayed on what didn’t work in long-term or for huge audience.

                                                                                                                                                                                                  1. 2

                                                                                                                                                                                                    IRC happened before the privatization of the internet. So the standard didn’t lend itself well for companies to make good money off of it. Things like slack are designed for investor optimization, vs things like IRC being designed for use and openness.

                                                                                                                                                                                                    1. 2

                                                                                                                                                                                                      My point was there were companies selling chat software, including IRC clients. None pulled off what Slack did. Even those doing IRC with money or making money off it didn’t accomplish what Slack did for some reason. It would help to understand why that happened. Then, the IRC-based alternative can try to address that from features to business model. I don’t see anything like that when most people that like FOSS talk Slack alternatives. Then, they’re not Slack alternatives if lacking what Slack customers demand.

                                                                                                                                                                                                      1. 1

                                                                                                                                                                                                        Thanks for clarifying. My point can be restated as… There is no business model for federated and decentralized software (until recently , see cryptocurrencies). Note most open and decentralized tech of the past was government funded and therefore didn’t face business pressures. This freed designets to optimise other concerns instead of business onrs like slack does.

                                                                                                                                                                                                2. 4

                                                                                                                                                                                                  To the extent that Slack did succeed because it was hip and cool, why is that a negative? Why can’t IRC be hip and cool?

                                                                                                                                                                                                  The argument being made is that the vast majority of Slack’s appeal is the “hip-and-cool” factor, not any meaningful additions to functionality.

                                                                                                                                                                                                  1. 6

                                                                                                                                                                                                    Right, as I said I think it’s important for proponents of open tech to look at successful products like Slack and try to understand why they succeeded. If you really think there is no meaningful difference then I think you’re totally disconnected from the needs/context of the average organization or computer user.

                                                                                                                                                                                                    1. 3

                                                                                                                                                                                                      That’s all well and good, I just don’t see why we can’t build those systems on top of existing open protocols like IRC. I mean: of course I understand, it’s about the money. My opinion is that it doesn’t make much sense to insist that opaque, closed ecosystems are the way to go. We can have the “hip-and-cool” factor, and all the amenities provided by services like Slack, without abandoning the important precedent we’ve set for ourselves with protocols like IRC and XMPP. I’m just disappointed that everyone’s seeing this as an “either-or” situation.

                                                                                                                                                                                                      1. 2

                                                                                                                                                                                                        I definitely don’t see it as an either-or situation, I just think that the open source community typically has the wrong mindset for competing with closed products and that most projects are unapproachable by UX or design-minded people.

                                                                                                                                                                                                3. 3

                                                                                                                                                                                                  Open, standard chat tech has had persistent history and much more for decades in the form of XMPP. Comparing to the older IRC on features isn’t really fair.

                                                                                                                                                                                                  1. 2

                                                                                                                                                                                                    The fact that people are using something tells you nothing about how Good that thing is.

                                                                                                                                                                                                    I have to disagree here. It shows that it is good enough to solve a problem for them.

                                                                                                                                                                                                    1. 1

                                                                                                                                                                                                      I don’t see how Good and “good enough to solve a problem” are related here. The first is a metric of quality, the second is the literal bare minimum of that metric.

                                                                                                                                                                                              2. 1

                                                                                                                                                                                                Alternative distribution mechanisms are not used by 99%+ of the existing phone userbases, providing an APK is indeed correctly viewed as harm reduction.

                                                                                                                                                                                                I’d dispute that. People who become interested in Signal seem much more prone to be using F-Droid than, say, WhatsApp users. Signal tries to be an app accessible to the common person, but few people really use it or see the need… and often they are free software enthusiasts or people who are fed up with Google and surveillance.

                                                                                                                                                                                                1. 1

                                                                                                                                                                                                  More likely sure, but that doesn’t mean that many of them reach the threshold of effort that they do.

                                                                                                                                                                                                2. 0

                                                                                                                                                                                                  Ossification of a decentralized protocol.

                                                                                                                                                                                                  IRC isn’t decentralised… it’s not even federated

                                                                                                                                                                                                  1. 3

                                                                                                                                                                                                    Sure it is, it’s just that there are multiple federations.

                                                                                                                                                                                                1. 2

                                                                                                                                                                                                  If it would have been Google, would people react the same way? I feel there’s a constant hanger around Microsoft, that is generally localized around its OS, but the Azure teams and this acquisition is showing great advances for Microsoft and hopefully a better future for everyone!

                                                                                                                                                                                                  1. 2

                                                                                                                                                                                                    I think people would be much more upset if it had been Google, but really both companies have historically short attention spans.

                                                                                                                                                                                                    The problem is that products which would be great successes if run as independent entities are frequently seen as distractions or failures inside large corporations like Google or Microsoft. And if they do decide to maintain an acquired product, the amount of value they need to juice from it is dramatically higher than would be needed by an independent org.