Why not? What tone would you take if you wanted folks to regret posting unpaid advertisements?

I would rather use Magic Wormhole if I have to have an intermediate server operated by somebody else.

Your protocol isn't documented enough to allow interoperability. It is important for folks to be able to develop their own clients and frontends; the ecosystem becomes richer and more resilient to attacks when there are many different implementations.

I'm not sensing an awareness of capabilities. Access to a file is one of the classic examples of a capability and a file-sharing system should be oriented around ensuring that references to files are unforgeable and copyable.

The terms of service are unacceptable and I won't be trying out the product. I can point at exactly what's wrong; talk to your attorney for details.

Users are expected to respect the intellectual property rights of others when using the app.

You don't understand what file-sharing technology is used for.

We reserve the right to introduce tools and technologies for monitoring the performance of the app and improving its functionality. By using the app, you acknowledge and agree to this potential monitoring.

Ah yes, because telemetry has never been met with user backlash.

The company does not collect user data, apart from what is needed for monitoring tools to ensure the app's stability and to make improvements.

You don't need user data for that. Y'know what's a lot easier? Just don't collect user data!

We may also use Sentry.io for error monitoring and NLevel Software for analytics.

I block those.

The app may include functionality to report users, and we reserve the right for this functionality to send necessary details for any investigation.

Ah yes, completely fair that somebody accused of misbehavior gets their local data exfiltrated too.

Meanwhile Magic Wormhole merely tells us that it is MIT licensed and we can do whatever we like with it.

And here we see the self-Godwin in the wild. Masterful play, sir.

Neither the CFO nor CEO are saying that Google ought to be not broken up. They are saying that Mozilla existentially depends on Google. This is actually more of a central point in the lawsuit than you think; in the original complaint, part 6 of the background is about revenue-sharing agreements (RSAs) between Google and various other companies who would normally compete in search, browsers, and other venues. That is, nobody is disputing that:

Today, Google has RSAs with nearly every significant non-Google browser (other than those distributed by Microsoft) including Mozilla's Firefox, Opera, and UCWeb. These agreements generally require the browsers to make Google the preset default general search engine for each search access point on both their Web and mobile versions.

If Mozilla did want to petition the court, then they are welcome to file as amici, but they haven't! Nor have any court filings included a reference to the CFO's testimony so far, although to be fair the testimony isn't yet available to read. There is no evidence that Mozilla will stand in the way of whatever the court decides to do with Google. Rather, in their post, the CEO is asking lawmakers to figure out some way to ensure that the browser market remains competitive:

Mozilla calls on regulators and policymakers to recognize the vital role of independent browsers and take action to nurture competition, innovation, and protect the public interest in the evolving digital landscape.

Courts aren't regulators or policymakers. The complaint before the court is not the same as the underlying principles of antitrust which motivated the complaint. A request to improve the future is not the same as a request to forestall the present.

The author would do well to look up SGML; Markdown is fundamentally about sugaring the syntax for tag-oriented markup and is defined as a superset of HTML, so mistaking it for something like TeX or Word really demonstrates a failure to engage with Markdown per se. I suppose that the author can be forgiven somewhat, considering that they are talking to writers, but it's yet another example of how writers really only do research up to the point where they can emit a plausible article and get paid.

It’s worth noting that Microsoft bought PowerPoint, GitHub, LinkedIn, and many other things—but it did in fact create Word and Excel. Microsoft is, in essence, a sales company. It’s not too great at designing software.

So close to a real insight! The correct lesson is that Microsoft, like Blizzard, is skilled at imitating what's popular in the market; like magpies, they don't need to have a culture of software design as long as they have a culture of software sales. In particular, Microsoft didn't create Word or Excel, but ripped off WordPerfect and Lotus 1-2-3.

Forget about your job for a moment. In general, why are you willing to set a threshold on how accessible your work is? I urge you to forget about how callous your employer wants you to be.

across the Internet ... doesn't require storing data twice

A flavor of the CAP theorem applies here; if you want your data to be available even during network partitions (and those are going to happen on the Internet!) then it has to be duplicated somehow. For example, I still have a soft spot for Tahoe-LAFS, which allows users to control how much duplication will be used and typically is configured to have some redundancy. Typical cloud providers build redundancy into their storage products; for example, it's known that Google's Colossus storage system uses Reed-Solomon to trade space for durability.

Pick a language like Perl, where some packages are written in C and some are written in pure Perl, and you'll get to experience the same cryptic GCC errors, sometimes. There's no secret to pip; many Python developers upload wheels with pre-compiled binaries, including Windows-compatible binaries, and so you don't have to run GCC because they already did it for you.

I'm a fan of putting factored expressions into their own files and importing those files as NixOS modules. For example, let's say that we want to install vim. We might start with a vim.nix:

 undefined

        { pkgs, ... }: {
      environment.systemPackages = [ pkgs.vim ];
    }


  

Then in the main configuration, this can be imported by path:

 undefined

        {
        imports = [ ./vim.nix ];
    }


  

Adding the import is like enabling the feature, but without any options or config. Later on, the feature can be customized without changing the import-oriented usage pattern:

 undefined

        { pkgs, ... }:
    let
      vim = ...;
    in {
      environment.systemPackages = [ vim ];
    }


  

Since the imported file is a complete NixOS module, it can carry other configuration. Here's a real example, adb.nix, which adds Android debugger support:

 undefined

        { pkgs, ... }: {
      programs.adb.enable = true;
      environment.systemPackages = [ pkgs.pmount ];
      users.users.corbin.extraGroups = [ "adbusers" ];
    }
  

