jaxrtech

Agreed, commenting assembly is bit different "environment" to explain the "why?". You're explaining why you're putting a value in a register vs why you're calling some particular API or whatever in a higher-level language. And then you have COBOL...

Well, it's a number in a ledger system somewhere (e.g. mainframe system, Oracle database, or what have you), with a lot of auditing, reporting, and procedures around changing that number. (Though, having an internal API to instantly get a new bank account number always seemed kinda funny to me).

Slightly related, I'd have to find it again, but I recall there was at some point an assembly level hack on some Oracle database holding core banking in one country.

Isn't half the problem in the U.S. at least, we don't have a legal differentiation between political commentary and "news" as in reporting the facts as they are?

Well there are pros and cons selling at a loss

Can also say that the SQL implementation in Access is reprehensible in terms of silent errors and other weirdness.

Absolutely. I've also seen my fair share of horrendous home-grown "ETL" programs that waste more time shuffling bytes to and from database with poor ORM queries in loops, that could be done with a couple half decent SQL queries.

Probably the most useful things for me was learning relational algebra in college, and having been thrown on the deep end on a team that was very SQL heavy (not withstanding attempting to debug Oracle PL/SQL syntax errors while pulling your hair out about a missing closing parenthesis -- of which isn't the problem).

The usual challenge seems to be fetching data from external services or performing complex business that may conditionally load things -- things that can be awkward in procedural SQL. At the end of the day, you're building a messy ad-hoc dependency graph that is being manually executed very inefficiently. Would be better to just have your code just describe the dependency graph and treat each value transparently as a promise/future and then have a separate engine execute it.

Anyhow, something something monads with lipstick, I digress...

ngl the borrow chicker is miles better than it used to be in terms of implants cit behavior and just dealing with more "natural" scoping patterns. It sure isn't perfect, but at the end of the day, I trust the borrow checker more than my logic to make sure that multi threaded applications do not have threading issues...

The only thing that worked for me was: - Hit Ctrl + Shift + Del (TIL this exists) -- which will open the "Clear Recent History" dialog - Select under the down "Time range to clear": "Everything" - Select at least "Cache" and "Offline Website Data"

> The centralization of apis (infura, opensea and ethscan used by metamask) is the biggest problem. I could be wrong, but I don't think we've seen that fast consolidation in other early tech. I remember in the late 90s there were a number of search engines but no one really owned the space. Only 20 years later did Google emerge as the winner and is (IMO) by far the best in terms of relevant results. But that didn't happen overnight, and there wasn't a search engine dominating 90% of the market within a few years of the beginning of mainstream acceptance.

> How hard is it to create a competitor to infura? MetaMask should be incentivized to do this as they're core offering is controlled by one party.

> [edit] Never mind, metamask and infura are owned by the same company (ConsenSys). It's even worse than it appears...

Currently working in the space (graduated from doing systems-level . My hot take is what is considered a "full node" can potentially use significantly less resources. The base word size is 256-bit (size of SHA256), most is either 1s or 0s, the entire raw Ethereum blockchain is roughly 350 GiB uncompressed, probably can be much better with zstd compression on multi-core. Let's just quietly ignore that most is not using an assembly-level optimized implentations of uint256 arithmetic operations. Also all the current clients (a) afaik run transactions single-threaded, and (b) no on-disk compression, (c) at best use mmap relying on OS level paging even though you're going to have 32-byte random reads invalidating entire 4K or 16K pages out of ~3TiB of read/write space. I'm more than certain execution can be ran speculatively using STM (software transaction memory). I seriously doubt that most Ethereum transactions within a single block have that much r/w contention if you were to execute them in arbitrary order in parallel. Basically application level speculative execution (except you know the ending hash ahead of time, so you know of the ending state is valid or not). Anyhow...

At a previous job was looking at different binary parsing methods. This project looks quite interesting having binary format descriptions in YAML that then can be generated into your language of choice.

https://formats.kaitai.io/png/

> Re-write your code. Re-do your projects. Start from scratch. Let a new team try on their own. Software has such tremendous leverage, it’s way more valuable to do one thing twice than to do two things once.

Well I guess creating a gajillion prototypes is actually worth something -- learning what works and what doesn't allowing you to create a proper base for what actually sees the light of day.

Is it more of a problem of regulation not keeping up with modern developments? Or draconian requirements that got implemented once several decades ago to spec and now no one wants to poke it with a 10ft pole? I guess both apply to most heavily regulated industries that have any level of technology involved.

> Us-East-1 took out commuter rail travel in Chicago for like a good 30 minutes, so not just companies

Was it Metra or the CTA out of curiosity?

I currently work in the crypto space (views are my own). For the life of me, I cannot understand why we do not have a foundation built on something like TLA+ or the Z3 theorem prover instead of paying another human to try and poke your code for thousands of dollars. Maybe formal methods wouldn't be a silver bullet, but it seems a lot better and less error prone than manual review. Or maybe adopt existing knowledge from safety critical environments (e.g. programming brakes on a locomotive).

I always feel like we're making mistakes that tangential areas of software engineering must have already solved. I guess devs tend to also not like math or writing proofs either, which is ironic given this is "crypto" lol.

Honestly, this reminds me of the case of the rating agencies during the 2008 subprime mortgage crisis[1] (with rating agencies rating CDOs of "junk" loans as now magically AAA)[2]. Practically speaking, these rating agencies were incentivized by the firms paying them for the ratings to rate -- and now a la Yelp and Glassdoor can be added to that list...

[1]: https://en.wikipedia.org/wiki/Subprime_mortgage_crisis

[2]: https://en.wikipedia.org/wiki/Credit_rating_agencies_and_the...