I might have been unsure if you were running copyrighted code, but now I know for sure you stiffed a programmer and are trying to cover your ass after the fact.

As a professional consideration, I won't be using any of your services. Failing to pay an appropriate invoice for services rendered to you is a serious black mark for a company, particularly to people who depend on contract work to make a living.

Finally:

> Our agreement with the poster makes it clear that we own all work product produced pursuant to the agreement

I suspect that this is only true in the event that you completely paid the programmer. Failing to do so likely invalidated the copyright transfer, which is standard language to include in a contract.

I also suspect that the code you're currently running is not a clean rewrite, meaning that the next programmer based his code on that code and likely didn't remove literally every piece of it from the code base before starting.

This very easily could have left your company with liability regarding the code you're no longer using, because the formation of your current code base depended integrally on violating the copyright of the programmer you didn't pay.

I suspect you should just shut up and stop making a bigger deal of this in public, and that you should ask your lawyer point blank if the cost of fighting over the liability you might not have properly controlled will be cheaper than just paying the rest of the programmer's fee.

There's no way they have any good faith belief they own the copyright to (or are authorized by its holder to act in their stead about) the material explicitly named.

I'm just going to assume that their lawyer is smart enough to not have filed a DMCA notice, as such, and just send a thuggish letter instead.

You certainly can write similar code in ML, Java, or C - or whatever language strikes your fancy. It just helps when the type system is lined up with that goal, such as forcing you to denote where side-effects occur, and ensuring only functions that expect side-effect based code can operate on them. (For what it's worth, I've used both ML and Scheme to write similar style code as part of a programming languages class; and similarly, the C code I write relies on the functional ideas as much as possible.)

I just like the combination of Haskell's syntax and type system, so I prefer it to something like C (where functions aren't exactly a first class datatype, and the type system is somewhat weaker).

At the end of the day, you still write some stateful, imperative code.

It's just that your utility/work functions are pure, which means that you have predictable side-effects: you've stuck them all in one (imperative) place, or perhaps a couple places, but you're guaranteed to know where they are because the type system enforces notating which code has the ability to cause side effects. (Makes it easy to grep on type signatures, for example.)

Most of my workload is dominated by high level concerns: correctness, large-scale data flow, coordination of state, and security.

The purity of functions means that I explain all of the constraints/solutions of those problems in pieces, which I then compose with a clear data flow between them (since they can't have shared, mutable state), and only at the end, lift them to operate on the state of the system (in a stateful, imperative block).

This way of programming gives me much more confidence in replacing pieces of the code without worrying about the side effects, because the side effects are predictably related to that code.

At the end of the day, that predictability of side effects makes the majority of my work MUCH easier, even if it adds complexity to some low level data manipulation.

I easily write 10x the high level code I do low level code, so a 20% savings on that code, even if I double the complexity of low level code, is a net savings on my time/effort.

tl;dr: Functional programming is a productivity booster if most of your work is of a high level nature, even if it makes low level manipulations harder to do. Interfacing with low level imperative code can be (and is) regularly done, to get the best of both worlds.

Before it was varying levels of unprovable (ie, not photographs or verifiable sources) and bandwidth limited (people could only store so much information; sources weren't interlinked for quick queries).

So it's actually quite likely that when we drafted our laws, this was an implicit right by the nature of technology, and considered a natural part of the bounds of specifically enumerated rights.

We should make sure, as technology removes traditional limits on what we can do, that we adequately adjust our laws to reflect that change.

It's not like the claim was about just any beam of light.

How are these any different?

Even if they are contractors for specialized policing (something I find dubious, but am not sure is actually a bad idea), why wouldn't they still be subject to regulation as government employees while performing government work?

It's very simple to build a function which doesn't have to understand the possible dimension conflicts and lift it to work on this new type, returning an either (or a maybe, if there's only one failure mode) in place of a definite value.

It's also very simple to propagate such errors forward, so they'll short circuit a computation when you have non-matching matrices used in a calculation that's multiple steps.

In Haskell, I don't have to remember to write special functions which guard against this: I write functions that operate on the matrices and add the guarding at the very end. I can ensure that all my calls use the guarding functions, because they have a different type signature.

Trying to do this same thing in Python require that I remember to always use the guarded calls, and doesn't have as clean of an interface to create the guarded functions from standard functions.

It would only take a local wage initiative, for instance, to likely bother the closest Walmart. So there's an inherent incentive not to let prices rise so much that people are angry enough to get the government involved because they can no longer buy milk (or food).

If Walmart has enough local monopolies, this is a self-reinforcing strategy, since it's unlikely all of the monopolies will be challenged at once, and Walmart can thus have a few of them with unusually low prices while the rest sustain that one during the conflict (since they're guaranteed to have business, being the only store in town).

This kind of unequal distribution can cause the slight lessening of pain for a large number of people to mortally wound the few actually producing content, leading to a serious destabilizing of the market, which requires that both parties have something to provide.

Which was the point of the GP comment, and something you didn't even remotely address, instead making a pedantic point about words chosen for effect.