1.  

    For some reason I have never liked the look and feel of SQL. I think functional style filter(select(db,'all'), filter-function ... makes more sense to me.

    1.  

      Interesting. I always found that the nesting was one of the worst examples of functional style to the extent that people devised additional mechanisms to get rid of it.

      I’d love to have something like …

      let does = Stream.of[Person]
        .map(_.lastName)
        .accept(_ == "Doe")
      
      let orders = Stream.of[Order]
        .accept(_.price > 100)
        .map(order -> (order.name, order.price)
      
      let doesOrders: Stream[NameAndPrice] =
        does.join(orders) // Stream[(String, String, Int)]
          .on(_.lastName, _.customerLastName)
          .as[NameAndPrice] // Stream[NameAndPrice]
      

      … where you can describe the computation, and then tell it which datasource to use, e.g some database, a file-system, or an in-memory collection …

      import streams.database
      let result = doesOrders.using(databaseSession) // DB
      
      import streams.filesystem
      let result = doesOrders.using(personFile, orderFile) // filesystem
      

      … and then tell it how you want to run it and which errors to handle:

      let data: List[...] = result.run() // synchronous, blocking
      let data: List[...] = result.handling(ioErrorHandler).runOn(threadPool) // parallel, blocking, handles IO-related errors
      let data: Task[List[...]] = result.runAsync() // synchronous, blocking
      let data: Task[List[...]] =result.runAsyncOn(threadPool) // parallel, blocking
      ...
      
      1.  

        SQL syntax is a bit clunky as it’s from the era when computer languages were designed to look sort of like English (“COBOL style”) rather than sort of like math (“Algol style”). But my main issue with it is that the order is scrambled. The pipeline is join|where|group|having|select but the syntax is select-join-where-group-having. In functional style (e.g., Microsoft’s Linq) it reads more clearly.

      1. 3

        Yeah, this reads like “leave me alone - let me toxic and write code in PEACE!”

        Like this part:

        I have done a lot of charity work and I can see the same patterns emerge in the Open Source community: if you are successful at doing something altruistic, then there will be people who attack you. Some people masquerade as Open Source maintainers but are, in fact, mob leaders. Be careful of these people, they are abusive and their goal is dominance. Privileged members of a toxic community feel it is their moral duty to create do-not-hire lists, “call people out”, or contact employers. If they disagree with you about something, they will call you a Nazi or a troll, like a 17th century villager crying witch. I’ve not only experienced these things personally, but I’ve seen them happen to contributors from marginalised backgrounds.

        Seriously? Opening and closing it on a self congratulatory (and false alignment in victimization) doesn’t hide that sandwiched thought there.

        Also disappointed with the people on here applauding that.

        1. 10

          Wow. This verifies what the author was saying. They write a simple post advising people to be careful with how much data they share and now you are assuming that they must be a toxic horrible person for wanting privacy.

          1. 0

            Where did I say that they were precisely that?

            like: comparison used in similes. It’s not a strict equality operator in English.

          2. 4

            I don’t understand that comment but it seems especially interesting because you seem to disagree where most people here so far agree.

            Do you have examples of behavior of fommil that you object to and that you think he wants to hide? Or is your first comment more on principle? Or did I misunderstand it?

            Of course, fommil himself did not mention which witch hunts he means. Is that what you relate to with false alignment in victimization?

            What does the opening and closing on self congratulatory refer to? Why is it relevant?

            What is the applauding that you refer to?

            1. 3

              I’m very curious about what fommil is accused of doing. Witch hunts are uncommon in the general scheme of things (though people who are extremely visible get more scrutiny), so if he thinks he’s the subject of one, at the very least that indicates that he has probably exposed himself to a volatile community.

              Operating under a pseudonym is just generally a good idea – your birth name is nobody’s business, and there’s no real point in making yourself a target for the one person in a million who’s liable to take something too personally. However, open source isn’t particularly more toxic in this way than other online communities. Most open source developers are functionally anonymous even when they use their real names, since most open source projects are small enough that nobody cares.

              This guy’s painting a weird, paranoid picture: a shadowy cabal of open source developers who keep secret hiring blacklists and accuse random people of naziism. This is a pretty strange idea. Of course, on the other hand, individual people in charge of hiring decisions often will pass on folks who associate themselves with far-right radical movements on the grounds that they’re liable to produce HR problems if hired – and people who aren’t part of far-right radical movements don’t distinguish between neo-nazis and neoreactionaries any moreso than folks on the right distinguish between trotskyists and posadists. It sounds like this guy maybe associated himself with a particular far-right movement and then was surprised that people criticized him for it.

              1. 3

                This guy’s painting a weird, paranoid picture: a shadowy cabal of open source developers who keep secret hiring blacklists and accuse random people of naziism.

                It’s unfortunately not that uncommon. I have seen people comment in github threads with stuff like “Thanks for everyone posting in this thread, I know know everyone not to hire”. Also the Redis developer was accused of being almost everything recently.

                Unfortunately people always assume the worst in others and are quick to gather others on twitter to attack them.

                1. 2

                  Do people actually mean that? I’m pretty sure I’ve said something like “you’re not getting hired” as a synonym for “you’re wrong” but there’s no list. Five minutes later I couldn’t tell you who I was talking about.

                  1. 0

                    It’s very different for an individual person to decide not to hire somebody who has shown themselves to be a liability than for a shadowy cabal of powerful people to create and enforce a blacklist of people they personally dislike. The former happens all the time. The latter requires an incredible centralization of power that simply doesn’t exist in this industry.

                    1. 1

                      The latter requires an incredible centralization of power that simply doesn’t exist in this industry.

                      In individual programming communities such a centralization of power exists. Or why do you think people only speak out after abandoning their career in their former field?

                    2. 0

                      I have seen people comment in github threads with stuff like “Thanks for everyone posting in this thread, I know know everyone not to hire”.

                      I haven’t seen that , but then I’m not that active as a commentator on Github.

                      Just playing a bit of a Devil’s advocate here, if I as a person in a hiring position saw a lot of comments that were off-topic, demeaning, or simply rude, I might come to the perhaps reasonable conclusion that such a person was a poor fit for my organization.

                      Now, publicly posting that would be unprofessional. But on the internet, no-one knows if you’re a dog, or an HR manager.

                    3. 2

                      This guy’s painting a weird, paranoid picture: a shadowy cabal of open source developers who keep secret hiring blacklists and accuse random people of naziism.

                      It would be great if it was just imagination, but it’s sad reality in Scala.

                      It sounds like this guy maybe associated himself with a particular far-right movement and then was surprised that people criticized him for it.

                      He didn’t. People (including the people who banned him from various Scala dev channels) still haven’t found a reason to justify the ban.

                      From my perspective, the only crime he committed was having unapproved technical opinions.

                      1. 1

                        OK, this is providing some much-needed context.

                        Still, “an op banned me without cause from a particular irc channel” is a very different claim than “there is a conspiracy to blacklist people from employment”. The essay does not make the former claim, but does make the latter claim.

                        People get banned from irc channels all the time, even for bad reasons. Ops that can’t justify their bans sometimes get replaced, if the channel owner cares enough. Luckily, access to an irc channel doesn’t prevent you from contributing to a project (or forking it, or contributing to any other project).

                        Furthermore, even the claim “scala maintainers pressure employers not to hire particular developers” is very far from “the open source community pressures employers not to hire particular developers”. Being on a scala developer’s shit list is no doubt a great asset in some people’s eyes. Scala is a tiny corner of open source, and mostly irrelevant to the non-JVM world.

                        1. 1

                          Still, “an op banned me without cause from a particular irc channel” is a very different claim than “there is a conspiracy to blacklist people from employment”. The essay does not make the former claim, but does make the latter claim.

                          Both happened, I’m not providing context, I’m adding to the list of things that happened.

                          People get banned from irc channels all the time, even for bad reasons. Ops that can’t justify their bans sometimes get replaced, if the channel owner cares enough.

                          I think what makes people unhappy is the hypocrisy of “we ban you for CoC violations, but we can’t actually find a single one”. If the sole purpose of a CoC is to hide behind it, abdicate any personal responsibility and use it to ban people who disagree with “the channel owner” … that’s just giving CoC’s a really bad name.

                          Furthermore, even the claim “scala maintainers pressure employers not to hire particular developers” is very far from “the open source community pressures employers not to hire particular developers”.

                          I think writing nasty mails to contributors’ workplaces is not ok. Feel free to disagree.

                          1. 2

                            I think writing nasty mails to contributors’ workplaces is not ok.

                            That isn’t what he’s claiming in the essay. He’s claiming that the open source community is full of people contributing to a wide-scale blacklisting effort.

                            The scala developers are not the open source community. All of scala development could be composed of 100% evil lizard-people from zeta reticuli who want to eat our babies, and it that wouldn’t say anything at all about open source.

                            Rather than explain a bad experience with a handful of particular people, he’s making sweeping claims about millions of people who have never heard of him. If he’s going to make those claims, I’m interested in his justification for the scope.

                            1. 1

                              His comments are largely based on the experiences he made in Scala. He even says that things might be better elsewhere.

                              1. 2

                                He mentions Scala once, in the last paragraph of the article, in the process of saying that he worries that the Haskell community will be no better. He says “open source” nine times, including in the title. At the very least, this is misleading to someone not already embedded in Scala community drama (and therefore missing the context).

                                I absolutely agree that keeping yourself pseudonymous is a good idea. His experience with Scala maintainers isn’t common enough to justify claiming that open source is particularly toxic – his argument becomes stronger when he doesn’t include references to it at all.

                1. 11

                  On one hand, I don’t particularly find the Linux code particularly pleasant to work on, so I probably wouldn’t be contributing in my spare time regardless.

                  On the other hand, I think that this reduces the chance that I’ll send any patches in the future; I find these “welcoming” cultures make me feel less at ease, for whatever reason, which is a second strike against my involvement.

                  For me, the code reviews I got from Theo were a highlight of sending in patches to OpenBSD.

                  In the end, it doesn’t matter much – not everything needs to be for everybody, and the Linux community isn’t run for for me. This will bring some people in, push others out, and the world will go on.

                  1. 7

                    True. I’m also concerned that code quality (and therefore users) will suffer.

                    1. 21

                      Why? Do you truly believe that it is impossible to reject bad patches without telling someone that they should be “retroactively aborted”?

                      1. -5

                        Language as harsh as that is used daily in normal speech between developers. I’ve seen much worse slack channels in terms of use of language, and you wouldn’t believe the language I’ve seen used on IRC to describe bad code.

                        I do indeed think that if you start censoring peoples’ language they’re going to change the way they contribute for the worse. If all you did was ban the absolute worst things like that, nobody would complain. But the reality is that’s not what will happen. Anything ‘offensive’ will be banned. Offensiveness is completely subjective.

                        1. 18

                          Language as harsh as that is used daily in normal speech between developers

                          That’s a rash generalisation. At none of the places I’ve worked as a developer would that sort of language be acceptable.

                          Offensiveness is completely subjective

                          That’s also untrue. While there will be grey areas, there are some things that are objectively offensive if interpreted literally - and if they’re not meant literally, why not use another expression?

                          1. 3

                            I’m going to guess you’re an American, correct me if I’m wrong. EDIT: stand corrected

                            The American cultural norm of ‘compliment sandwiches’ and being obsequiously polite is cancer to the ears of most people that aren’t Americans. I find it quite funny that Americans have this idea of Japanese as being very polite culturally, while Americans are insanely polite culturally compared to most other English-speaking countries.

                            The typical British, Australian or Kiwi software developer swears like a trooper. It’s not uncommon, it’s not offensive. You wouldn’t do it in an email, but this is the key point: my emails are not Linus’s emails. The context is different. All his communication is by email, so naturally email carries a much lower average level of formality.

                            That’s also untrue. While there will be grey areas, there are some things that are objectively offensive if interpreted literally - and if they’re not meant literally, why not use another expression?

                            I don’t even know how to respond to this. Why would one only ever say things you mean literally? Speaking entirely literally is something I would expect of someone with extreme levels of Asperger’s syndrome, I believe it’s a common symptom.

                            1. 9

                              I’m going to guess you’re an American, correct me if I’m wrong

                              The typical British, Australian or Kiwi software developer swears like a trooper

                              You are wrong; I’m Australian, currently working in England, and I disagree. Regardless, swearing by itself is not something that I find offensive.

                              Why would one only ever say things you mean literally?

                              That’s not what I suggested. If you have a choice between a highly offensive figurative or metaphorical expression and some other expression - whether literal or also figurative - which is not highly offensive, why go for the former?

                              1. 2

                                You are wrong; I’m Australian, currently working in England, and I disagree. Regardless, swearing by itself is not something that I find offensive.

                                I see

                                That’s not what I suggested.

                                I must have misinterpreted you. Sorry.

                                If you have a choice between a highly offensive figurative or metaphorical expression and some other expression - whether literal or also figurative - which is not highly offensive, why go for the former?

                                People say things that others find offensive, sometimes on purpose and sometimes not. Offensiveness is subjective. I genuinely don’t think I’ve ever been offended. Why go for one expression over another knowing that someone will get their knickers in a twist over it? Because you don’t care if someone finds it offensive? Because you enjoy it?

                                I have to admit that I actually quite enjoy knowing that someone got self-righteously offended over something I’ve said. It hasn’t happened too often, but when it does it’s just great.

                                EDIT: to be clear, there is ‘offensiveness’ that I don’t like. If someone is racist, I’m not offended, I just think that being racist is wrong and stupid and that they are wrong and stupid. I guess you could call this ‘offense’ but it’s really not the same thing.

                                1. 5

                                  Why go for one expression over another knowing that someone will get their knickers in a twist over it? Because you don’t care if someone finds it offensive? Because you enjoy it?

                                  I was not intending for you to provide an answer for the “why” - it was a rhetorical question. The point was that I do not think you should say something that may well offend someone, when there is a way to communicate without doing so.

                                  Offensiveness is subjective. I genuinely don’t think I’ve ever been offended

                                  I suspect this is why you’re having difficulty seeing the problem, and while I envy you never having experienced the feeling of being offended I can see that this could lead to lack of empathy for those who were.

                                  Maybe you wouldn’t get offended by something, but that doesn’t mean it’s “not offensive” per se. I don’t agree that offensiveness is entirely subjective. Implying (or stating directly) that someone is stupid in communication to them, for example, is generally considered offensive. Statements can be intended to cause offense. There may be disagreement on specific cases, but I think in general that there would be good agreement in a survey of a random portion of the population that certain statements were offensive.

                                  1. 1

                                    I think the reality is that I would be closest to feeling hurt or offended by someone calling me stupid if I really had done something stupid. I’ve been called stupid when I haven’t been stupid many times, doesn’t bother me. I’ve been called stupid when I really have been stupid, and it does indeed make you feel bad.

                                    I’ll acknowledge that the best way to deal with some bad code getting into the Linux kernel isn’t to make the person that wrote it feel bad.

                              2. 4

                                The typical British, Australian or Kiwi software developer swears like a trooper.

                                As a kiwi, I have not had this experience at all, quite the opposite. Everyone I work with is polite and respectful. This is just my experience, but I’m very surprised by your comment.

                                it’s not offensive

                                Sure, if it’s just swearing in general (though I’d still prefer to keep it to a minimum). The problem is when it becomes personal. Your argument is that people use ‘language just as harsh is used daily’, but there’s a line between bad language and abusive language. I don’t think the latter should be acceptable in a professional environment (at least one I’d want to work in). You can’t use one to justify the other.

                                1. 2

                                  The typical British, Australian or Kiwi software developer swears like a trooper. It’s not uncommon, it’s not offensive.

                                  I work in software development in the UK and many of Linus’ comments would be seen as completely unprofessional in either emails or conversation - certainly far past the bar where HR would get involved. There’s a massive gap between swearing and direct personal insults.

                          2. 20

                            I am honestly at a loss to see who abiding to a bland CoC could lead to code quality suffering.

                            Nothing in the CoC that I have read is in any way unremarkable. It’s simply normal professional behavior codified, with some additions to address the peculiarities of mostly online communications.

                            1. 5

                              It’s simply normal professional behavior codified.

                              That ship has sailed, but I am not convinced Open Source should be held to the standards of “professional behavior”. For instance, should we stop accepting underage contributors? What about anonymous or pseudonymous contributions?

                              Moreover what constitutes “professional behavior” differs wildly between countries and even companies within countries. For instance, “don’t ask don’t tell”-style policies are still the norm at some workplaces; do we want that in our communities? Or should we just accept that the average (non-Trump voter) U.S. sentiment should be the norm in Open Source?

                              Regarding Linus, he does (did?) have a very strong way of reacting when people disregarded things that he considered important principles of the kernel such as “do not break userspace”. He isn’t shy to use strong language to criticize companies either :)

                              Whether this has a positive or a negative effect is hard to say. It certainly antagonizes some people, and especially some potential new contributors, but at the scale of Linux should that still be the main concern of the project?

                              In any case Linus knows he reacts too strongly too fast already. This is not the first time he says something like that. We should wait and judge the long-term effects in a few months or years.

                              1. 12

                                Treating people professionally does not imply employment. A proprietor of a store treats a customer professionally by not insulting them, or refusing service. A teacher treats a student professionally by not verbally denigrating them, for example. A maintainer of an open source project treats bug reports professionally by attempting to reproduce them and applying a fix, even though the submitter of the issue may as well be anonymous.

                                It’s basically the 21st century formulation of the Categorical Imperative, as far as I am concerned.

                            2. 14

                              No one said you have to be an asshole when being firm about rejecting patches.

                              1. -1

                                A lot of people will interpret anything firm as being an arsehole. If you don’t put smiley faces at the end of every sentence, some people will interpret it as you being an arsehole. If you don’t couch every negative thing you say between two positive things, people will react very aggressively.

                                1. 16

                                  But saying someone should be “retroactively aborted” for some bad code?

                                  1. 10

                                    If you don’t put smiley faces at the end of every sentence, some people will interpret it as you being an arsehole. If you don’t couch every negative thing you say between two positive things, people will react very aggressively.

                                    This sounds like a very broad generalization to me.

                                2. 22

                                  I think there’s no causal link between “being nicer when responding to patches” and code quality going down. If anything I’d suspect the opposite; you get people who learn and improve rather than giving up after feeling insulted, and then continue to submit quality improvements.

                                  1. 3

                                    Linus Torvalds is nearly always nice when responding to patches. In 0.001% of emails he’s rude. Unfortunately he sends a lot of emails, and people cherry-pick the worst of the worst.

                                    1. 20

                                      His own apology and admission of a problem would indicate that the issue is significant. That “0.001%” is a made-up number, isn’t it? While I’m sure that only a small number of his emails are insulting, that small number still has - and has had - a detrimental effect on the mind-state of other developers. This is what’s come out of a discussion between Linus and a number of developers.

                                      Don’t get me wrong, I like Linus generally (not that I know him personally) and I think he does a great job in general, but it’s clear that this personality problem has been a growing problem. A number of people - even quite prominent developers - have left the kernel development arena because of this kind of behaviour from Linus and others and/or issues around it.

                                      I think this is a great step on Linus’ behalf, it must have been hard to make the admissions that he has and it’s a sign that things really could be better going forward.

                                      1. 4

                                        His own apology and admission of a problem would indicate that the issue is significant.

                                        I disagree. I think the issue is massively overblown and that he’s been worn down by the endless bullshit about something that really isn’t an issue.

                                        That “0.001%” is a made-up number, isn’t it?

                                        If you’d like to go do sentiment analysis on every LKML email he’s sent, be my guest. I’d love to see the real numbers. But I chose the number to make a point: it’s a vanishingly small number of emails. It’s about half a dozen well known rude emails over two decades or more. They’re really not that bad taken in the context of the number of emails he sends and the context in which he sends them. He doesn’t say ‘this code is shit’ out loud to his coworker and then send a nice polite email. The LKML is the entire communication layer for all of Linux kernel development (plus the other lists of course). The context of those emails includes a lot more than what you’d normally include in emails in a normal development environment.

                                        While I’m sure that only a small number of his emails are insulting, that small number still has - and has had - a detrimental effect on the mind-state of other developers. This is what’s come out of a discussion between Linus and a number of developers.

                                        I mean frankly I think that if someone is going to be detrimentally affected by a few emails they are no great loss. I’ve seen a few people that say things like ‘I’d never contribute to Linux even if that were in my skill set, because they’re always rude to new people’ and then cite Linus’s emails as evidence of this. I’ve seen that sort of comment a lot. Dozens of times on /r/linux, dozens of times on /r/programming, many times on HN. It’s rubbish! The LKML isn’t obsequious: the email culture there is the traditional techy one of saying what you need to say straightforwardly rather than the traditional corporate one of layering everything in sugar to avoid sounding rude to people that expect every criticism to be wrapped in three layers of compliments.

                                        The LKML is especially not rude to newcomers. Linus has been rude, in the past, sure, but only to people that are expected to know better. Long term, hardcore maintainers that have been around for years. Is it okay? No, but it’s not anything to get worked up about. It’s a really really minor issue.

                                        There are way bigger issues in Linux kernel development, like the really scary amount of control and input some companies have in its development.

                                        Don’t get me wrong, I like Linus generally (not that I know him personally) and I think he does a great job in general, but it’s clear that this personality problem has been a growing problem. A number of people - even quite prominent developers - have left the kernel development arena because of this kind of behaviour from Linus and others and/or issues around it.

                                        They probably would have left anyway. People don’t change careers because someone said ‘retroactively aborted’ in an email once.

                                3. 8

                                  funny, I almost avoided a potential security report to OpenBSD because I saw the contact is theo. I didn’t want to get flamed.

                                1. 4

                                  Surely I’m not going to be the only one expecting a comparison here between go’s. I’m not really well versed in GC but this appears to mirror go’s quite heavily.

                                  1. 12

                                    It’s compacting and generational, so that’s a pair of very large differences.

                                    1. 1

                                      My understanding, and I can’t find a link handy, is that the Go team is on a long term path to change their internals to allow for compacting and generational gc. There was something about the Azul guys advising them a year+ ago iirc.

                                      Edit; I’m not sure what the current status is, haven’t been following, but see this from 2012, look for Gil Tene comments:

                                      https://groups.google.com/forum/#!topic/golang-dev/GvA0DaCI2BU

                                      1. 3

                                        This presentation from this July suggests they’re averse to taking almost any regressions now even if they get good GC throughput out of it. rlh tried freeing garbage at thread (goroutine) exit if the memory wasn’t reachable from another thread at any point, which seemed promising to me but didn’t pan out. aclements did some very clever experiments with fast cryptographic hashing of pointers to allow new tradeoffs, but rlh even seemed doubtful the prospects of that approach in the long term.

                                        Compacting is a yet harder sell because they don’t want a read barrier and objects moving might make life harder for cgo users.

                                        Does seem likely we’ll see more work on more reliably meeting folks’ current expectations, like by fixing situations where it’s hard to stop a thread in a tight loop, and we’ll probably see work on reducing garbage through escape analysis, either directly or by doing better at other stuff like inlining. I said more in my long comment, but I suspect Java and Go have gone on sufficiently different paths they might not come back that close together. I could be wrong; things are interesting that way!

                                        1. 1

                                          Might be. I’m just going on what I know about the collector’s current state.

                                      2. 9

                                        Other comments get at it, but the two are very different internally. Java GCs have been generational, meaning they can collect common short-lived garbage without looking at every live pointer in the heap, and compacting, meaning they pack together live data, which helps them achieve quick allocation and locality that can help processor caches work effectively.

                                        ZGC is trying to maintain all of that and not pause the app much. Concurrent compacting GCs are hard because you can’t normally atomically update all the pointers to an object at once. To deal with that you need a read barrier or load barrier, something that happens when the app reads a pointer to make sure that it ends up reading the object from the right place. Sometimes (like in Azul C4 I think) this is done with memory-mapping tricks; in ZGC it looks like they do it by checking a few bits in each pointer they read. Anyway, keeping an app running while you move its data out from under it, without slowing it down a lot, is no easier than it sounds. (To the side, generational collectors don’t have to be compacting, but most are. WebKit’s Riptide is an interesting example of the tradeoffs of non-compacting generational.)

                                        In Go all collections are full collections (not generational) and no heap compaction happens. So Go’s average GC cycle will do more work than a typical Java collector’s average cycle would in an app that allocates equally heavily and has short-lived garbage. Go is by all accounts good at keeping that work in the background. While not tackling generational, they’ve reduced the GC pauses to more or less synchronization points, under 1ms if all the threads of your app can be paused promptly (and they’re interested in making it possible to pause currently-uncooperative threads).

                                        What Go does have going for it throughput-wise is that the language and tooling make it easier to allocate less, similar to what Coda’s comment said. Java is heavy on references to heap-allocated objects, and it uses indirect calls (virtual method calls) all over the place that make cross-function escape analysis hard (though JVMs still manage to do some, because the JIT can watch the app running and notice that an indirect call’s destination is predictable). Go’s defaults are flipped from that, and existing perf-sensitive Go code is already written with the assumption that allocations are kind of expensive. The presentation ngrilly linked to from one of the Go GC people suggests at a minimum the Go team really doesn’t want to accept any regressions for low-garbage code to get generational-type throughput improvements. I suspect the languages and communities have gone down sufficiently divergent paths about memory and GC that they’re not that likely to come together now, but I could be surprised.

                                        1. 1

                                          One question that I don’t have a good feeling for is: could Go offer something like what the JVM has, where there are several distinct garbage collectors with different performance characteristics (high throughput vs. low latency)? I know simplicity has been a selling point, but like Coda said, the abundance of options is fine if you have a really solid default.

                                          1. 1

                                            Doubtful they’ll have the user choose; they talk pretty proudly about not offering many knobs.

                                            One thing Rick Hudson noted in the presentation (worth reading if you’re this deep in) is that if Austin’s clever pointer-hashing-at-GC-time trick works for some programs, the runtime could choose between using it or not based on how well it’s working out on the current workload. (Which it couldn’t easily do if, like, changing GCs meant compiling in different barrier code.) He doesn’t exactly suggest that they’re going to do it, just notes they could.

                                          2. 1

                                            This is fantastic! Exactly what I was hoping for!

                                          3. 3

                                            There are decades of research and engineering efforts that put Go’s GC and Hotspot apart.

                                            Go’s GC is a nice introductory project, Hotspot is the real deal.

                                            1. 3

                                              Go’s GC designers are not newbies either and have decades of experience: https://blog.golang.org/ismmkeynote

                                              1. 1

                                                Google seems to be the nursing home of many people that had one lucky idea 20 years ago and are content with riding on their fame til retirement, so “famous person X works on it” has not much meaning when associated with Google.

                                                The Train GC was quite interesting at its time, but the “invention” of stack maps is just like the “invention” of UTF-8 … if it hadn’t been “invented” by random person A, it would have been invented by random person B a few weeks/months later.

                                                Taking everything together, I’m rather unconvinced that Go’s GC will even remotely approach G1, ZGC’s, Shenandoah’s level of sophistication any time soon.

                                              2. 3

                                                For me it is kind of amusing that huge amounts of research and development went into the Hotspot GC but on the other hand there seem to be no sensible defaults because there is often the need to hand tune its parameters. In Go I don’t have to jump through those hoops, and I’m not advised to, but still get very good performance characteristics, at least comparable to (in my humble opinion even better) than for a lot of Java applications.

                                                1. 12

                                                  On the contrary, most Java applications don’t need to be tuned and the default GC ergonomics are just fine. For the G1 collector (introduced in 2009 a few months before Go and made the default a year ago), setting the JVM’s heap size is enough for pretty much all workloads except for those which have always been challenging for garbage collected languages—large, dense reference graphs.

                                                  The advantages Go has for those workloads are non-scalar value types and excellent tooling for optimizing memory allocation, not a magic garbage collector.

                                                  (Also, to clarify — HotSpot is generally used to refer to Oracle’s JIT VM, not its garbage collection architecture.)

                                                  1. 1

                                                    Thank you for the clarification.

                                              3. 2

                                                I had the same impression while reading the article, although I also don’t know that much about GC.

                                              1. 5

                                                So they are roughly adopting the model Maven used since … who-knows-when?

                                                1. 2

                                                  This is really cool work. I couldn’t ignore the nagging feeling, though, that the GC team is in a race against time, as people are forced to move to things like openJDK because of licensing issues. It must be frustrating as hell to work on awesome stuff and have your parent corporation undermining you as you go.

                                                  1. 9

                                                    ZGC is part of OpenJDK, isn’t it?

                                                    1. 2

                                                      I could imagine it becoming commercial-only, but I guess RedHat’s move largely prevented that.

                                                      Oracle will rather give away its own new GC than have people migrate to the GC of a different vendor, where they lack the experienced developers to fix issues.

                                                      1. 2

                                                        What RH move?

                                                        1. 5

                                                          It probably refers to Shenandoah, a GC developed by Red Hat with properties similar to ZGC.

                                                    2. 4

                                                      Correct me if I’m wrong, but I believe this is going to land in the openJDK, not only the Oracle JRE.

                                                    1. 5

                                                      And it follows the XDG spec, and doesn’t dump files into the $HOME directory!

                                                      This was fixed a while ago already, but it doesn’t hurt to mention it again, considering that most users probably don’t read the changelog for every minor version.

                                                      1. 2

                                                        Its infuriating how many programs dont do this. My home directory is a mess..

                                                        1. 1

                                                          I’m down to 7 dot-directories and 0 dot-files. Making your home directory read-only certainly helps weeding out the worst offenders, and prevents new offenders from adding to the mess.

                                                      1. 2

                                                        pico < nano < micro

                                                        1. 5

                                                          mili < vim < kilo < mega < giga < emacs

                                                          1. 2

                                                            it’s just a static binary

                                                            Erm…

                                                            $ file micro-1.4.1/micro 
                                                            micro-1.4.1/micro: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, Go BuildID=5a83ed8300296d2d29c7c21b668bda0a1db5fa7ba, stripped
                                                            

                                                            (This seems to be a common misunderstanding these days.)

                                                            1. 3

                                                              I think a lot of people use “static binary” to mean “doesn’t link against anything other than libc” now. Not that that’s correct, but it’s certainly how the Go world tends to use it, which is unfortunate.

                                                            2. -1

                                                              Not sure I want an editor to be written in Go, to be honest.

                                                              1. 3

                                                                Why not? As with the parent comment you replied to I would very much like to know why you think so. The reasoning behind a claim is often more interesting than the claim itself.

                                                                1. 1

                                                                  Some languages just come with a smell of lower quality. If something is written in a language like JavaScript, PHP or Go, I just immediately assume that the engineering standards are lower then some alternative written in e. g. Rust, F#, Haskell – or even C and C++.

                                                                  I guess some languages are just more attractive to the “worse is better” crowd, and I have become wary of the resulting software.

                                                                2. 2

                                                                  Lets be honest here, on a single user system 35kb of ram vs 1 meg of ram doesn’t change much… But given the choice one is better.

                                                                  1. 1

                                                                    Any specific reason why?

                                                                1. 6

                                                                  This paper is flogging a dead horse. There are plenty of corner cases to be tweaked, but they don’t add up to much.

                                                                  There are bigger improvements to be had by thinking bigger

                                                                  1. 2

                                                                    Your thinking bigger article is interesting. Morton encoding is cool.

                                                                    1. 2

                                                                      Interesting! Were there any programming languages which experimented with/used the Morton encoding for their arrays?

                                                                      1. 1

                                                                        It’s an implementation technique. If an array is only ever indexed (i.e., no pointers into it) the compiler can use whatever layout it chooses.

                                                                        1. 1

                                                                          I don’t see how a compiler could deduce usage patterns that would benefit from morton indexing.

                                                                      2. 1

                                                                        “There are really really big savings to be had by providing compilers with a means of controlling the processors caches, e.g., instructions to load and flush cache lines. “

                                                                        It’s true. It’s also field-proven: they’re called scratchpads. They use less circuitry and power since they’re simple, software-driven stores. However, they have to be used wisely by the compiler. Most of what market makes isn’t. So, those pushing caches over scratchpads got more sales. The scratchpads are mainly in embedded products now IIRC.

                                                                      1. 5

                                                                        I worked on cleaning up the user interface of Synaptic (the trusty package manager on Debian systems) last weekend. I might have a look at it again in the evennigs.

                                                                        Before:

                                                                        https://soc.github.io/assets/img/synaptic/synaptic-old.png

                                                                        First steps:

                                                                        https://soc.github.io/assets/img/synaptic/synaptic-new1.png

                                                                        https://soc.github.io/assets/img/synaptic/synaptic-new2.png

                                                                        Current state:

                                                                        https://user-images.githubusercontent.com/42493/45269852-2ba28c80-b495-11e8-8fdb-01a3351fb210.png

                                                                        1. 6

                                                                          I wouldn’t consider the LGPL to be a bureaucratic or a bad license. I certainly wouldn’t want to use a proprietary graphics library; nor would I want to see my contributions to a library made proprietary. The GPL & LGPL create a software commons, which is pretty awesome.

                                                                          1. 5

                                                                            This is a popular point of contention. It’s like VIM vs. Emacs. These days I release under effective public domain (I can’t place anything in real PD in my jurisdiction) because I take whatever chance I can to have other people finish or build on top of my work in any form whatsoever, and screw attribution. They’re free to add any arbitrary restrictions if it makes them happy.

                                                                            1. 3

                                                                              It’s really nothing like vim vs. emacs. Vim vs. emacs is a matter of opinion and is about personal preference. Licenses are the opposite: if you support one over another you should be able to back that up with good reasoning.

                                                                              because I take whatever chance I can to have other people finish or build on top of my work in any form whatsoever, and screw attribution. They’re free to add any arbitrary restrictions if it makes them happy.

                                                                              If you’re fine with people taking your work and using it to abuse end users that’s for your conscience to deal with and not mine, but don’t pretend that it has anything to do with how ‘bureaucratic’ a license is.

                                                                              1. 1

                                                                                Why not just do a BSD-like license since public domain isn’t a thing in some countries but it is? If public domain isn’t always recognized, then putting stuff in the public domain might go against freedom or uptake given it limits who might use the work with its uncertainty. Whereas, people see BSD or MIT, they go “Hell yeah! Nothing to worry about!”

                                                                                1. 4

                                                                                  The stress is on “effective”: 0BSD erases 1 half-sentence from the ISC license I used before.

                                                                                  1. 1

                                                                                    Ok, so it is licensed instead of just public domain. I didn’t know about that license either. Thanks for the tip!

                                                                              2. 1

                                                                                Agree. I got the impression that a lot of stupid would follow, as soon as I read this gem:

                                                                                Why C? It’s a clean, rather simple language that I’ve ‘mastered’ at one point […]

                                                                                “Mastering C” and thinking it is “a clean, rather simple language” are at opposite ends of the knowledge spectrum.

                                                                                1. 7

                                                                                  I think what the author meant is that at some point you learn enough of the C language that you’re able to read and understand 99% (maybe 100%?) of C code. The language is small enough and changing at such a slow pace that it’s possible to “master” it. I agree with the author that C is a clean and simple language perhaps made slightly dirtier with the incorporation of the preprocessor and various preprocessor macros but those are usually used sparingly.

                                                                                  1. 0

                                                                                    Then either all C developers must be trolling us with decades of security issues and crashes in their software, or describing C as “clean and simple” is an idea limited to people with the mistaken believe that they mastered the language.

                                                                                    1. 3

                                                                                      Just because a language doesn’t have facilities to reason about complex mechanisms expressively doesn’t mean it’s not simple. It’s a simple, clean, and flawed language. These things are orthogonal.

                                                                                      I think that there’s an extremely popular Unix-bias in online programming communities where all complexity is viewed as the same thing to be avoided without realizing that a lot of what you want to express is actually quite complex to express correctly.

                                                                                2. 1

                                                                                  Though the problem is Go is always statically linked, so wouldn’t the application have to be LGPL then too?

                                                                                  1. 5

                                                                                    Actually, not always. Cgo is typically used with dynamic linking, and pure Go can also link dynamically since 1.5. I haven’t experimented with it yet.

                                                                                  2. 1

                                                                                    Yeah there’s nothing at all ‘bureaucratic’ about any license. They’re all as bureaucratic as each other.

                                                                                  1. 2

                                                                                    I’m surprised how regularly this happens pretty much around every macOS version release since OSX Tiger. Last time I used such tool was to run macOS Leopart on PowerMac G4 (QuickSilver 2002) which has beep deprecated in that release. It was completely not worth that, I downgraded back to Tiger after few days, and personally I think 10.4 was the peak of macOS line (something like Windows 2000 for WinNT OSes)

                                                                                    1. 2

                                                                                      I’m sometimes impressed with the effort some people put into making proprietary software work.

                                                                                      If having an operating system with long-term maintenance, regular updates and without planned obsolescence is important, why don’t they pick an appropriate Linux distribution of their choice?

                                                                                      That additional 30%+ performance boost of replacing macOS with Linux might especially help with older hardware.

                                                                                      1. 4

                                                                                        Because the operating system is just the enabling technology for the software that runs on top of it?

                                                                                    1. 6

                                                                                      … and yet another language realizing that spending all its bracket budget on luxuries like array syntax backfires spectacularly.

                                                                                      The first rule of language design should be: “You got 4 pairs of brackets, (), {}, [] and <>. Use them wisely – once they are spent, they are pretty much gone forever.”

                                                                                      I’m all for generics, but the draft syntax coupled with Go’s ident Type syntax turns the code into a one-letter alphabet soup.

                                                                                      1. 2

                                                                                        Dare we resort to 「」 and 『』?

                                                                                        No. ;)

                                                                                        1. 1

                                                                                          I like it. Why should type parameters use a totally different syntax to normal parameters? They’re not really that different. From the sounds of it, they’re going to be able to be dispatched at runtime sometimes anyway (a bit like how in Go objects will be heap allocated if you return pointers to them but stack-allocated otherwise, I guess).

                                                                                          Also I’m firmly of the opinion that lists are waaay more important to programming than types.

                                                                                          1. 2

                                                                                            Why should type parameters use a totally different syntax to normal parameters?

                                                                                            Because they are completely different. If you want to turn Go into a dependently-typed language where the difference between types and terms ceased to exist, go ahead, but until then, types and terms are fundamentally different and should receive different syntax (especially because you can often infer the types), so it’s important to see which one of the parameter lists was left out.

                                                                                        1. 1

                                                                                          My experience in Myrddin makes me think that you don’t actually need syntax to instantiate or specify generics. You just need a syntax for a ‘type parameter’, and let type inference unify for you. So, for example, a generic sort function in Myrddin looks like:

                                                                                           generic sort : (a : @t[:], cmp : (a : @t, b : @t -> std.order) -> void)
                                                                                          

                                                                                          If Go were to adopt the same sort of syntax, where @a represents a type parameter, it might look like:

                                                                                           func Sort(a []@t, cmp func(a @t, b @t) int) { ... }
                                                                                          

                                                                                          To invoke it, you just call it with the value:

                                                                                           Sort(myArray, myCmpFunc)
                                                                                          

                                                                                          There’s some design needed around how constraints work – my first attempt in Myrddin directly attached them to the type, which made a few things syntactically impossible, specifically specifying auxiliary types, but I think that’s more surmountable than trying to make explicit instantiation pretty.

                                                                                          1. 2

                                                                                            Sometimes specifying the types at the instantiation site also serves readability purposes for the next developer coming along.

                                                                                            1. 1

                                                                                              But the types for these function calls are just as strongly specified as any other function call: ‘a slice of @t’ isn’t fundamentally different from ‘a slice of int’, beyond code generation concerns.

                                                                                          1. [Comment removed by author]

                                                                                            1. 5

                                                                                              Official Rust support for the FlatBuffers serialization format

                                                                                              Wrong thread mate

                                                                                              1. 3

                                                                                                Haha, thanks mate!

                                                                                            1. 1

                                                                                              I get that mental illness gives old mate a pass on the racist diatribes, but most of those “features” are really bad ideas.

                                                                                              1. 7

                                                                                                As the article put it:

                                                                                                Don’t write things off just because they have big flaws.

                                                                                                That said, would you please expand on why most of the features are really bad ideas?

                                                                                                1. 11

                                                                                                  I may be the only user of my computer, but I still appreciate memory protection.

                                                                                                  1. 5

                                                                                                    More to the point: Practically every, if not every, security feature is also an anti-footbullet feature. Memory protection protects my data from other people on the system and allows security contexts to be enforced, and it protects my data from one of my own programs going wrong and trying to erase everything it can address. Disk file protections protect my data from other users and partially-trusted processes, and ensure my own code can’t erase vital system files in the normal course of operation. That isn’t even getting into how memory protection interacts with protecting peripheral hardware.

                                                                                                    Sufficiently advanced stupidity is indistinguishable from malice.

                                                                                                    1. 15

                                                                                                      But that’s not really the point of TempleOS, is it?

                                                                                                      As Terry once mentioned, TempleOS is a motorbike. If you lean over too far you fall off. Don’t do that. There is no anti-footbullet features because that’s the point.

                                                                                                      Beside that, TOS still has some features lacking in other OS. Severely lacking.

                                                                                                      1. 1

                                                                                                        Beside that, TOS still has some features lacking in other OS. Severely lacking.

                                                                                                        Like?

                                                                                                        1. 12

                                                                                                          The shell being not purely text but actual hypertext with images is lacking in most other os by default and I would love to have that.

                                                                                                          1. 6

                                                                                                            If you’ve never played with Oberon or one of its descendant systems, or with Acme (inspired by Oberon) from Rob Pike, you should give it/them a try.

                                                                                                            1. 0

                                                                                                              If you start adding images and complex formatting in to the terminal then you lose the ability to pipe programs and run text processing tools on them.

                                                                                                              1. 13

                                                                                                                Only because Unix can’t comprehend with the idea of anything other than bags of bytes that unformatted text happens to be congruent with.

                                                                                                                1. 4

                                                                                                                  I have never seen program composition of guis. The power of text is how simple it is to manipulate and understand with simple tools. If a tool gives you a list of numbers its very easy to process. If the tool gives you those numbers in a picture of a pie chart then it’s next to impossible to do stuff with that.

                                                                                                                  1. 7

                                                                                                                    Program composition of GUIs is certainly possible – the Alto had it. It’s uncommon in UNIX-derived systems and in proprietary end-user-oriented systems.

                                                                                                                    One can make the argument that the kind of pipelining of complex structured objects familiar from notebook interfaces & powershell is as well-suited to GUI composability as message-passing is (although I prefer message-passing for this purpose since explicit nominal typing associated with this kind of OO slows down iterative exploration).

                                                                                                                    A pie chart isn’t an image, after all – a pie chart is a list of numbers with some metadata that indicates how to render those numbers. The only real reason UNIX doesn’t have good support for rich data piping is that it’s hard to add support to standard tools decades later without breaking existing code (one of the reasons why plan9 is not fully UNIX compatible – it exposes structures that can’t be easily handled by existing tools, like union filesystems with multiple files of the same name, and then requires basically out-of-band disambiguation). Attempts to add extra information to text streams in UNIX tools exist, though (often as extra control sequences).

                                                                                                                    1. 3

                                                                                                                      Have a look at PowerShell.

                                                                                                                      1. 3

                                                                                                                        I have never seen program composition of guis. The power of text is how simple it is to manipulate and understand with simple tools. If a tool gives you a list of numbers its very easy to process. If the tool gives you those numbers in a picture of a pie chart then it’s next to impossible to do stuff with that.

                                                                                                                        Then, respectfully, you need to get out more :) Calvin pointed out one excellent example, but there are others.

                                                                                                                        Smalltalk / Squeak springs to mind.

                                                                                                                        1. 2

                                                                                                                          Certainly the data of the pie chart has to be structured with such metadata that you can pipe it to a tool which extracts the numbers. Maybe even manipulates them and returns a new pie chart.

                                                                                                                      2. 3

                                                                                                                        You don’t loose that ability considering such data would likely still have to be passed around in a pipe. All that changes is that your shell is now capable of understanding hypertext instead of normal text.

                                                                                                                        1. 1

                                                                                                                          I could easily imagine a command shell based on S-expressions rather than text which enabled one to pipe typed data (to include images) easily from program to program.

                                                                                                                    2. 1

                                                                                                                      But why do I want that? It takes me 30 seconds to change permissions on /dev/mem such that I too can ride a motorbike without a helmet.

                                                                                                                      1. 2

                                                                                                                        That is completely beside the point. A better question is how long would it take you to implement an operating system from scratch, by yourself, for yourself. When you look at it that way, of course he left some things out. Maybe those things just weren’t as interesting to him.

                                                                                                                        1. 1

                                                                                                                          You could do that, but in TOS that’s the default. Defaults matter a lot.

                                                                                                                          1. 2

                                                                                                                            /dev/mem more or less world accessible was also the default for a particular smartphone vendor I did a security audit for.

                                                                                                                            Defaults do matter a lot…

                                                                                                                      2. 8

                                                                                                                        If there are no other users, and it takes only a second or two to reload the OS, what’s the harm?

                                                                                                                        1. 6

                                                                                                                          Its fine for a toy OS but I dont want to be working on real tasks where a bug in one program could wipe out everything I’m working on or corrupt it silently.

                                                                                                                          1. 11

                                                                                                                            I don’t think TempleOS has been advertised as anything other than a toy OS. All this discussion of “but identity mapped ring 0!” seems pretty silly in context. It’s not designed to meet POSIX guidelines, it’s designed to turn your x86_64 into a Commodore.

                                                                                                                    3. 2

                                                                                                                      Don’t write things off just because they have big flaws.

                                                                                                                      That’s pretty much the one and only reason where you would want to write things off.

                                                                                                                      1. 14

                                                                                                                        There’s a difference between writing something off based on it having no redeeming qualities and writing something off because it’s a mixed bag. TempleOS is a mixed bag – it is flawed in a generally-interesting way. (This is preferable to yet another UNIX, which is flawed in the same boring ways as every other UNIX.)

                                                                                                                    4. 2

                                                                                                                      This is probably not what you meant to imply, but nobody else said it, so just to be clear: Mental illness and racism aren’t correlated.

                                                                                                                      1. 2

                                                                                                                        Whatever is broken inside somebody to make them think the CIA is conspiring against them, I find it hard to believe that same fault couldn’t easily make somebody think redheads are conspiring against them.

                                                                                                                        1. 2

                                                                                                                          You’re oversimplifying. There are many schizophrenic people in the U.S., and most of them are not racist. Compulsions, even schizophrenic ones, don’t come from the ether, and they’re not correlated with any particular mental illness. Also, terry’s compulsions went far beyond paranoia.

                                                                                                                    1. 4

                                                                                                                      I’m guessing that Google kept most of those tools they built for making JS usable private so they never ended up becoming what we all use today and instead others have reinvented all of it.

                                                                                                                      1. 2

                                                                                                                        Closure Compiler is totally an alternate-history TypeScript. It’s a pleasure to use if you get it set up right.

                                                                                                                        1. 2

                                                                                                                          They published a lot of them but at the time they were working with much bigger and weirder codebases than the rest of the industry.

                                                                                                                          1. 0

                                                                                                                            I wish they had done the same with MapReduce, Dart and Go …

                                                                                                                            1. 2

                                                                                                                              Why?

                                                                                                                              1. 1

                                                                                                                                Something with more technical merit could have taken their place.

                                                                                                                              2. 2

                                                                                                                                Better to help other tools than hate on ones you dislike.

                                                                                                                                1. 1

                                                                                                                                  And that’s what I did in the past. But the thing is, if you write software to have some amount of users, adoption matters, and adoption rarely follows quality.

                                                                                                                                  You could have written something 10 times better than what Google published, and everyone would still flock to Google’s software. Technical merit << Google name-drop.

                                                                                                                                  1. 1

                                                                                                                                    I tend to look at things like that as a competitive edge for myself.

                                                                                                                            1. 1

                                                                                                                              The technology in upcoming Firefox versions looks increasingly great.

                                                                                                                              I would switch back in a heart beat if it wasn’t for the lack of vertical tabs. But it seems like Chrome is working on them, so Firefox might add them too.

                                                                                                                              1. 5

                                                                                                                                There are several add-ons for vertical tabs in Firefox, including Tab Center Redux and Tree Style Tab.

                                                                                                                                1. 2

                                                                                                                                  Yes, I left Firefox after more than 15 years of usage after seeing these abominations. If these are the best option Mozilla allows, I’ll look elsewhere for a browser.

                                                                                                                                  1. 1

                                                                                                                                    Which browser have you found that has vertical tabs done better?

                                                                                                                                    1. 1

                                                                                                                                      I’m pretty happy with Vivaldi (it’s one of the first questions they ask on first startup – where the tabs should be placed). Here is how it looks: https://i.imgur.com/DzoJ8d9.png

                                                                                                                                    2. 1

                                                                                                                                      Haha, well, to each their own… I happily use Tree Style Tab everyday myself. I am not sure how to browse the web without it anymore… (All of these add-ons have been (re)implemented to use WebExtension APIs that isolate the browser and add-ons from each other in the last year or so… perhaps they are quite different from the last time you checked them, depending on when that was.)

                                                                                                                                      1. 1

                                                                                                                                        Yeah, I used Tree Style Tabs, too. Since Mozilla broke the old APIs without replacement, all the reimplemented extensions are an utter disappointment.

                                                                                                                                        I looked at different extensions right now, and I love how all extension authors carefully crop their screenshots to hide the fact that they can’t get rid of

                                                                                                                                        • the horizontal tab bar
                                                                                                                                        • the sidebar header

                                                                                                                                        thanks to Mozilla’s “mom knows best!” approach, which makes their extensions rather pointless.

                                                                                                                                        I’m so glad Mozilla isn’t in charge of an IDE/editor, because otherwise we all could start preparing to develop without syntax highlighting, because “Mozilla UX team decided it’s unnecessary”.

                                                                                                                                  2. 1

                                                                                                                                    Every time I see something like this quoted as a reason to switch browsers I’m amazed how deep control-freakery is rooted in all of us :-)

                                                                                                                                    1. 1

                                                                                                                                      Stuff like mass-market browsers are designed for the lowest common denominator of user behavior.

                                                                                                                                      It shouldn’t be surprising that more and more people fall outside Mozilla’s supported use cases, as Mozilla keeps pushing “our way or the highway” on how their users have to use their browser.

                                                                                                                                    2. 1

                                                                                                                                      I have been using tree tabs which works wonderfully. Even better than what I had before the web extensions migration.

                                                                                                                                      1. 1

                                                                                                                                        Just tried it, it’s rather embarrassing due to missing APIs Mozilla removed without replacement. It is pretty much the state when I left Firefox, no improvements visible.

                                                                                                                                    1. 2

                                                                                                                                      I don’t want to act like “oh, it’s all obvious to me, because I’m so smart” … but isn’t the behavior exactly how things are supposed to work?

                                                                                                                                      If one wouldn’t be able to do 123.to_string(), then it would not work for any value type. There is nothing special about “primitives” that I can discern here.

                                                                                                                                      1. 11

                                                                                                                                        Oil is compiled with a bytecode compiler (and front end) written in Python. It’s the only program that uses this specific compiler. (I didn’t write it, but I cobbled it together and heavily refactored it, with plans to add many more features.)

                                                                                                                                        I’ve written at length about it [1] – in short the plan is to evolve Oil into a more efficient program without doing a big-bang rewrite in C or C++. I have to implement at least 2 programming languages for the Oil project – OSH and Oil, so using a high-level language helps.

                                                                                                                                        I think of Oil as being “metaprogrammed”, not programmed. There are custom compilers for DSLs like re2c and ASDL, and also some small Python code generators for things like enums, online documentation, etc.

                                                                                                                                        The latest release only has 9K significant lines of code in the core! [2] Compared to 110K significant lines of C code for bash (as measured by cloc, bash 4.4).


                                                                                                                                        The way I’ve been explaining thing to people is with an analogy TeX. TeX is actually written in an abstract subset of Pascal! The versions on your machine are not compiled using a Pascal compiler. They are translated to C and then compiled with a C compiler!

                                                                                                                                        https://news.ycombinator.com/item?id=16526151

                                                                                                                                        [1] Building Oil with the OPy Bytecode Compiler

                                                                                                                                        [2] http://www.oilshell.org/release/0.6.pre3/metrics.wwz/line-counts/oil-osh-cloc.txt

                                                                                                                                        1. 3

                                                                                                                                          TeX is actually written in an abstract subset of Pascal! The versions on your machine are not compiled using a Pascal compiler. They are translated to C and then compiled with a C compiler!

                                                                                                                                          Oh, wow, thanks for writing this! I knew about WEB, but never looked at it, or where it came from. Definitely learned something today! Thanks!