3 ms·
Anyone who works on a large system written in any paradigm can see the same "disaster" -- at least so far[1]. What so far differentiates paradigms that claim th
by pron 11y ago
Anyone who works on a large system written in any paradigm can see the same "disaster" -- at least so far[1]. What so far differentiates paradigms that claim they are immune to those problems (or other problems with similar severity, some of them perhaps unknown as of yet) is that they have never been put to the test on projects of the same magnitude (i.e., same codebase size, same team size, same project lifespan[2]), let alone in enough problem domains, so they haven't had a chance to encounter "disaster inducing scenarios", and therefore haven't reported disasters yet. What we have now is paradigms that we know to be problematic -- but also effective to some degree (large or small, depending on your perspective) -- and paradigms that we don't know enough about: they could turn out to be more effective, just as effective or even less effective (or they could be any of the three depending on the problem domain).
How can we know if we should switch to a different paradigm? Empirical data. So please, academic community and the software industry: go out and collect that data! Theoretical (let along religious) arguments are perhaps a valid starting point, but they are ultimately unhelpful in making a decision. In fact, it has been mathematically proven that they can contribute little to the discussion: the theoretical difficulty in constructing a correct program is the same regardless of the abstractions used[3]; only cognitive effects -- which can only be studied empirically -- could provide arguments in favor of a certain paradigm making it easier for humans to write correct code.
[1]: As someone who worked on software written in procedural code before the popularity of OOP, it wasn't any better (actually, it was worse). For contemporary examples, see Toyota's car software.
[2]: Those are, of course, proxies for "very complex requirements, both functional and structural", but the point stands.
[3]: The cost of verifying/constructing a correct program is at least linear in the size of the program's state-space (or, more precisely, its Kripke structure, which also includes transitions) regardless of representation in code or abstractions used to make it more succinct. E.g., "Kripke structures that admit a succinct representation are not simpler for model checking purposes
than arbitrary Kripke structures" (http://www.lsv.ens-cachan.fr/Publis/PAPERS/PDF/Sch-aiml02.pdf http://www.lsv.ens-cachan.fr/Publis/PAPERS/PDF/Sch-aiml02.pd...), and model checking can be reduced to any other verification/construction methodology.
- loup-vaillant 11y ago> [2]: Those are, of course, proxies […] Someone is defending against some pedantic stalker… :-)
- pif 11y agoVery well said! Bjarne Stroustrup resumed with: "There are only two kinds of languages: the ones people complain about and the ones nobody uses."
- danieldk 11y agoThat quote is often cited, but it stymies the discussion. First of all because there are counterexamples. E.g. I think SQL is generally well-liked for its domain and widely used. Secondly, even if we complain about languages that are used, we can still distill and compare pros and cons. Speaking of C++ specifically - once Rust is in wider use, people will probably complain about it too. But we can describe in what regards Rust is safer objectively.
- js8 11y agoI don't like SQL. I think there could be a worthy successor to it. Something functional, typed, Haskell-like. Something that can incorporate other data processing paradigms, such as ETL, stream processing, map reduce and so on.