153 karma · joined July 11, 2020
What I wonder more about is our own guys: how does manning and Snowden walk out the door with this info anyway? Our search procedures apparently suck.
For the record my assessment of our involvement in Iraq is not kind: we should have escalated to armed intrusion to vet wmds base by base instead of invading wholesale on the reason Iraqi's were evasive. Second torture is unamerican, not reliable, and wholly wrong. Not proud at all of what we did here. Our response before after 9/11 was incompetent.
"the whole point of crypto was to break the pyramid scheme of central bank planning and currency, yet here we are using it as a meta-pyramid scheme." and immediate following question:
"There’s a sense crypto has lost its way, but it also seems like our best hope of beating the current exploitative and extractive system."
In both there are unproven or unsubstantiated claims here. We're all vaguely aware banks lend fractions of deposits on the calculated risk that demand on those deposits never exceeds deposits. So what's the sense in which this is a pyramid scheme? And in what sense is central banking extractive?
Presumably the implied criticism is bank bailouts, and federal government's perpetual deficit spending as in the USA?
Here's a question they don't get into: do they store transactions on the cloud? If not, why not?
So what's the claim here? banks should have not wired money or the doj looked the other way and did nothing when there was suggestion of fraud?
The point is that strongly ideological bents (here coming from Religion) tend to conflict with economics. Correct, CCP is not a religious organization rather eschewing it. But what they both have in common is that economic activity is secondary and non-strategic. Or as another HN article put it quoting Drucker: "Culture eats strategy for breakfast."
I work in a very large C/C++ organization and the build concern over our 1000s of libraries is a giant chore to do well in a DEVOPS context. GO is so much better. RUST is routinely seen worse than GO here. Compilation is slow but anecdotally dependency management in RUST is orders of 10 better that C/C++ and comparable to GO.
There are a few stories in HN where cloud providers, big data types have been burned by GC. But it's not routine. Their ability to find and fix root cause required in-depth diagnostics. If your system is complex your tooling better have good support there. GO definitely does.
Here's what I say: if you are I/O bound GO is just fine. GO has great libraries for all manner of HTML/socket work. It works well with protobuf, compression, REST APIs, UUIDs. Its SQL library is great.
If you are low latency bound or need latency in a narrow range you'd better do a POC in GO and RUST and make an informed choice. There's plenty of GO programmers and fewer good RUST programmers.
There are more HN posts from people learning RUST reporting the borrow aspect of RUST is tough to learn and tougher to do right. RUST kind of memory management isn't routinely found in other languages.
RUST is meant to be a better C++. It's meant to excel in the niche area of system like libraries by yielding C/C++ performance without memory C/C++ memory problems which are perhaps the largest security attack area. RUST will not remove all data races. It reduces them - which is good - but do not over interpret. In this sense RUST is smart: they've picked a good market, and their tools make good sense there.
C++ is not necessarily the go-to for bare metal programming. So neither would RUST be. Most of the Linux kernel is C not C++, for example. We know that calling C-libraries from a non-C language is routine. To RUST? Not sure. To C++? That's a harder ask but you're probably not the only one who's doing it - at least that.
Part of the appeal of GO is simplicity: get some things down in a minimal yet complete way then consistently do it on the strength that it's a net-win: less complexity to learn that takes you further in most cases. This isn't the only game in town, but it is a good game. C++ is different: we've got 21 million ways of doing things, but you only pay for what you use. That's fine too if you know what you're doing.
Back to GO: The fact that the real world is wishy-washy here sometimes in the mood, sometimes not, sometimes I like blondes some days I like brunettes other days isn't the go way ... is a sometimes depressing part of DEVOPS: not formal. It's not the GO way either.
So I think GO's standpoint that changing something to explicitly ask for a breaking change isn't out of line. It can't be that tough of an ask to mean what you say and say what you mean when we label code with a semantic version.
Both this post and the other V2 problem GO post fail to better get at the crux of the problem: In GO there are two names:
- the path we import in code
- the actual GIT URL (or vendor ref) down to tag/commitId in go.mod that the previous item ultimately resolves to
The module name in code is ambiguous. It's desirable to some that code is unchanged ever wrt to imported module name. If true, then we must turn our attention to what's in go.mod. Here the ask is for hints that there's a breaking version available ... and it'll be up to the DEV to use it or ignore it changing go.mod as they deem makes sense.
If false, then you've gotta change the code to reference the breaking version if that's the desire ... realizing it's still ambiguous because it doesn't resolve down to a commitId or tag ... so that leaves go.mod on the table for change too.
Nobody debates that code must change to reflect breaking changes if the breaking change is included in go.mod. The questions are: did we ask? Where? Did we know there's a breaking change, and can't we get some help knowing there's a breaking change since GO hits GIT anyway?
At it's crux then ... there are two names. Leaving the code unchanged and changing go.mod with some tool help is better IMHO.
- help better diagnose where/why shift/reduce arises in the context of a given grammar
- argument if Prat or another approach entirely avoids shif/reduce errors.
Doing this well requires,
- requiring internal service suppliers to be (internal) customer driven. Too often however things we'd never put up with an external supplier we'd pay money for are tolerated and even protected by management. Internal suppliers are required for use. It's hard to fire them.
- cross functional management: reduce silos. Again my area and your area might be "clean" but users of both of our services are often left to die in the crummy alley way between our groups. That's a major source of frustration for engineers.
- promote openness and honesty: there's too much happy talk and PC correctness at the office.
- supply chain management: engineers are often confronted by too many point solutions that don't integrate. See above points. Managers need to cull and combine supply chains time to time.
- be customer in not supplier out. Older companies often have organizational norms where what can be produced is more a function of what internal politics allow or company culture tolerates than what customers want. Managers need to be on top of this.
- top management needs to give TLC to middle management perhaps the toughest job. Here they (middle mgmnt) cannot micromanage while they are held accountable for broad corporate goals like lean organizations, top line growth, reduce expenses, and better expense control. They neither are hands on nor are too far from the real work to be too abstract.
- teamwork (see schutz's human element the best single read on this) namely that ridgid individuals are the single fastest way to break teams. Today's work depends more than ever on good teams.
When managers do above well it's a pleasure to work with them. It's a difficult task.