Threads for inactive-user

  1. 4

    Like someone else has pointed out, there’s a glaring lack of rust code to go with all of these descriptions. I’d like to see what writing “lunatic rust” looks like, and I can’t find it in this post, nor anywhere on the website.

    1. 14

      This reads like a puff piece. It’s an interesting project but I wouldn’t say there was a real takeaway except that you have YC funding now.

      1. 11

        Ouch; this is very unconstructive criticism.

        1. 4

          I liked the article as an experience report - you can build something Erlang-ish in Rust on wasm and end up at least convincing yourself (and YC?) that it works. I agree that the article doesn’t have a strong central thesis, but I found it interesting.

        2. 11

          Sadly I believe you’re correct, especially given the post history here.

          For folks that quibble with this dismissal as a “puff piece”: for me at least if this post had any code at all showing how the APIs changed, how this mirrored GenServers or other BEAM idioms, how various approaches like the mentioned channels approach changed the shape of could, or anything like that I wouldn’t be so dismissive. Alas, it seems like a growth-hacking attempt with lots of buzzwords (I mean christ, look at the tags here).

          Marketing spam and bad actors still exist folks.

          1. 2

            Hi friendlysock, I do mention in the post “Check out the release notes for code examples”. Here is a direct link to them: https://github.com/lunatic-solutions/rust-lib/releases/tag/v0.9.0

            1. 6

              From (successful) personal experience: you can get away with promoting your stuff if you offer people something of real value in exchange for taking their time & attention. Nobody cares what’s in your GitHub: make content that is on the page you are posting that is worth reading.

              1. 5

                Friend, your only contributions to this site have been entirely self-promotion for your Lunatic project. It’s a neat project, but you are breaking decorum and exhibiting poor manners by using us in a fashion indistinguishable from a growth hacker. Please stop.

                1. 1

                  I don’t think it’s fair to call a blog that has 3 posts in 2 years “marketing spam”. This submission is currently #1, so it’s obviously of interest to the community. But with this backlash in the comments I’m definitely going to refrain from posting in the future.

                  1. 19

                    I don’t think it’s fair to call a blog that has 3 posts in 2 years “marketing spam”.

                    In one year, as I write this comment, you have:

                    • Submitted 3 stories, all self promotion.
                    • Made 5 comments, all on stories that you submitted, promoting your own project.

                    That is not engaging with this community, that is using the community for self promotion, which is actively contrary to the community norms, and has been the reason for a ban from the site in the past.

                    This submission is currently #1, so it’s obviously of interest to the community.

                    The rankings are based on the number of votes, comments, and clicks. At the moment, all of the comments in this article are either by you, or are complaining about the submission. This will elevate the post but not in a good way.

                    But with this backlash in the comments I’m definitely going to refrain from posting in the future.

                    I would say that you have two choices:

                    1. Stop posting altogether.
                    2. Engage with the community, comment on other stories, submit things that are not just your own work.

                    The general rule of thumb that I’ve seen advocated here is that posts of your own things should make up no more than 10% of your total contributions to the site. At the moment, for you, they are 100%. If they were under 50%, you’d probably see a lot fewer claims that you were abusing lobste.rs for self promotion.

                    1. 4

                      I don’t know how to resolve the problem that this is both an interesting project but only being posted by you, and that there’s a business wrapped around it, where you’re the ‘CEO’ - which just makes it a bit awkward when people are interested in the tech but opposed to ‘spam’.

                      I’m certainly interested in following the project, so I’d prefer that you keep posting!

            1. 1

              Work: I am on call again.

              Personal: My power just went out so I’ll be reading on my Kindle until it returns.

              1. 4

                I feel like pretty much every “design pattern” is an example of an “emergent language feature”, as the author named them. Which is what I dislike about Java-style OOP.

                1. 8

                  Design patterns are descriptive, not prescriptive. Whenever objects are composed in a certain way, including composition of functions, then the corresponding design pattern describes the behavior of the composition. They don’t just emerge from languages you don’t like, but from any Turing-complete language.

                  1. 4

                    Whenever there is a pattern in your code, you should abstract it away. Some languages will allow you to do that, some won’t.

                    1. 8

                      Expressive languages still have patterns, people just refuse to call them patterns because they think expressive languages don’t have patterns.

                      1. 2

                        Can you give an example?

                        1. 3

                          If nothing else, Nim’s metaprogramming tends to have certain patterns, like dispatching on the kind of an AST node.

                          Also, XiDoc uses when isMainModule and not defined(js):, a very common pattern in Nim programs that want to both expose a library and an executable from the same file. Just because the pattern isn’t obnoxious to deal with doesn’t mean it isn’t a pattern, a thing repeated where needed. Janet solves that particular conundrum differently, and Nim’s is a riff on a similar pattern in Python.

                          It is also worth calling out that many patterns are as much about the the way data is arranged as they are are about code being arranged.

                          And one could argue that convention-based programming is all about fitting into a prescribed pattern.

                          That being said, making patterns in code less obnoxious to deal with is nearly always pleasant, IMO.

                          1. 1

                            I’ll see if I can come up with one, though it might be tricky because I don’t think we have any languages in common

                            1. 2

                              Just use pseudocode.

                              1. 1

                                I don’t see how I could. Patterns are found by examining how people use languages in the wild, and there’s no pseudocode in the wild.

                            2. 1

                              Ruby is an ultra-expressive language and very strong on using patterns like attr_accessor and similar to manage that complexity. Most of those patterns end up as libraries, but their use is as schematic as using patterns in other languages.

                              1. 2

                                I wouldn’t call attr_accessor a pattern. It’s just a method. That’s like calling print a method.

                                1. 1

                                  It’s the implementation of the “Accessor Pattern” in a method to encourage its use. Ruby also uses iteration as a general pattern over loops, and the method is called “each”. It uses conversion over casts, implemented through “to_” methods. Ultimately, all pattern use boils down to some form of using language features, and methods are just the most common construct in Ruby.

                                  Ruby is very brief in it’s pattern use, but there’s a ton of them to know to program it competently.

                                  1. 2

                                    Well, that’s exactly my point. The pattern is abstracted away into a method, so there’s no repetitive code.

                                    1. 1

                                      Patterns are not about repetitive code. That may be related, but many patterns are around common structure and names.

                                      Related discussion: attr_accessor :foo, :bar, :batz or three lines of attr_accessor :foo...? If DRY is your only principle, the first, but there’s a strong school that says the second is preferable.(*)

                                      Java Code is repetitive, but strongly pattern-based.

                                      (*) which is why i prefer Single Source of Truth over DRY. https://en.wikipedia.org/wiki/Single_source_of_truth

                                      1. 3

                                        In my opinion, what distinguishes a pattern from normal code is that you have to recognize it as a pattern instead of taking the code at face value. For example, if you see the following Java code:

                                        public class Vector2 {
                                            private double x;
                                            public double getX() {
                                                return x;
                                            }
                                            public void setX(double newX) {
                                                x = newX;
                                            }
                                            private double y;
                                            public double getY() {
                                                return y;
                                            }
                                            public void setY(double newY) {
                                                y = newY;
                                            }
                                        }
                                        

                                        If you just read the code without recognizing that it’s “just” two properties with getters and setters, you’ll have to think about what it does in the larger picture. In contrast, the Ruby version

                                        class Vector2
                                          attr_accessor :x, :y
                                        end
                                        

                                        makes the intention clear.

                                    2. 1

                                      IMHO, to_xxx is an anti-pattern. Making one type out of another should be a constructor on the target type. to_xxx in Java is an artefact of Java types being inextensible.

                                      1. 1

                                        How far would you take that? “Each class which wants to support serialization to string should add a constructor to the string class” seems a little extreme to me.

                                2. 1

                                  Clojure (with-open), Common Lisp (with-open-file, with-open-stream) and Ruby (File.open have the with-foo pattern for scoped resource usage.

                              2. 4

                                One of the frustrating things about design patterns in software is that so much of the original intent and thought behind “patterns” was lost in the telephone game of people talking about software engineering over the years. Christopher Alexander and the Gang of Four would both tell you that if you can abstract it away, it’s—by definition—not a pattern.

                                The key thing that separates patterns from data structures and algorithms is that patterns are slightly different every time they are manifested. A pattern is a guideline for how one could structure a solution to a problem, but not a solution itself. Taking a pattern and applying it still requires human judgement and understanding of the specific context in which it’s applied to know what to implement.

                                1. 2

                                  Abstraction is not factorization. Yes, whenever there is a repetition in code, we should factor it out.

                                  1. 1

                                    Nah. That repetition is very likely to be incidental, and factoring it out has the effect of reifying an abstraction that is unlikely to stand the test of time.

                                  2. 1

                                    This sentence implies definitions of “pattern” and “abstraction” that aren’t familiar to me. Can you say more?

                                    1. 2

                                      A pattern is something that is repetitive, either directly or on a more abstract level. If you have a lot of the same code, it violates the DRY principle and you should extract it into a procedure/function/method. However, this won’t always be possible when the repetition is more nuanced. In this case, languages like Java will simply say “fuck you” and leave you to either write a lot of repetitive code, or even use a code generator to write it automatically, which produces heaps of code that is hard to navigate through and find the true substance. Meanwhile, a more powerful language will offer features like templates or macros that can extract the repetition in the same way that procedures can extract simple repetition.

                                      1. 1

                                        Thanks for the response. I think you’re using a pretty esoteric definition of “pattern”. Also, DRY isn’t really about literal repetition of code, it’s about sources of truth in the information sense. It’s often far better to leave repetition alone than to try and abstract it away!

                                  3. 2

                                    Huh! I’ve never heard this perspective before. I’ve always understood design patterns as explicitly proscriptive: they originate from repetition in practice, yes, true — but they exist as well-defined things, serving as a kind of shared domain language for practitioners. I’ve always liked the notion that design patterns are “cages for complexity” — things to actively apply to problems to keep them tractable.

                                1. 5

                                  This is an OpenWRT image built around speedify, the latter component of which I believe has been discussed here before.

                                  (I clicked hoping for something new not dependent on such a 3rd party service and was disappointed.)

                                  1. 1

                                    Sorry, fixed the title. I couldn’t find any past discussions here.

                                    1. 1

                                      Thanks for explaining and I’m definitely not disparaging your work. This looks very helpful for people at a certain scale or with certain needs - thanks for making it public and freely available.

                                      WRT alternatives, the first thing that comes to mind is I imagine a modern solution would use MPTCP at the gateway and call it a day while a more compatible solution would have an open source client/server architecture that would tag and forward all traffic over both connections to a remote VM and reassemble them on the other end.

                                      1. 5

                                        It’s nowhere easy to implement with different links.

                                        MPTCP is for TCP aggregation, it’s not a tunnel.

                                        There is a great project by the name OpenMPTCProuter(OMR) that makes use of it. Bonding is done via a TCP proxy for TCP only as a side effect having MPTCP enabled per WAN. Clients are now behind a proxy. UDP and non-TCP flows are second class citizens, a TCP VPN is used to route these flows over the proxy. MPTCP requires an ISP that doesn’t filter TCP headers which is uncommon, OMR solves this by using another VPN per WAN which decreases performance and cause bufferbloat. (VPN->Mptcp->proxy->tcp VPN for non TCP, TCP over TCP over TCP)

                                        OMR is excellent for bonding over a gigabit as tested by few contributors, it’s not designed for lossy networks.

                                        There is no seamless failover, and having one WAN going lossy will disrupt connectivity. MPTCP doesn’t work if the client cold start with the master interface down. You can have 3 WANs up and 1 down that happens to be a master and experience a loss of connectivity on reboot or power up.

                                        Residential grade internet is not reliable enough for MPTCP, let alone combining cellular with wired unless one of them is very reliable and set as master. This is not an issue in data centers. Apple uses their own MPTCP “fork” to work around this, it’s mainly used for data migration in video calls.

                                        The more you aggregate WANs the less the reliability hence why Speedify includes a basic SD-WAN, other solutions are equivalent to a RAID 0 hard drive storage in terms of reliability. There are channels for different streams: aggregation/bonding channel, mirroring/redundant channel. Routing each stream to these channels being application aware. Redundant duplicates data across WANs while aggregate channel bonds across them. With video calls, thin streams, large downloads, and a low quality network will cause Speedify to route the calls and sensitive thin streams to the redundant channel while aggregating the bulk downloads, bulk downloads can handle packet loss and small disruptions, no real time requirments, this works with “Streaming mode” enabled. There is more info in the README.md page. You can combine different links with different speeds and latencies, however it takes time for the speed to ramp up when adding more than 3 WANs while weighing and monitoring history for quality rating score per WAN. A bad connection will be removed from aggregation but is still used in the redundant channel. Speedify seems to have a huge reordering buffer, saturating each WAN will cause a small fixed bufferbloat. There is FEC when encryption is enabled which is a bonus for lossy wireless connections.

                                        Edit: Regarding OSS alternatives, there is a project called “Engarde” that is a middleware for Wireguard to duplicate data for redundancy only. Glorytun for aggregation only but without reordering the packets (bad for TCP with different links) and no automatic weighing yet. MLVPN doesn’t have a functional reordering buffer, no auto weighing, and aggregation only. Vtrunkd is abandoned and unfinished as it moved to commercial, it’s very similar to Speedify, offers redundancy and aggregation.

                                        Auto weighing and reordering are not needed for combining two equal gateways from the same ISP and identical hardware, you can get away with bonding two OpenVPN clients tied per each WAN interface in pfSense, or using Linux Ethernet bonding if the jitter and latency is very low. MLVPN was designed for equal latencies but with large tolerance and failover.

                                        1. 1

                                          ZeroTier also seems to support multipath.

                                          Also, apparently OMR can use UDP as a transport as well.

                                          If MPTCP is not supported, OpenMPTCProuter can also use Multi-link VPN (MLVPN) or Glorytun UDP with multipath support. ref: https://github.com/Ysurac/openmptcprouter/wiki

                                          No idea how well they work though.

                                          1. 1

                                            OMR using Glorytun UDP only or MLVPN only disables MPTCP and shadowsocks proxy. MPTCP is TCP only. All aggregation solutions are called multi path.

                                            I mentioned Glorytun and MLVPN in the previous comment for details.

                                            OMR supports VPN per WAN to forward MPTCP with Wireguard (default since 0.58) or OpenVPN both causing large overhead and bufferbloat. This is not clearly mentioned unfortunately.

                                            Since 0.58, OMR is using the master branch of Glorytun without the correct parameters in post-tracking script. An unofficial dormant fork of MLVPN that’s not functional instead of the updated fork called Ubond or simply using official MLVPN. There is no easy way to downgrade to older versions on the server side.

                                            Zerotier multipath is for equal links only, no buffering or auto* weighing.

                                            1. 1

                                              Zerotier multipath is for equal links only, no buffering or weighing.

                                              Sure seems like it has weighting?

                                              1. 2

                                                Sorry, “Auto weighting”, typo. Anyways can’t wait till they actually implement these features as they’re only documented, the basic multi path function barely works, even then automatic detection and buffer length is necessary for dynamic links like cellular and residential internet, this is missing in Zerotier, reordering buffer is needed for non equal links, UDP and QUIC will run fine. Flow based is load balancing no packet aggregation hence why they suggest to use it for TCP streams. I haven’t tried dev-mutlipath testing branch yet: https://github.com/zerotier/ZeroTierOne/issues/1412

                                                Checkout ubond, it has a working auto weight and reordering buffer in the master branch as of today but it lacks any documentation, I followed MLVPN docs. I’ll eventually add it after some polishing and use few major VPS providers using their API for one click server deployment requiring prepaid balance and an account for self hosting to maintain the “no CLI” approach, much less simpler than a 3rd party service however.

                                                1. 2

                                                  Thanks for the info!

                                  1. 42

                                    I suggest to the author, as I suggest to anybody who finds themselves imagining that everyone around them (except for themselves) must be pathologically stupid, that they suppose that all of the things they decry are motivated by sensible, relatable concerns, which nevertheless might not be the same concerns as are primary to the author, or which might be realized via methods which nevertheless might not be the ones that the author prefers or knows.

                                    1. 11

                                      Devil’s advocate even though I think your approach is the right default one:

                                      Does this mean it’s impossible for large groups of people to do “crazy” things? Empirically, historically, this seems false. How then do you distinguish between those cases and cases where you simply lack context?

                                      “motivated by sensible, relatable concerns”

                                      What if the relatable concern is wanting to feel cool, and use something fresh and new, or a thing that Google uses and people talk about at conferences? I’m not just being glib and dismissive. But if that is the impulse – and I think it drives deeper than most people admit – you don’t necessarily get sensible. Or… there’s plain old not knowing about simpler ways.

                                      People don’t have to be dumb to partake of sub-optimal trends.

                                      1. 1

                                        Does this mean it’s impossible for large groups of people to do “crazy” things? Empirically, historically, this seems false. How then do you distinguish between those cases and cases where you simply lack context?

                                        I normally try creating a Fermi Estimate for the problem. If it differs substantially from the scope of work then I assume there’s some missing context.

                                        1. 1

                                          I normally try creating a Fermi Estimate for the problem. If it differs substantially from the scope of work then I assume there’s some missing context.

                                          For example, how would this work to answer a question like “Are far too many companies using Angular when something simpler could have solved their problem better and saved many engineering hours?”

                                          1. 1

                                            I don’t think it would work for that kind of question; I use this approach for projects at work where there’s usually a missing context.

                                      2. 2

                                        I don’t know if the author really thinks that way about people or it’s just a way to emphasize the unnecessary growing complexity of some systems (given his personal experience).

                                        1. 7

                                          Being loud, angry, and intolerant is UnixSheikh’s whole deal, so I don’t think it’s “just a way to emphasize”.

                                      1. 7

                                        This article talks at-length about the tensions between tokio and mixed workloads that it cannot even theoretically serve well, and goes into a bunch of workarounds that needed to be put in-place to mask these tensions, instead of just avoiding the tensions to begin with.

                                        When a request’s dependency chain contains a mixture of components optimized for low latency (with short buffers in front) and components optimized for high throughput (with large buffers in front), you get the worst-of-all-worlds high-level system behavior.

                                        It’s like taking a school bus of kids to McDonalds and going through the drive-through and looping around once for each kid on the bus. Each loop is latency-optimized and whichever kid whose turn it is to order will receive their meal at a low latency after the time that they get to order it, but their sojourn time where they are waiting around doing nothing before being served explodes. But by taking the whole bus’s orders at once, the overall throughput is far higher, and because we have to accomplish a whole bus’s worth of orders anyway, there’s no point optimizing for latency below the whole-bus threshold. The idea has strong descriptive power for so many things in life, especially in software. Most people would probably not have a social media web site server kick off an apache mapreduce job for each GET to the timeline, even if the mapreduce job was to looking at a miniscule amount of data, because it is a similar (more exaggerated but still the same idea) mixing of low-latency components with high throughput components. Mixing of queue depths in a request chain degrades both latency and throughput.

                                        Sure, it’s software, you can mix queue depths, and in this case it will probably actually give you a social advantage by signalling to a wider group of subcommunities that you are invested in the products of their social software activities, but you are leaving a lot on the table from an actual performance perspective. This is pretty important queue theory stuff for people who want to achieve competitive latency or throughput. I strongly recommend (and give to basically everyone I work with on performance stuff) chapter 2: Methodology from Brendan Gregg’s book Systems Performance: Enterprise and Cloud which goes into the USE method for reasoning about these properties at a high level.

                                        Drilling more into the important properties of a a scheduler: parallelism (what you need for scaling CPU-bound tasks) is, from a scheduling perspective, the OPPOSITE of concurrency (what you need for blocking on dependencies). I love this video that illustrates this point: https://www.youtube.com/watch?v=tF-Nz4aRWAM&t=498s. By spending cycles on concurrent dependency management, you really cut into the basic compute resources available for accomplishing low-interactivity analytical and general CPU-bound work. The mind-exploder of this perspective is that a single-threaded execution is firmly in-between parallelism and concurrency on the programmer freedom vs scheduler freedom spectrum. The big con is people like Rob Pike who have managed to convince people (while selling compute resources) that concurrency is somehow an admirable path towards effective parallelism.

                                        Sure, you can essentially build a sub-scheduler that runs within your async scheduler that runs on top of your OS’s scheduler that runs on top of your cluster’s scheduler that runs on your business’s capex resources etc… etc… but it’s pretty clear that from the high-level, you can push your available resources farther by cutting out the dueling subschedulers for workloads where their tensions drive down the available utilization of resources that you’re paying for anyway.

                                        1. 3

                                          Basically, they want one process to deal with latency optimized requests and other throughput optimized requests. I don’t know if there use case is valid but basically they try to separate them into different systems. Something you actually advocate for.

                                          It is not unlike having a UI main thread and offloading long running ops to background tasks which may, e.g. report progress back to the UI.

                                          That is entirely reasonable, in my opinion.

                                          They even do use OS scheduling for their needs by using low priority threads.

                                          The decision whether to use tokio for the long running ops is more questionable. It might be just a matter of “it works well enough and we prefer using the same APIs everywhere.”

                                          They also put the a big buffer in front with the channel (and a rather slow one, I think).

                                          I think it can obviously be optimized but the question is more, so they need to? Or is their a simpler solution that is also simpler considering the new APIs it requires devs to know about.

                                          1. 1

                                            Just a random thought related to not using OS schedulers to their full extend: in-process app schedulers relate to OS schedulers in a similar way Electron relates to native desktop toolkits.

                                            Reimplementing part of the OS stack seems silly until you want apps to work cross platform. Then your limited scheduler is still a compromise but at least it works similarly everywhere. Overhead for threads, processes, fibers is pretty different in Operating Systems, at least it used to be.

                                            1. 1

                                              Most services are deployed on Linux (and if not Linux then usually only one operating system), however, so discrepancies that cause performance drops on other operating systems are not that important.

                                              1. 1

                                                I agree about deployment but the ecosystem would still prefer a cross platform aporoach.

                                                Being able to repeoduce problems on your dev machine without a vm is very valuable, though.

                                                Also I don’t think an optimized a single OS approach to async in rust would get adoption.

                                          1. 2

                                            Anyone on windows not already using notepad++ does not care about having a decent notepad

                                            1. 14

                                              Sometimes people need to do things on a non-dev environment without a better notepad though. None of my customers have notepad++ installed and I don’t permissions to install or even run new apps - so sometimes when I need to see a file, it’s notepad - and any improvement to it is very welcome.

                                              1. 4

                                                Ouch, I feel for you then. Consider me corrected

                                              2. 7

                                                I leave notepad open because some Windows apps still don’t have ‘paste as plain text’ options and so it’s useful to paste into notepad and then copy. Multi-level undo can be useful sometimes. I mostly use vim in WSL for text editing though, so I’m probably not representative of the wider Windows ecosystem.

                                                1. 3

                                                  I leave notepad open because some Windows apps still don’t have ‘paste as plain text’ options

                                                  If this is your main motivation, Win+V allows you to do that globally. (Do note that I think you have to turn on Clipboard History, but it should prompt you if you do.)

                                                  1. 1

                                                    I use PureText for copying and pasting as plain text.

                                                    1. 1

                                                      Cant you paste unformatted text in vim?

                                                    2. 1

                                                      I’m a fan of notepad2 myself… Notepad++ is too much

                                                    1. 2
                                                      desktop screenshot

                                                      On the M1 Air writing some SQL and fixing static file paths just now for a little weekend project. This machine is just about fully Nord everywhere with a hint of Ayu. It’s nice to take a break from the big iron at the desk.

                                                      1. 4

                                                        I have a utilities library for another language and I’ve found that the grab-bag, misc nature of it has made people reluctant to use it. Any advice?

                                                        1. 6

                                                          My advice is that people will use your library if it’s less work to find it, understand it, integrate it, and consume it, when compared to writing their own utility functions. For a utilities library, this is highly unlikely to be the case.

                                                          The remarkable thing about left-pad to me is that these conditions somehow became true, which is a huge credit to npm.

                                                          1. 2

                                                            Any advice?

                                                            Well, seeing as I released this package literally today, I might not be the best person to give advice – maybe no one will use _ either!

                                                            That said, here are a few things that I’d look for in a utilities package and that I’m aiming to deliver with _:

                                                            • How much do I trust the quality of the code? For _, I’m emphasizing the shortness of the code and hoping that reading it will get people to trust the quality (this depends both on them being willing to read it and on them thinking it’s well-written). But this could also be based on the reputation of the author/professional backing, test coverage, etc.
                                                            • Does the library seem likely to be well maintained? Part of the point of a utility library is to simplify common tasks. But if the library becomes abandoned, it would have the opposite effect. For _, I’m trying to address this by putting thought into the library’s future and being transparent about my thoughts. (See, e.g., the 5,000+ word OP)
                                                            • Will the library maintain backwards compatibility or break when I need it most? As with the previous bullet, a utility library that breaks my code is having the opposite of the effect I want. This part is still a WIP for _, but I’m trying to come up with the strongest promise of backward compatibility that I can reasonably keep.
                                                            • Does the library have functions in a “happy medium” of complexity? If they’re too simple, I’d just implement them myself instead of using the library; if they’re too complex, I’d be willing to take on a dedicated dependency for that feature rather than leave it to a utility library. This is fairly subjective; I’ve tried to strike the correct balance with _, but I’ll have to see how many users agree.
                                                            1. 4

                                                              maybe no one will use _ either

                                                              first impression: this is a terrible name, and not just because it’s already in use by gettext

                                                              1. 1

                                                                Can you say more about why _ strikes you as a bad name? Does the spelled-out version I also used (“lowbar”) strike you the same way?

                                                                Names are important things, and I’m curious about your views.

                                                                1. 5

                                                                  “I used an underscore character to name my library. Many people will think it’s named after this other similar library that also uses an underscore for its name, but it’s actually not.” <- This makes no sense at all. I’ve never heard an underscore called a lowbar, and citing the HTML spec comes across as “see I’m technically correct” pedantry.

                                                                  1. 2

                                                                    That’s an entirely fair criticism of my post – so much so that I upvoted.

                                                                    (The bit about the HTML spec was intended as … well, not quite a joke, but making light of myself for needing to pick an obscure term for the character – I also hadn’t heard a ‘_’ called a “lowbar” before. Clearly that not-quite-a-joke didn’t land).

                                                                    What I was trying to say is that _ fits so well with Raku’s existing use of $_, @_, and %_ that I decided to go with the name anyway – even though I view the name collision with underscore.js and lodash.js as unfortunate and 100% accept that most people will think that _ named in homage to lowdash.

                                                                    1. 2

                                                                      Yeah, I’m speaking without any specific knowledge of Raku. I just think that if the library does catch on, people will pronounce it as “underscore” whether you want them to or not. =)

                                                                      The thing that the underscore character reminds me of is when you’re writing a function that accepts more arguments than it needs, and you’re using an underscore to communicate that it’s unused: https://softwareengineering.stackexchange.com/questions/139582/which-style-to-use-for-unused-return-parameters-in-a-python-function-call (the link mentions Python and I’ve never used Python, but it’s common in nearly every language I do use)

                                                                  2. 1

                                                                    Can you say more about why _ strikes you as a bad name? Does the spelled-out version I also used (“lowbar”) strike you the same way?

                                                                    I dislike this name because it’s difficult to search for and lowbar is a relatively obscure term. If the intent is that every Raku program includes the library, then you could call it Prelude. That’s what other languages such as Haskell call a library of functions that are implicitly included in every program.

                                                                    1. 2

                                                                      On the other hand, lodash uses _ and is pretty well known in the JS land.

                                                                      1. 1

                                                                        there’s also underscore.js https://underscorejs.org/

                                                              2. 1

                                                                I sometimes use such libraries if I have no other choice, but it would be much better to split it into smaller, more focused libraries probably?

                                                                1. 2

                                                                  But then we’re back to the left-pad dilemma!

                                                                  1. 1

                                                                    Not if you don’t rely on a mutable third party store for your production builds :)

                                                                    1. 3

                                                                      But you’ve just pushed the workload somewhere else… now you have to separately monitor for and pull in manually any bug fixes and security patches that get made in the dependency. Vendoring (whether in the traditional sense, or merely by snapshotting some specific state of a remote source) is a valid approach, but no panacea.

                                                              1. 40

                                                                Looks like the employee is based in the UK. As you might expect, most of the responses to his announcement are Bad Legal Advice. This comment is also going to be Bad Legal Advice (IANAL!) but I have some experience and a little background knowledge so I hope I can comment more wisely…

                                                                The way FOSS (and indeed all private-time) software development works here for employees is that according to your contract your employer will own everything you create, even in your private time. Opinions I’ve heard from solicitors and employment law experts suggest that this practice might constitute an over-broad, “unfair”, contract term under UK law. That means you might be able to get it overturned if you really tried, but you’d have to litigate to resolve it. At any rate the de facto status is: they own it by default.

                                                                What employees typically do is seek an IP waiver from their employer where the employer disclaims ownership of the side-project. The employer can refuse. If you’ve already started they could take ownership, as apparently is happening in this case. Probably in that scenario what you should not do is try to pre-emptively fork under some idea that your project is FOSS and that you have that right. The employer will likely take the view that because you aren’t the legal holder of the IP that you aren’t entitled to release either the original nor the fork as FOSS - so you’ve improperly releasing corporate source code. Pushing that subject is an speedy route to dismissal for “gross misconduct” - which a sufficient reason for summary dismissal, no process except appeal to tribunal after the fact.

                                                                My personal experience seeking IP waivers, before I turned contractor (after which none of the above applies), was mixed. One startup refused it and even reprimanded me for asking - the management took the view that any side project was a “distraction from the main goal”. Conversely ThoughtWorks granted IP waivers pretty much blanket - you entered your project name and description in a shared spreadsheet and they sent you a notice when the solicitor saw the new entry. They took professional pride in never refusing unless it conflicted with the client you were currently working with.

                                                                My guess is that legal rules and practices on this are similar in most common law countries (UK, Australia, Canada, America, NZ).

                                                                1. 27

                                                                  The way FOSS (and indeed all private-time) software development works here for employees is that according to your contract your employer will own everything you create, even in your private time.

                                                                  This seems absurd. If I’m a chef, do things I cook in my kitchen at home belong to my employer? If I’m a writer do my kids’ book reports that I help with become privileged? If I’m a mechanic can I no longer change my in-laws’ oil?

                                                                  Why is software singled out like this and, moreover, why do people think it’s okay?

                                                                  1. 10

                                                                    There have been cases of employees claiming to have written some essential piece of software their employer relied on in their spare time. Sometimes that was even plausible, but still it’s essentially taking your employer hostage. There have been cases of people starting competitors to their employer in their spare time; what is or is not competition is often subject to differences of opinion and are often a matter of degree. These are shadow areas that are threatening to business owners that they want to blanket prevent by such contractual stipulations.

                                                                    Software isn’t singled out. It’s exactly the same in all kinds of research, design and other creative activities.

                                                                    1. 12

                                                                      There have been cases of people starting competitors to their employer in their spare time;

                                                                      Sounds fine to me, what’s the problem? Should it be illegal for an employer to look for a way to lay off employees or otherwise reduce its workforce?

                                                                      1. 4

                                                                        what’s the problem?

                                                                        I think it’s a pretty large problem if someone can become a colleague, quickly hoover up all the hard won knowledge we’ve together accumulated over the past decade, then start a direct competitor to my employer, possibly putting me out of work.

                                                                        You’re thinking of large faceless companies that you have no allegiance to. I’m thinking of the two founders of the company that employs me and my two dozen colleagues, whom I feel loyal towards.

                                                                        This kind of thing protects smaller companies more than larger ones.

                                                                        1. 2

                                                                          …start a direct competitor to my employer, possibly putting me out of work.

                                                                          Go work for the competitor! Also, people can already do pretty much what you describe in much of the US where non-competes are unenforceable. To be clear, I think this kind of hyper competitiveness is gross, and I would much rather collaborate with people to solve problems than stab them in the back (I’m a terrible capitalist). But I’m absolutely opposed to giving companies this kind of legal control over (and “protection” from) their employees.

                                                                          1. 3

                                                                            Go work for the competitor!

                                                                            Who says they want me? Also I care for my colleagues: who says they want them as well?

                                                                            where non-competes are unenforceable

                                                                            Overly broad non-competes are unenforceable when used to attempt to enforce against something not clearly competition. They are perfectly enforceable if you start working for, or start, a direct competitor, profiting from very specific relevant knowledge.

                                                                            opposed to giving companies this kind of legal control

                                                                            As I see it we don’t give “the company” legal control: we effectively give humans, me and my colleagues, legal control over what new colleagues are allowed to do, in the short run, with the knowledge and experience they gain from working with us. We’re not protecting some nameless company: we’re protecting our livelihood.

                                                                            And please note that my employer does waive rights to unrelated side projects if you ask them, waives rights to contributions to OSS, etc. Also note that non-compete restrictions are only for a year anyway.

                                                                            1. 1

                                                                              Who says they want me? Also I care for my colleagues: who says they want them as well?

                                                                              Well then get a different job, get over it, someone produced a better product than your company, that’s the whole point of capitalism!

                                                                              They are perfectly enforceable if you start working for, or start, a direct competitor, profiting from very specific relevant knowledge.

                                                                              Not in California, at least, it’s trivially easy to Google this.

                                                                              As I see it we don’t give “the company” legal control: we effectively give humans, me and my colleagues, legal control over what new colleagues are allowed to do, in the short run, with the knowledge and experience they gain from working with us.

                                                                              Are you a legal party to the contract? If not, then no, it’s a contract with your employer and if it suits your employer to use it to screw you over, they probably will.

                                                                              I truly hope that you work for amazing people, but you need to recognize that almost no one else does.

                                                                              Even small startups routinely screw over their employees, so unless I’ve got a crazy amount of vested equity, I have literally zero loyalty, and that’s exactly how capitalism is supposed to work: the company doesn’t have to care about me, and I don’t have to care about the company, we help each other out only as long as it benefits us.

                                                                            2. 1

                                                                              Go work for the competitor?

                                                                              Why would the competitor want/need the person they formerly worked with/for?

                                                                              1. 1

                                                                                Why did the original company need the person who started the competitor? Companies need workers and if the competitor puts the original company out of business (I was responding to the “putting me out of work” bit) then presumably it has taken on the original company’s customers and will need more workers, and who better than people already familiar with the industry!

                                                                          2. 1

                                                                            Laying off and reducing the workforce can be regulated (and is in my non-US country). The issue with having employees starting competitor products is that they benefit from an unfair advantage and create a huge conflict of interest.

                                                                            1. 2

                                                                              Modern Silicon Valley began with employees starting competitor products: https://en.wikipedia.org/wiki/Traitorous_eight

                                                                              If California enforced non-compete agreements, Silicon Valley might well not have ended up existing. Non-enforcement of noncompetes is believed to be one of the major factors that resulted in Silicon Valley overtaking Boston’s Route 128 corridor, formerly a competitive center of technology development: https://hbr.org/2016/11/the-reason-silicon-valley-beat-out-boston-for-vc-dominance

                                                                              1. 1

                                                                                I don’t think we are talking about the same thing. While I agree that any restriction on post-employment should be banned, I don’t think it is unfair for an organization to ask their employees to not work on competing products while being under their payroll. These are two very different situations.

                                                                              2. 2

                                                                                If the employee uses company IP in their product then sure, sue them, that’s totally fair. But if the employee wants to use their deep knowledge of an industry to build a better product in their free time, then it sucks for their employer, but that’s capitalism. Maybe the employer should have made a better product so it would be harder for the employee to build something to compete with it. In fact, it seems like encouraging employees to compete with their employers would actually be good for consumers and the economy / society at large.

                                                                                1. 1

                                                                                  An employee working on competing products on its free time creates an unfair advantage because the employees have access to an organization IP to build its new product while the organization does not have access to the competing product IP. So what’s the difference between industrial espionage and employees working on competing products on their free time?

                                                                                  1. 1

                                                                                    If the employee uses company IP in their product then sure, sue them, that’s totally fair.

                                                                                    That was literally in the comment you responded to.

                                                                          3. 4

                                                                            Joel Spolsky wrote a piece that frames it well, I think. I don’t personally find it especially persuasive, but I think it does answer the question of why software falls into a different bucket than cooking at home or working on a car under your shade tree, and why many people think it’s OK.

                                                                            1. 3

                                                                              Does this article suggest the employers view contracts as paying for an employee’s time, rather than just paying for their work?

                                                                              Could a contract just be “in exchange for this salary, we’d like $some_metric of work”, with working hours just being something to help with management? It seems irrelevant when you came up with something, as long as you ultimately give your employer the amount of work they paid you for.

                                                                              Why should an employer care about extra work being released as FOSS if they’ve already received the amount they paid an employee for?

                                                                              EDIT: I realise now that $some_metric is probably very hard to define in terms of anything except number of hours worked, which ends up being the same problem

                                                                              1. 2

                                                                                Does this article suggest the employers view contracts as paying for an employee’s time, rather than just paying for their work?

                                                                                I didn’t read it that way. It’s short, though. I’d suggest reading it and forming your own impression.

                                                                                Could a contract just be “in exchange for this salary, we’d like $some_metric of work”, with working hours just being something to help with management? It seems irrelevant when you came up with something, as long as you ultimately give your employer the amount of work they paid you for.

                                                                                I’d certainly think that one of many possible reasonable work arrangements. I didn’t link the article intending to advocate for any particular one, and I don’t think its author intended to with this piece, either.

                                                                                I only linked it as an answer to the question that I read in /u/lorddimwit’s comment as “why is this even a thing?” because I think it’s a plausible and cogent explanation of how these agreements might come to be as widespread as they are.

                                                                                Why should an employer care about extra work being released as FOSS if they’ve already received the amount they paid an employee for?

                                                                                As a general matter, I don’t believe they should. One reason I’ve heard given for why they might is that they’re afraid it will help their competition. I, once again, do not find that persuasive personally. But it is one perceived interest in the matter that might lead an employer to negotiate an agreement that precludes releasing side work without concurrence from management.

                                                                                1. 1

                                                                                  I only linked it as an answer to the question that I read in /u/lorddimwit’s comment as “why is this even a thing?” because I think it’s a plausible and cogent explanation of how these agreements might come to be as widespread as they are.

                                                                                  I think so too, and hope I didn’t come across as assuming you (or the article) were advocating anything that needs to be argued!

                                                                                  I didn’t read it that way. It’s short, though. I’d suggest reading it and forming your own impression.

                                                                                  I’d definitely gotten confused because I completely ignored that the author is saying that the thinking can become “I don’t just want to buy your 9:00-5:00 inventions. I want them all, and I’m going to pay you a nice salary to get them all”. Sorry!

                                                                            2. 3

                                                                              There is a huge difference: We’re talking about creativity and invention. The company isn’t hiring your for changing some oil or swapping some server hardware. They’re hiring you to solve their problems, to be creative and think of solutions. (Which is also why I don’t think it’s relevant how many hours you actually coded, the result and time you thought about it matters.) Your company doesn’t exist because it’s changing oil, the value is in the code (hopefully) and thus their IP.

                                                                              So yes, that’s why this stuff is actually different. Obviously you want to have exemptions from this kind of stuff when you do FOSS things.

                                                                              1. 2

                                                                                I think the chef and mechanic examples are a bit different since they’re not creating intellectual property, and a book report is probably not interesting to an employer.

                                                                                Maybe a closer example would be a chef employed to write recipes for a book/site. Their employer might have a problem with them creating and publishing their own recipes for free in their own time. Similarly, maybe a writer could get in trouble for independently publishing things written in their own time while employed to write for a company. I can see it happening for other IP that isn’t software, although I don’t know if it happens in reality.

                                                                                1. 3

                                                                                  I think the “not interesting” bit is a key point here. I have no idea what Bumble is or the scope of the company, and I speak out of frustration of these overarching “legal” restrictions, but its sounds like they are an immature organization trying to hold on to anything interesting their employees do, core to the current business, or not, in case they need to pivot or find a new revenue stream.

                                                                                  Frankly if a company is so fearful that a couple of technologies will make make or break their company, their business model sucks. Technology != product.

                                                                                  1. 2

                                                                                    Similarly, maybe a writer could get in trouble for independently publishing things written in their own time while employed to write for a company

                                                                                    I know of at least one online magazine’s contracts which forbid exactly this. If you write for them, you publicly only write for them.

                                                                                2. 10

                                                                                  This is pretty much my (non-lawyer) understanding and a good summary, thanks.

                                                                                  If you find yourself in this situation, talk to a lawyer. However I suspect that unless you have deep pockets and a willingness to litigate “is this clause enforceable” through several courts, your best chance is likely to be reaching some agreement with the company that gives them what they want whilst letting you retain control of the project or at least a fork.

                                                                                  One startup refused it and even reprimanded me for asking - the management took the view that any side project was a “distraction from the main goal”

                                                                                  I think the legal term for this is “bunch of arsehats”. I’m curious to know whether you worked for them after they started out like this?

                                                                                  1. 6

                                                                                    I think the legal term for this is “bunch of arsehats”.

                                                                                    https://www.youtube.com/watch?v=Oz8RjPAD2Jk

                                                                                    I’m curious to know whether you worked for them after they started out like this?

                                                                                    I left shortly after for other reasons

                                                                                  2. 2

                                                                                    The way FOSS (and indeed all private-time) software development works here for employees is that according to your contract your employer will own everything you create, even in your private time

                                                                                    Is it really that widespread? It’s a question that we get asked by candidates but our contract is pretty clear that personal-time open source comes under the moonlighting clause (i.e. don’t directly compete with your employer). If it is, we should make a bigger deal about it in recruiting.

                                                                                    1. 1

                                                                                      I would think the solution is to quit, then start a new project without re-using any line of code of the old project - but I guess the lawyers thought of this too and added clauses giving them ownership of the new project too…

                                                                                    1. 1

                                                                                      There is no real technical content in the link, just vague hints and repeated (see the book for more info) all over. The page doesn’t make it seem like it’s a description of the book - it makes it seem like “here’s how to build this” then doesn’t deliver.

                                                                                      That and the fact that the page starts off by talking about how it’s all open source and shared with the community was really incongruent. Flagged as spam.

                                                                                      1. 1

                                                                                        I’m pretty sure that even Gmail spam detection system is better at detecting “spam”. There are two links in this site to “backshed” forum detailing the circuit, pcb print, schematics and firmware. The main page is a showcase/summary. The book is just a comprehensive guide/compilation, you can build without it. It’s mostly about wrapping the TF and best practices.

                                                                                      1. 0

                                                                                        So beautiful!

                                                                                        1. 4

                                                                                          This is an interesting thread on making Makefiles which are POSIX-compatible. The interesting thing is that it’s very hard or impossible, at least if you want to keep some standard features like out-of-tree builds. I’ve never restricted myself to write portable Makefiles (I use GNU extensions freely), but I previously assumed it wasn’t that bad.

                                                                                          That this is so hard is maybe a good example of why portability to different dependencies is a bad goal when your dependencies are already open source and portable. As many posters in the thread say, you can just use gmake on FreeBSD. The same goes for many other open source dependencies: If the software is open source, portability to alternatives to that software is not really important.

                                                                                          1. 4

                                                                                            you can just use gmake on FreeBSD.

                                                                                            I can, but I don’t want to.

                                                                                            If you want to require any specific tool or dependecy, fine, that’s your prerogative, just don’t force your idea of the tool’s cost on me. Own your decision, if it impacts me, be frank about it, just don’t bullshit me that it doesn’t impact me just because the cost for you is less than the cost for me.

                                                                                            The question of why don’t you use X instead of Y is nobody’s business but mine. I fully understand and expect that you might not care about Y, please respect my right not to care about X.

                                                                                            1. 11

                                                                                              That’s very standard rhetoric about portability, but the linked thread shows it’s not so simple in this case: It’s essentially impossible to write good, portable Makefiles.

                                                                                              1. 5

                                                                                                Especially considering how low cost using GNU Make is, over i.e. switching OS/architecture.

                                                                                                1. 2

                                                                                                  It’s just as easy to run BSD make on Linux as it is to run GNU make on BSDs, yet if I ship my software to Linux users with a BSD makefile and tell them to install BSD make, there will hardly be a person who wouldn’t scorn at the idea.

                                                                                                  Yet Linux users expect BSD users not to complain when they do exact same thing.

                                                                                                  Why is this so hard to understand, the objection is not that you have to run some software dependency, the objection is people telling you that you shouldn’t care about the nature of the dependency because their cost for that dependency is different than yours.

                                                                                                  I don’t think that your software is bad because it uses GNU make, and I don’t think that using GNU make makes you a bad person, but if you try to convince me that “using GNU make is not a big deal”, then I don’t want to ever work with you.

                                                                                                  1. 2

                                                                                                    Are BSD makefiles incompatible with GNU make? I actually don’t know.

                                                                                                    1. 2

                                                                                                      The features, syntax, and semantics of GNU and BSD make are disjoint. Their intersection is POSIX make, which has almost no features.

                                                                                                      …but that’s not the point at all.

                                                                                                      1. 2

                                                                                                        If they use BSD specific extensions then yes

                                                                                                  2. 2

                                                                                                    Posix should really standardize some of GNU make’s features (e.g. pattern rules) and/or the BSDs should just adopt them.

                                                                                                    1. 5

                                                                                                      I get the vibe at this point that BSD intentionally refuses to make improvements to their software specifically because those improvements came from GNU, and they really hate GNU.

                                                                                                      Maybe there’s another reason, but why else would you put up with a program that is missing such a critically important feature and force your users to go thru the absurd workarounds described in the article when it would be so much easier and better for everyone to just make your make better?

                                                                                                      1. 4

                                                                                                        I get the vibe at this point that BSD intentionally refuses to make improvements to their software specifically because those improvements came from GNU, and they really hate GNU.

                                                                                                        Really? I’ve observed the opposite. For example, glibc refused to adopt the strl* functions from OpenBSD’s libc, in spite of the fact that they were useful and widely implemented, and the refusal to merge them explicitly called them ‘inefficient BSD crap’ in spite of the fact that they were no less efficient than existing strn* functions. Glibc implemented the POSIX _l-suffixed versions but not the full set from Darwin libc.

                                                                                                        In contrast, you’ll find a lot of ‘added for GNU compatibility’ functions in FreeBSD libc, the *BSD utilities have ‘for GNU compatibility’ in a lot of places. Picking a utility at random, FreeBSD’s du [has two flags that are listed in the man page as first appearing in the GNU version], whereas GNU du does not list any as coming from BSDs (though -d, at least, was originally in FreeBSD’s du - the lack of it in GNU and OpenBSD du used to annoy me a lot since most of my du invocations used -d0 or -d1).

                                                                                                        1. 2

                                                                                                          The two are in no way mutually exclusive.

                                                                                                        2. 1

                                                                                                          Maybe there’s another reason, but why else would you put up with a program that is missing such a critically important feature and force your users to go thru the absurd workarounds described in the article when it would be so much easier and better for everyone to just make your make better?

                                                                                                          Every active software project has an infinite set of possible features or bug fixes; some of them will remain unimplemented for decades. glibc’s daemon function, for example, has been broken under Linux since it was implemented. The BSD Make maintainers just have a different view of the importance of this feature. There’s no reason to attribute negative intent.

                                                                                                          1. 1

                                                                                                            The BSD Make maintainers just have a different view of the importance of this feature

                                                                                                            I mean, I used to think that too but after reading the article and learning the details I have a really hard time continuing to believe that. we’re talking about pretty basic everyday functionality here.

                                                                                                          2. 1

                                                                                                            Every BSD is different, but most BSDs are minimalist-leaning. They don’t want to add features not because GNU has them, but because they only want to add things they’ve really decided they need. It’s an anti-bloat philosophy.

                                                                                                            GNU on the other hand is basically founded in the mantra “if it’s useful then add it”

                                                                                                            1. 6

                                                                                                              I really don’t understand the appeal of the kind of philosophy that results in the kind of nonsense the linked article recommends. Why do people put up with it? What good is “anti-bloat philosophy” if it treats “putting build files in directories” as some kind of super advanced edge case?

                                                                                                              Of course when dealing with people who claim to be “minimalist” it’s always completely arbitrary where they draw the line, but this is a fairly clear-cut instance of people having lost sight of the fact that the point of software is to be useful.

                                                                                                              1. 4

                                                                                                                The article under discussion isn’t the result of a minimalist philosophy, it’s the result of a lack of standardisation. BSD make grew a lot of features that were not part of POSIX. GNU make also grew a similar set of features, at around the same time, with different syntax. FreeBSD and NetBSD, for example, both use bmake, which is sufficiently powerful to build the entire FreeBSD base system.

                                                                                                                The Open Group never made an effort to standardise any of them and so you have two completely different syntaxes. The unfortunate thing is that both GNU Make and bmake accept all of their extensions in a file called Makefile, in addition to looking for files called GNUmakefile / BSDmakefile in preference to Makefile, which leads people to believe that they’re writing a portable Makefile and complain when another Make implementation doesn’t accept it.

                                                                                                      2. 7

                                                                                                        But as a programmer, I have to use some build system. If I chose Meson, that’d be no problem; you’d just have to install Meson to build my software. Ditto if I chose cmake. Or mk. Why is GNU make any different here? If you’re gonna wanna compile my software, you better be prepared to get my dependencies onto your machine, and GNU make is probably gonna be one of the easiest build systems for a BSD user to install.

                                                                                                        As a Linux user, if your build instructions told me to install bsdmake or meson or any other build system, I wouldn’t bat an eye, as long as that build system is easy to install from my distro’s repos.

                                                                                                        1. 3

                                                                                                          Good grief, why is this so difficult to get through? If you want to use GNU make, or Meson, or whatever, then do that! I use GNU make too! I also use Plan 9’s mk, which few people have installed, and even fewer would want to install. That’s not the point.

                                                                                                          The problem here has nothing to do with intrinsic software properties at all, I don’t know why this is impossible for Linux people to understand.

                                                                                                          If you say “I am using GNU make, and if you don’t like it, tough luck”, that’s perfectly fine.

                                                                                                          If you say “I am using GNU make, which can’t cause any problem for you because you can just install it” then you are being ignorant of other people’s needs, requirements, or choices, or you are being arrogant for pretending other people’s needs, requirements, or choices are invalid, and of course in both cases you are being patronizing towards users you do not understand.

                                                                                                          This has nothing to do with GNU vs. BSD make. It has nothing to do with software, even. It’s a social problem.

                                                                                                          if your build instructions told me to install bsdmake or meson or any other build system, I wouldn’t bat an eye, as long as that build system is easy to install from my distro’s repos.

                                                                                                          And this is why Linux users do not understand the actual problem. They can’t fathom that there are people for whom the above way of doing things is unacceptable. It perfectly fine not to cater to such people, what’s not fine is to demand that their reasoning is invalid. There are people to whom extrinsic properties of software are far more important than their intrinsic properties. It’s ironic that Linux people have trouble understanding this, given this is the raison d’etre for the GNU project itself.

                                                                                                          1. 5

                                                                                                            I think the question is “why is assuming gmake is no big deal any different than assuming meson is no big deal?” And I think your answer is “those aren’t different, and you can’t assume meson is no big deal” but you haven’t come out and said that yet.

                                                                                                        2. 1

                                                                                                          I can, but I don’t want to.

                                                                                                          Same. Rewriting my Makefiles is so annoying, that so far I have resigned to just calling gmake on FreeBSD. Maybe one day I will finally do it. I never really understood how heavily GNUism “infected” my style of writing software, until I switched to the land of the BSD.

                                                                                                        3. 2

                                                                                                          What seems to irk BSD users the most is putting gnuisms in a file called Makefile; they see the file and expect to be able to run make, yet that will fail. Naming the file GNUMakefile is an oft-accepted compromise.

                                                                                                          I admit I do not follow that rule myself, but if I ever thought a BSD user would want to use my code, I probably would follow it, or use a Makefile-generator.

                                                                                                          1. 4

                                                                                                            I’d have a lot more sympathy for this position if BSD make was actually good, but their refusal to implement pattern rules makes it real hard to take seriously.

                                                                                                            1. 2

                                                                                                              I’d have a lot more sympathy for this position if BSD make was actually good

                                                                                                              bmake is able to build and install the complete FreeBSD source tree, including both kernel and userland. The FreeBSD build is the most complex make-based build that I’ve seen and is well past the level of complexity where I think it makes sense to have hand-written Makefiles.

                                                                                                              For the use case in mind, it’s worth noting that you don’t need pattern rules, bmake puts things in obj or $OBJDIRPREFIX by default.

                                                                                                          2. 1

                                                                                                            That this is so hard is maybe a good example of why portability to different dependencies is a bad goal when your dependencies are already open source and portable.

                                                                                                            I mean, technically you are right, but in my opinion, you are wrong because of the goal of open source.

                                                                                                            The goal of open source is to have as many people as possible using your software. That is my premise, and if it is wrong, the rest of my post does not apply.

                                                                                                            But if that is the goal, then portability to different dependencies is one of the most important goals! The reason is because it is showing the user empathy. Making things as easy as possible for users is being empathetic towards them, and while they may not notice that you did it, subconsciously, they do. They don’t give up as easily, and in fact, sometimes they even put extra effort in.

                                                                                                            I saw this when porting my bc to POSIX make. I wrote a configure script that uses nothing other than POSIX sh. It was hard, mind you, I’m not denying that.

                                                                                                            But the result was that my bc was so portable that people started using on the BSD’s without my knowledge, and one of those users decided to spend effort to demonstrate that my bc could make serious performance gains and help me to realize them once I made the decision to pursue that. He also convinced FreeBSD to make my bc the system default for FreeBSD 13.

                                                                                                            Having empathy for users, in the form of portability, makes some of them want to give back to you. It’s well worth it, in my opinion. In fact, I just spent two days papering over the differences between filesystems on Windows and on sane platforms so that my next project could be portable enough to run on Windows.

                                                                                                            (Oh, and my bc was so portable that porting it to Windows was little effort, and I had a user there help me improve it too.)

                                                                                                            1. 5

                                                                                                              The goal of open source is to have as many people as possible using your software.

                                                                                                              I have never heard that goal before. In fact, given current market conditions, open source may not be the fastest way if that is your goal. Millions in VC to blow on marketing does wonders for user aquisition

                                                                                                              1. 1

                                                                                                                That is true, but I’d also prefer to keep my soul.

                                                                                                                That’s the difference. One is done by getting users organically, in a way that adds value. The other is a way to extract value. Personally, I don’t see Open Source as having an “extract value” mindset in general. Some people who write FOSS do, but I don’t think FOSS authors do in general.

                                                                                                              2. 4

                                                                                                                The goal of open source is to have as many people as possible using your software.

                                                                                                                I actually agree with @singpolyma that this isn’t necessarily a goal. When I write software and then open source it, it’s often stuff I really don’t want many people to use: experiments, small tools or toys, etc. I mainly open source it because the cost to me of doing it is negligible, and I’ve gotten enough neat random bits and pieces of fun or interesting stuff out of other people’s weird software that I want to give back to the world.

                                                                                                                On the other hand, I’ve worked on two open source projects whose goal was to be “production-quality” solutions to certain problems, and knew they weren’t going to be used much if they weren’t open source. So, you’re not wrong, but I’d turn the statement around: open source is a good tool if you want as many people as possible using your software.

                                                                                                            1. 4

                                                                                                              It’s true TCP/IP can be made better, and I’m glad someone out there is still trying.

                                                                                                              But how would you replace them? If you make a new protocol, you also need enough backbones to adopt and support them. Otherwise, all you have is an intranet.

                                                                                                              1. 2

                                                                                                                But how would you replace them? If you make a new protocol, you also need enough backbones to adopt and support them. Otherwise, all you have is an intranet.

                                                                                                                You can use tunnels, proxies, gateway hosts, and routers until the new protocol is available everywhere. This is what people did before TCP/IP was available everywhere.

                                                                                                                1. 4

                                                                                                                  But then, the new protocols will suffer all the weaknesses of the old ones. So why would anyone bother to use it, other than a few technical enthusiasts?

                                                                                                              1. 1

                                                                                                                Gallium Arsenide was also used in the Convex C2 and the Tera MTA.

                                                                                                                1. 23

                                                                                                                  Looks functionally neat and aesthetically pleasing, but my terminal emulator is definitely something that I want to be open-source. Also, I get the need for it for this particular software, but a privacy policy for a terminal emulator? Pass.

                                                                                                                  1. 5

                                                                                                                    LLVM 13 includes a new pass manager that significantly improves compile times in Rust: https://twitter.com/ryan_levick/status/1443202538099073027?s=21

                                                                                                                    1. 3

                                                                                                                      to be clear: this is not a new pass manager, just enabling the “new” pass manager by default. The “new” pass manager has been in llvm for years, but it is still difficult to find good documentation on how to use it. Hopefully, things will improve now