Good notes. Another trick is to replace /etc/hosts (which is usually a symlink to /etc/static/hosts) with a custom file; for example, copy all of the hosts from /etc/static/hosts and then add new hostnames for the failing caches. This can turn an indefinite network timeout into a fairly quick connection-failed error.

Personally I think it's a design deficit in Nix that is compounded by the serial, one-at-a-time, timeout-based way of operating. A Nix implementation should have a sense of trading off disk, bandwidth, compute, and time; a substitution should only be preferred when it is likely to save at least one of those resources, and abandoned if it isn't making progress.

Nah, just use direnv instead, comrade.

"For the record, I still don't like this particular face-eating incident." As if you aren't a leopard enthusiast. Who cares whether you like something?

You literally attach a license to every comment you post. The rules which make that license effective are the same rules which make Free Software and open-source licenses effective, too. Show some solidarity; you're part of the community too, and you should feel comfortable making the same demands as the rest of us. When you say that "open source defenders" are distinct from "developers" you are contributing to a schism for the sake of aggrandizing employment and exploitation.

This week (likely most of the month) I am rebuilding a backup process which appears to currently rely on Syncthing and hasn't been tested in years. Everybody got to put in their opinions, so I need to design something which has a single source of truth, also has 3-2-1 replica counts, takes snapshots of the production DBs without degrading them, and burns a monthly DVD on a workstation in the office. Once I'm done with that, I get to look at the office VPN's performance problems.

If you were creating a new programming language from scratch, there's no clear agreed answer to what error handling approach you should pick, not the way we have more or less agreed on how for, while, and so on should work.

I think that they don't talk to enough language designers. Errors-as-values is the correct model because it eventually leads to the understanding that errors are our opinions about the state of the machine rather than an actual failure of the machine's invariants, and the permanent divide between recoverable-yet-undesirable "error" states and genuine faults in the hardware. All other error models persist due to inertia and machismo.

This doesn't mean that exceptions have to be removed from languages, but rather that we should think of them as continuation-passing or stack-controlling operations which perform non-local jumps; they're part of the structured-control-flow toolbox along with break/return/continue jumps. Going in the other direction, a language designer need not add exceptions if they intend to add call/cc instead.

You'd be left to evaluate trade offs in language design and language ergonomics and to make (and justify) your choices, and there probably would always be people who think you should have chosen differently.

Yeah, but Sturgeon's Law never stops; most new programming languages are fundamentally not interesting because they are either garbage-collected Algol-descended languages or memory-unsafe. Meanwhile, sum types can always be added to simply-typed lambda calculi without invalidating any safety properties. If you argue in favor of mediocrity, you're gonna get Golang instead of something good.

Shit, I didn't realize you were so young. Back in the 90s, before 9/11, none of these disclosure requirements existed; only a customs declaration was required to enter the country, and the naturalization process consisted of paying a fee, taking a test, and swearing an oath. We used to associate this sort of disclosure requirement with petty kingdoms like Bahrain or Thailand, where there are laws against insulting the monarch and therefore a justification for thought police. We shouldn't let any of the four presidents who have slid us into fascism avoid the blame.

For what it's worth, most of your comments aren't eligible for copyright; they aren't sufficiently original or information-packed. Just like @onlinepersona@programming.dev and their licensing efforts, it's mostly a vanity to attach a license to unoriginal one-line throwaway jokes. I wouldn't say that it's arrogant so much as lacking in self-awareness; a one-liner must be deeply insightful, contain a pun or paraprosdokian, address the current zeitgeist, or otherwise be memorable above and beyond the time and place that contextualized it.

As a relatively heavy solution, you can use a container orchestrator that understands a failure to pull an image as a temporary or transient situation. The lightest orchestrator that I've used on NixOS in a homelab is k3s:

 undefined

        services.k3s.enable = true;


  

It is more-or-less a cut-down Kubernetes, and as such it will not fail to start merely because one Pod had an error pulling one Image. It will also offer a path forward if you want to continue building up software-defined networking.

That all said, I'd re-examine what you want from service isolation during OS upgrades; it's possible for routine NixOS updates to only restart affected services and not reboot. In production, nixos-rebuild switch can do things like upgrade shared libraries, switch webroots, or flip feature flags. Containerization might be unnecessary overhead, and I say that as a Kubernetes proponent.

Become a kernel contributor first. I don't think it's acceptable to stand outside a community and ask how you can control it by throwing money at it.

Reading between the lines, the documentation has the key:

Generic instances … correspond to Semigroup and Monoid instances defined by pointwise lifting.

In more words: each generic type can be broken up into a tuple-like row of components, and the generic type admits a monoid/semigroup whenever every component in the row admits a monoid/semigroup. In your handwritten Semigroup instance, the given code is agnostic as to the types of variables and functions; all that matters is that they already have Semigroup instances of their own.

Let me answer the other question: where's the monoid in the generated Rep? Well, there isn't one! The Rep merely has a struct-like product of component types. If a monoid exists for each component, then a monoid for the entire struct exists (and is built from the obvious pointwise lifting!) but otherwise there isn't a monoid derived from the struct itself. This should be a notable contrast from generic instances for e.g. Functor, where every Rep has exactly zero or one Functor due to the algebra of the semiring of types (there is an underlying algebraic equation with at most one possible solution.)