This post makes your company look considerably less professional than it otherwise would have, even leaving allegations about code theft unanswered.
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.
Are you claiming that there is a difference in the class of problems that can be computer between an 8 bit processor and a network of 1 bit processors?
Wouldn't a properly formed DMCA complaint in this case be one of the few times you could commit perjury with one?
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.
All being a "functional language" means is that it's easy to write with a particular paradigm in the language.
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).
Your analysis ignores the key point that bacteria operate on simple rules based entirely on local concerns, which is not the proposed case in the sci-fi story.
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.
There's a distinctly 21st century flavor to being able to store all the banal life mistakes indefinitely, to dig them up later if we ever need dirt on a particular person.
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.
Except that the particular beams of light being discussed are intentionally meant by the broadcasters as resources for the public as part of fulfilling their deal to license the spectrum that beams of light useful for TV happen in, since the spectrum is fundamentally a public resource (hence open to anyone), and the exchange of public spectrum comes only in return for public usable content.
It's not like the claim was about just any beam of light.
The military and government in general makes extensive use of contractors for specialized tasks, but manages to audit and limit their behaviors to the degree that they're performing work on behalf of the government, recognizing that contracting out government work doesn't make it not government work.
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?
Haskell has a very neat interface for this, in that you build a special type which remembers the dimensions of a matrix as you build them, and then return either the result or a failure.
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.
What part of inviting a criminal you've gathered significant recorded evidence against (eg, their own telephone confession) to a place you can arrest him do you think violates due process?
The harm from the pervasive monitoring is greater than any benefit proposed: there's no need to run the trial to see if the benefit proposed is actually there, we already know it's outweighed by the harm.
I think there's a second element to why a gallon of milk isn't $20: Walmart relies on not upsetting too many people, who collectively wield enough local political power to harm Walmart locally.
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).
There are markets with no real viable alternative to Walmart, because Walmart used their scale to crush competition, and no has made it uneconomical to start a rival business, since they'll temporarily lower prices below sustainable (using their scale), then raise them again when the other store dies.
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).
Except that the hurt is widely distributed at the higher price, but not at the lower price (where it's felt by a few large publishers).
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.