5 ms·
Learned helplessness and the languages of DAO
- carsongross 10y agoAnd in the interim, let’s do everything we can to finally start to fix traditional programming. It is not a quixotic dream; it actually is possible. Once we just accept that, everything can, and I believe will, be better. This is literally magical thinking. Formally verifying software, being disciplined about not adding unnecessary features, favoring simplicity over sophistication, using the tried and true instead of The New New Thing: all of these require a huge amount of willpower and fighting against the entire grain of the tech culture. You will be branded a reactionary. You will be told you are stuck in the past. The person willing to promise marketing the moon will be promoted, you will be labeled "difficult to work with." It's pretty black pill, but, as with our government: we are getting the software we deserve, good and hard.
- jacquesm 10y agoThink of it as an opportunity. There is an insane amount of money to be made rescuing crashed projects built by people that were too focused on using the latest and the greatest tech rather than actually focusing on delivering what the customer asked, on time and within the alloted budget. And by the time the project has crashed those promising marketing the moon will be fired, and you'll be labeled 'the guy/gal that saved the project'. It's a pretty easy sell at that point, assuming the company survived the carnage.
- hinkley 10y agoYou will still run into a lot of sunk cost thinking, and they will assume often that you will deliver everything the charlatans promised them. Often it's the requirements that are the big part of the problem. Requests that defy physics aren't unheard of. Often the customer grasp how hard it is to change decisions in the structure after the fact. And what they have learned from this is to demand that everything in the system be "flexible". Which is how the giant white tower over engineered fiasco that preceded your arrival happened in the first place. Infinitely flexible software requires infinite test infrastructure. Nobody teaches that, and many don't even recognize when it's happening to them. My observations suggest that most don't learn from the mistake. they blame the failure on the preventable mistakes in execution they imagine were under their control and they just try harder the next time.
- nxc18 10y agoIt sounds like wherever you work/live there is a pretty toxic dev culture. Software development is primarily about managing complexity. Think about the mountain of abstraction after abstraction between your "new new thing" angular 2.0/react app and the machine instructions that are being executed in hardware. A huge amount of software work is done just to make your life as a developer simpler. Its crazy that so many willfully make their software more complex than it needs to be. Not adding unnecessary features is always a no-brainer. Do you really have time to waste building something no one will use? A good product person can help teams with less experienced engineers avoid building the most technically challenging feature that happens to be useless.
- jasode 10y ago>Everything is terrible because the fundamental tools we use are, still, so flawed that when used they inevitably craft terrible things. This applies to software [...] like the $150 million Ethereum DAO catastrophe. [...] >In principle, code can be proved correct with formal verification. Formal verification is not applicable to the DAO hack that lead to some humans to decide on forking the blockchain. Correctness in that example was in the eye of the beholder and from the perspective of the hacker that received the digital currency, it would have been formally verified as "correct".
- pron 10y agoI don't know the details, but I doubt this is true. In this case, correctness was "in the eye of the beholder" simply because they decided that the code is the contract. But when you formally verify, you can specify a set of safety properties, each usually very simple, and expressed in a line or two. Of course, you could miss a critical property, but it's very likely that you'd add at least some sanity properties that would catch most heists like this (e.g., "no more than 2% of the money can end up in the same account", or something like that).
- jasode 10y ago>, but it's very likely that you'd add at least some sanity properties that would catch most heists like this (e.g., "no more than 2% of the money can end up in the same account", or something like that). And then new Solidity programming code that moves 1.9999% of the money into a single account gets passed. The hacker who exploited the 2% threshold to his advantage thinks it's formally verified as "correct." The people who "lost" their money thinks it wasn't "correct." Add new verification "rules" in an attempt to close a loophole, wait for the next exploit. Rinse and repeat. Solidity programming code all by itself can't serve as the ultimate authority for smart contracts.
- pron 10y agoI think you'd agree that a 2% heist is better than a 60% heist. BTW, I don't advocate automatic contracts (personally I think the whole premise is dumb and misunderstands what a contract is), nor do I claim that formal verification is easy. It takes practice to know what to verify, at what level, and how to trust the results. But if it is used properly, it can really help.