1. 6

    I have mixed feelings about this. No longer mixed because of how yeah, this just seems very disrespectful.

    Mostly, it can be summed up as “can you just not?”

    This project is famous because of why it came to be, and who created it. It was the result of Terry’s mental illness which was also the unfortunate cause of his death. Trying to piggyback on it feels incredibly disingenuous and almost disrespectful, especially given the circumstances around its creation.

    Let it rest with Terry.

    EDIT: I completely forgot about that description - “A TempleOS distro for heretics” - this just sounds incredibly disrespectful.

    1.  

      Trying to piggyback on it feels incredibly disingenuous and almost disrespectful, especially given the circumstances around its creation. Let it rest with Terry.

      I think that on contrary, we should use, study and think about the lessons Terry gave us in form of the Temple OS. There is nothing disrespectful in trying to build on his legacy.

      1.  

        I agree - Terry didn’t take his software with him to the grave - he shared it with the world and made it public domain.

      2.  

        It was released before Terry’s passing

        1.  

          That doesn’t change much.

      1. -5

        <sarcasm>

        The natzi forked this, I think it should be banned :S

        </sarcasm>

        1.  

          Whether or not I agree with your position, bringing another dumpster fire in here is counterproductive. If you have an issue, take it up with the other mods.

          1.  

            Yeah, sorry about that, I agree, it was a “necessary evil”.

            1. -5

              Yeah…

              This is referal to my post which was deleted becasuse Google employee thought I am supporting nazis, so started to molest me with messages such as:

              • Were you aware of the repo owner’s apparent support for Nazi ideology, when you posted the link?
              • Nazis very much intend to kill everyone I care about, and millions of others, if they ever acquire the power to do so

              Its obvious that this kind of behavior is actuall fascizm. Not to mention that second one sounds like invented by 10 year old kid.

              I care none about things random people do in the world in their spare time even if it includes nazis or feeding street rats.

              This not that place.

              1. 5

                This not that place.

                This is also not the place for whining about mod decisions or insulting mods for not liking Nazis, so…

            1.  

              I liked this tweet from the @chatur_shalabh

              Interesting stuff.

              “Objects are self-describing.”

              “Binary objects and arrays have a special “type” slot that must contain a symbol reference. This slot is used to attach type information to these objects.”

              “There are no “windows”, just views that look like windows”

              1.  

                I want to write an article on this topic for a long time, because I’ve noticed same problem as you. I’ve even seen people talking about how python is not good language for running the production.

                1. 8

                  The reason for UNIX-like OS’s having low level abstractions like byte streams, filesystems of blocks/inodes/directories and hundreds of other like things, was to retain the efficiencies of the low level machine exported to time multiplexed processes on a single processor, where you could build upon them whatever complexity you’d like.

                  Many OS types I knew from the 69’s-70’s never even saw a LISP Machine (LISPM) OS, nor had much contact with such systems that never had any interest in retaining low level abstractions, because those users were more interested in high level abstractions to be fleshed out rapidly so they could be used on the machine, and then as they were used, they would be refined to make them efficient enough.

                  We’re in a very different universe of multicore, cluster, and cloud, where you can buy all the cycles you want in the world for the nanoseconds you might need them. Waiting to code/debug/process/parallelize high to low level to run on a low-level OS takes more time than the high level abstraction itself needs to function. So there is “anti-efficiency” many face.

                  Why is this happening? Well … standards. Like POSIX. Now that we’ve finally made them work, they can’t be replaced, too much depends on them. And, unlike on LISPM’s, you can’t just rebuild the APIs on the fly to suite your need, because several billion others need to work with them at the same time, and they want to build there own differently for both good and bad reasons.

                  There’s no escape through metastandards either, because that evasion will be countered in turn by efficiency arguments (which are mostly specious because people work off of fear and not measured, pragmatic study because that takes considerable talent/skill/work, which often isn’t valued as much as it should be).

                  We are at a crossroads where we need something to break the logjam w/o being sucked back into to old standards, but since no one trusts anyone to do it, it never goes anywhere. Such is what happens when the free OS’s sucked all the air out of OS research decades ago because it was no longer necessary, because the truth of a common low level OS was all we would ever need.

                  Well guess what, we have it now, and by golly its nowhere near what we need for the future.

                  1. 1

                    Well guess what, we have it now, and by golly its nowhere near what we need for the future.

                    Its also nowhere near to what we need for now. I literally created (and still create) same abstractions over and over again just to get away from this.

                  1. 14

                    The Newton OS was based on some similar thinking to this, though not the networking part, because nobody had a network back then!

                    In Newton OS you store the language-level objects (which are key/value containers kind of like JavaScript objects) directly in the not-a-filesystem object store and retrieve them (by content, not by name). Those stored objects could be executable — a function is just a simple object with a few slots, one of which is a blob of bytecode. We had some further ambitions for when the hardware got bigger that we didn’t get to realize.

                    If you google for “persistent object systems” you can still see a bunch of the papers we were reading back then. It was a hot topic for a while.

                    To quote my ancient overview paper:

                    The object store has many advantages over a more traditional filesystem. Applications do not need to implement their own methods of translating objects between runtime form and persistent form, so they are smaller and easier to write. It is very easy for Newton applications to share data, since they all get the same high-level interface to it; we encourage developers to share their persistent data structures to foster the creation of highly cooperative applications.

                    1. 4

                      Thanks for reminding us of the Newton (and for your creation, NewtonScript). I really like the name for the object store… ‘soups’. I had a message pad 1000 and it was a system way ahead of its time.

                      1. 2

                        I’ve read Object-Oriented Database Systems by Elisa Bertino & Lorenzo Martino (ISBN 978020162439), so I have some idea about object databases of the 90’s.

                        In Newton OS you store the language-level objects (which are key/value containers kind of like JavaScript objects) directly in the not-a-filesystem object store and retrieve them (by content, not by name). Those stored objects could be executable — a function is just a simple object with a few slots, one of which is a blob of bytecode. We had some further ambitions for when the hardware got bigger that we didn’t get to realize.

                        That sounds kinda similar to Self. I’ll have to look into that.

                        The Newton OS was based on some similar thinking to this, though not the networking part, because nobody had a network back then!

                        Didn’t Newton used Telescript for this? Edit: hah, it didn’t, sorry.

                        1. 4

                          The NewtonScript data model and language were certainly influenced by Self. The object store was probably most strongly influenced by Eliot Moss’s work at UMass (e.g., Working with Persistent Objects: To Swizzle or Not to Swizzle). There was also a lot of pondering of various single-address-space research, but we never got to the point of using it. Well, now that I think about it, we did use a variation of it (not as clever) for 3rd party application packages.

                      1. 25

                        A number of the “wishes” in here were already in the BeOS, and of course now live on in Haiku:

                        Configuration files and their various formats exist because the filesystem can’t save a structure. If it could, you could just save a given object or dictionary, with all its keys and values, and you’d be able to use them directly next time you’d needed them. … When a program needs to send data to other program, it doesn’t send a serialized version, messages are not sent as stream of bytes, but as structured messages, natively supported by the OS kernel.

                        This mostly lines up with the “Messages and Ports” concepts in BeOS and Haiku.

                        Programs as collections of addressable code blocks in a database … Once you publish them, you stop having to communicate using the old stream-based methods (sockets, files, …) - it suffices you to just return structured data.

                        Since on Haiku, every window is its own thread, applications communicate even with themselves using messages; and if they allow it, any application can send them messages, and even ask what messages they accept.

                        A database instead of a filesystem … I’m talking here about a generic structured system of storing data on media that supports data types, atomicity, indexing, transactions, journals and storage of arbitrarily structured data, including large blocks of purely binary data.

                        BeOS and Haiku make extensive use of (typed) extended attributes, which are then indexed and can be queried. Haiku’s Email client utilizes this by storing each e-mail as its own file, with attributes like MAIL:from, MAIL:subject, etc. There are also attributes like BE:caret_position, which specifies where the caret last was when you closed a (text) file, so any editor can restore your position, no matter which one you last opened a file in.

                        1. 6

                          Since on Haiku, every window is its own thread, applications communicate even with themselves using messages; and if they allow it, any application can send them messages, and even ask what messages they accept.

                          This is also the case, I believe, in Plan 9

                          1. 2

                            I’ll have to look into Haiku some day, thanks for the pointers.

                          1. 37
                              The venerable master Qc Na was walking with his student, Anton.  Hoping to
                            prompt the master into a discussion, Anton said "Master, I have heard that
                            objects are a very good thing - is this true?"  Qc Na looked pityingly at
                            his student and replied, "Foolish pupil - objects are merely a poor man's
                            closures."
                            
                              Chastised, Anton took his leave from his master and returned to his cell,
                            intent on studying closures.  He carefully read the entire "Lambda: The
                            Ultimate..." series of papers and its cousins, and implemented a small
                            Scheme interpreter with a closure-based object system.  He learned much, and
                            looked forward to informing his master of his progress.
                            
                              On his next walk with Qc Na, Anton attempted to impress his master by
                            saying "Master, I have diligently studied the matter, and now understand
                            that objects are truly a poor man's closures."  Qc Na responded by hitting
                            Anton with his stick, saying "When will you learn? Closures are a poor man's
                            object."  At that moment, Anton became enlightened.
                            
                            --- Anton van Straaten
                            
                            1. 5

                              Lo, I came here to post that very koan, and saw upon my arrival that it had already been done.

                              1. 14

                                And now you are enlightened.

                              2. 2

                                This is especially true if you know how objects in Smalltalk / Self work.

                              1. 1

                                I’ve read the readme and I still have no idea what it is or why should I use it.

                                Make your functions return something meaningful, typed, and safe!

                                Ok.. This doesn’t make any sense. My returns are typed and meaningful enough, thank you very much.

                                Enforces better architecture

                                How?! Bunch of typing doesn’t enforce better architecture and all of this anyway depends on the definition of “better”.

                                Pythonic and pleasant to write and to read

                                And the first example is this stuff:

                                user: Optional[User]
                                
                                can_buy_stuff: Maybe[bool] = Maybe.new(user).map(  # type hint is not required
                                    lambda real_user: real_user.get_balance(),
                                ).map(
                                    lambda balance: balance.credit_amount(),
                                ).map(
                                    lambda balance_credit: balance_credit > 0,
                                )
                                

                                This is just very unpythonic java in python syntax. It is said that it is beter than

                                user: Optional[User]
                                
                                if user is not None:
                                     balance = user.get_balance()
                                     if balance is not None:
                                         balance_credit = balance.credit_amount()
                                         if balance_credit is not None and balance_credit > 0:
                                             can_buy_stuff = True
                                else:
                                    can_buy_stuff = False
                                

                                because this is long and contain a lot of fluff with checking the value to None (functions returning None when they should clearly raise errors are antipattern by itself). But this can be shortened to:

                                try:
                                    can_buy_stuff = user.get_balance().credit_amount() > 0
                                except AttributeError:
                                    can_buy_stuff = False
                                

                                This is imho perfectly readable and much better than chained maps with lambdas.

                                1. 4

                                  Requires login to read it -> nope.

                                  1. 1

                                    There is an “x” in the overlay to close it. You don’t have to log in.

                                    1. 1

                                      I think that depends on how many articles from medium you’ve read that month. I opened the article at work and there was overlay that didn’t have “x” and required me to log in.

                                      Edit: https://imgur.com/a/1kSEv9d <- just opened few other articles, I think the limit is something like four articles.

                                      1. 1

                                        That’s unfortunate :(

                                  1. 2

                                    I’ve worked on generator of meaningness.com to epub: https://github.com/Bystroushaak/meaningness.com_epub_generator

                                    I’ve also did a bit of 3D modeling in blender on the illustration I want to use in blog.

                                    1. 17

                                      Wouldn’t it make more sense to ask for a retrospective, that is “What you did this weekend?”

                                      I follow lobsters using RSS and I would like to contribute to this threads, but my plans almost never really work. But I do keep a log and write summaries in retrospective. I think that it may be easier for more people to write what they did, instead of what they want to do.

                                      1. 14

                                        Seconded. Telling people you are going to do something is a great way to not do it.

                                        1. 2

                                          There is a second camp of thought that says telling other people (“throwing your hat over the wall”) will spur you on to doing it.

                                          1. 3
                                            1. 1

                                              Psychological research is always flip-flopping. The problem, of course, is poor experimental methods.

                                              For the particular effect in question, this review is interesting: https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4931712/

                                              The current meta-analysis estimated the magnitude of the impact of asking intention and self-prediction questions on rates of subsequent behavior, and examined mediators and moderators of this question-behavior effect (QBE). Random-effects meta-analysis on 116 published tests of the effect indicated that intention/prediction questions have a small positive effect on behavior (d+ = 0.24). Little support was observed for attitude accessibility, cognitive dissonance, behavioral simulation, or processing fluency explanations of the QBE. Multivariate analyses indicated significant effects of social desirability of behavior/behavior domain (larger effects for more desirable and less risky behaviors), difficulty of behavior (larger effects for easy-to-perform behaviors), and sample type (larger effects among student samples). Although this review controls for co-occurrence of moderators in multivariate analyses, future primary research should systematically vary moderators in fully factorial designs. Further primary research is also needed to unravel the mechanisms underlying different variants of the QBE.

                                          2. 1

                                            Agreed, this as well as not wanting to feel like I failed myself when my interest shifts, are why I don’t contribute to these threads anymore.

                                            1. 1

                                              Now I know why I never want to write anything here :)

                                            2. 2

                                              We could hold each other accountable for our grandiose ideas by following up to say what we actually did.

                                              1. 2

                                                Why? To what end?

                                                Why does actually measuring our communal throughput matter?

                                                I personally find these threads delightful and don’t give a rat’s posterior whether any of it actually happens or not.

                                                1. 2

                                                  I am going to solve world hunger and invent time travel … unless the Earth continues to rotate around its axis creating a period of light and darkness. In that case? I’ll have to go to plan B, watching Bonanza reruns and eating 14 pounds of cheese puffs.

                                                  Just kidding, of course. I think of these things as aspiration, more like “Have you thought about what you would like to do this weekend?” which many times is what I need to get off my ass and something, anything. Also I do not eat cheese puffs.

                                                2. 2

                                                  Why no say what you intend to do this weekend and then on sunday night reply to your own comment with what you did do?

                                                  1. 3

                                                    Because whole lobsters nature is shortlived discusions. On sunday night is good chance that no one will ever read it. This is even more true with “this week threads”.

                                                  2. 2

                                                    This thread could be useful to lobsters:

                                                    • to either get ideas of what they could also be doing in the weekend
                                                    • to help / give feedback to those asking for it

                                                    I get your point and I agree but maybe an additional thread “What you did this weekend?” should be created instead.

                                                    1. 1

                                                      FWIW, there’s nothing special about these threads, they’re just normal submissions tagged “ask”, so anybody (including you ;-) can post a “What did you do this weekend?” thread on Monday.

                                                      1. 2

                                                        Yeah, I know, I just feel like it would be too much spam for some.

                                                      1. 14

                                                        There’s a couple of people on Lobsters who have used Self or are involved in it. Self is still a (slowly) ongoing project, available for MacOS and Linux. I guess I’m the main Self guy at the moment, so happy to answer any questions.

                                                        1. 3

                                                          Whoaaaa. I just wanted to say: SUCH A COOL FUCKING PROJECT! THANK YOU for working on it.

                                                          I know I’m not supposed to yell like that, but… whatever, it’s deserved.

                                                          The reason I’m so happy that something like Self exists is that it serves as an example of “graphical programming”, which is a concept that somehow got lost between the 90’s and now. Project Oberon is another excellent example.

                                                          Basically, you’re able to interactively explore a system and link arrows together. It’s a flow chart, not a text file. (It can be a text file, of course, but a text file doesn’t help you examine runtime state.)

                                                          Not even React / Redux tooling is as advanced. You can inspect state, but you can’t really do anything using their tooling.

                                                          1. 4

                                                            I just help keep it ticking over, but thanks.

                                                            There is such a large amount of computing history which has been effectively forgotten. It’s amazing given how short the history of computing is! And every so often people reinvent something :)

                                                          2. 1

                                                            Do you have a text summary of what this even is, for those of us who don’t want to invest time in watching videos?

                                                            1. 4

                                                              Self is a research programming system first developed at Sun in the 80s, comprising a prototype based language, GUI and VM. The VM was for its time groundbreaking for its use of generational garbage collection and JIT compilation and is an ancestor of the HotSpot JVM. The language is clean and simple, “like Smalltalk but more so” - everything is a message send including local variable access, control structures and arithmetic. The GUI focuses on immediacy and concreteness and allows for multiple independent developers to collaboratively interact with objects on a shared canvas.

                                                              1. 1

                                                                Thank you! I’ll make sure to add this to my list of things to watch!

                                                                1. 1

                                                                  I’ve written about self this Series of articles: http://blog.rfox.eu/en/Series_about_Self.html

                                                            1. 3

                                                              Another good video is https://www.youtube.com/watch?v=8nfrC-YLYqc, but I don’t want to spam.

                                                              1. 1

                                                                Thank you Bystroushaak, I’ve merged your submission here in to story v2gahh. To your follow-up comment about not wanting to spam submitting another link: there is an open ticket to make story merging available as an edit suggestion, which would make submitting material related to previous story submissions less manual than it is now.

                                                              1. 1

                                                                Eh, this “article”. If you need to call python one liners quickly from the shell, use pythonpy. If you need the other way, that is to call shell from python, use sh.

                                                                1. 1

                                                                  حي بن يقظان, Hayy ibn Yaqdhan, or Alive, son of Awake one of the first books about autodidactism (1182)

                                                                  Passages from the Life of a Philosopher autobiographic book by the Charles Babbage, inventor of mechanical computers (1864)

                                                                  I would agree on Flatland and add also A Primer of Higher Space (the Fourth Dimension) (1913)

                                                                  The Adolescence of P-1 is one of the first stories about AI (1977)

                                                                  And if you want something really old and still relevant, try Euclid’s Elements (-300) or Newton’s Principia Mathematica (1687)

                                                                  1. 1

                                                                    Whoa, thanks.

                                                                    1. 1

                                                                      I was kinda disappointed that it wasn’t about X11.

                                                                      1. 23

                                                                        A lot of these points seem very opinionated. I share a number of them, but going off and calling everything that doesn’t fit your preferences “insane software” seems rather … meh. “Follow these rules”-articles without any explanations/reasoning aren’t really all that useful anyway.

                                                                        “Must be compatible with GNU GPLv3” means that I can never choose an alternative copyleft license, if I so prefer. It seems to me that this enforces exactly the kind of “monopoly” that some of the other points try to avoid. In general, I find the entire FSF-fawning in this article highly off-putting by the way.

                                                                        1. 3

                                                                          The EUPL 1.2 (see https://eupl.eu/1.2/en/) is compatible with the GNU GPLv3 without being the GNU GPLv3. It’s a hack to enable a one-way relicensing in certain circumstances, but a useful one.

                                                                          1. 0

                                                                            What if I don’t want my software relicensed to the GPL?

                                                                            1. 3

                                                                              This is the motivation behind the manifesto:

                                                                              In respect to user freedoms, privacy, liberty and software quality we create software according to the following guidelines.

                                                                              and this is the reason for recommending (not requiring) the copyleft licenses:

                                                                              Copyleft licenses (like GNU GPL or GNU Affero GPL) are strongly recommended because they guarantee software freedoms to every single end-user and prevent possibility that freedom vanishes somewhere in the distribution chain and the user can not benefit from the free software albeit the software is build on originally free source code.

                                                                              So if you can dual-license (GPLv3 + your favorite license), what are your objections?

                                                                              I would understand if e.g. some „open-source guy“ would disagree with requirement of GPLv3 license and would prefer a permissive license. But it is not a problem, because GPLv3 is not required – you can use e.g. BSD, MIT or Apache 2.0 – all such licenses are OK – it is required only to be GPLv3 compatible.

                                                                          2. 3

                                                                            Ad opinionated: this is not an exact science, I can not give mathematical proof for the each rule. So it is quite OK if you call it „opinions“. However they are based on experience (circa 14 years of professional software development). There is problem with TL;DR syndrome – such manifesto must not be too long, because nobody would read it. Each item could be an article and the manifesto could be a book… I will probably address particular topics in separate articles later. Currently, there are some additional notes, links and quotations in the source code (in later versions they might go to the footnotes in generated documents, but currently, in the v_0 branch they are just in the source code).

                                                                            1. 4

                                                                              Ad sane/insane: I understand that it is bit controversial, but it is not meant to be offensive. It should avoid the worst cases – if someone tells me to run curl http://www.example.com/install.sh | sudo bash in order to install his software, then yes, it is insane. Same case is that if so many free software projects depend on a single corporation. Or if you need a disproportionately complex (LOC, cyclomatic complexity, dependencies) software for doing a simple job. The complexity is real problem and despite it seems working now, it is still insane to depend on such software. BTW: today, the post just delivered me a copy of the book Click Here to Kill Everybody which seems to be a good read and relevant to this topic.

                                                                              1. 4

                                                                                Ad sane/insane: I understand that it is bit controversial, but it is not meant to be offensive. It should avoid the worst cases – if someone tells me to run curl http://www.example.com/install.sh | sudo bash in order to install his software, then yes, it is insane.

                                                                                I think your use of the word “insane” is insane.

                                                                                1. 2

                                                                                  Maybe it would work better if you negated the logic, that is to collect list of all insane examples, like in The Little Book of Python Anti-Patterns book.

                                                                                2. 2

                                                                                  I can never choose an alternative copyleft license

                                                                                  The software might be dual-licensed. It can be e.g. GPLv2 and GPLv3 (which differs from the GPLv2+ because it does not include the GPLv4 and later which is not known yet) or any other license + GPLv3.

                                                                                  I find the entire FSF-fawning in this article highly off-putting by the way.

                                                                                  I am a FSF associate member, but I am not happy with the recent events (see my article Future of the Free Software Foundation). However the Sane software manifesto is much older than those events and is written independently from the FSF. It rather refers to particular original ideas than to the current FSF (because such organization might change during time). It should work as a stand-alone document without any references to mutable external sources (such sources are usually quoted thus change in the external source does not automatically mean the change in the Sane software manifesto).

                                                                                  1. 4

                                                                                    I’m not sure how to state this more plainly: I don’t like the GPL. I don’t want software I write available under the GPL. I don’t want “alternative solutions”, I don’t want the GPL. It’s really that simple.

                                                                                    Recent events regarding the FSF have nothing to do with my dislike for it; that’s mostly fuelled by articles such as this one which state One True Way™ without any nuance or appearant understanding of other viewpoints or why things are as they are (your other comments, instead of adding nuance, only doubled down).

                                                                                    But hey, guess I’m “not sane” 🤷 Let me be plain about that as well: saying that people are “insane” for disagreeing about a particular topic – especially political ones like GPL/Free Software – is insulting, offensive, arrogant, and highly toxic.

                                                                                    1. 5

                                                                                      I’d like to enter the discussion right here.

                                                                                      Let me be plain about that as well: saying that people are “insane” for disagreeing about a particular topic – especially political ones like GPL/Free Software – is insulting, offensive, arrogant, and highly toxic.

                                                                                      While I do have my own objections against this manifesto (including its name, the fact that it’s even called a manifesto, and the majority of its content), there are two important points to be made. First of all, he’s calling the software “insane”, not its authors. But what’s even more important is that the English word “sane”, and especially the opposite term, “insane”, sound maybe more harsh than intended. Franta is Czech and translates the word as “příčetný”, which has somewhat milder connotation. That’s not to say it didn’t cause some controversy on the Czech Internet, because it for sure did, but it’s not per se insulting. It’s more that people just don’t agree with it.

                                                                                      Anyway, like I said, I do have my own objections about this manifesto, but I believe this particular statement of yours is just a cultural misunderstanding. There are some nice suggestions in this discussion (sensible or decent), so perhaps Franta would consider renaming it.

                                                                                      1. 3

                                                                                        I wrote about my own struggles with English as a non-native speaker before, so I certainly have a lot of sympathy and patience for that. The thing here is that people did tell the author, which was then ignored. So, I opted more a more direct approach to ensure the message got across with little chance of misunderstanding.

                                                                                        While less strong words – like “sensible” or “decent” – would certainly be an improvement, I still think this manifesto is far too opinionated and political to claim anything that doesn’t abide by it as “insensible” and “indecent”.

                                                                                        he’s calling the software “insane”, not its authors

                                                                                        I appreciate this, but there is a very fine line here; if I make “insane” software, then does that not imply that I’m acting in an “insane” way? And if I’m acting in an “insane” way, then am I not “insane”?

                                                                                        1. 3

                                                                                          Yes, I think it should be written in a different form. I hesitated to do it, but in the end decided to post my opinion.

                                                                                          I’ve read tons of Franta’s comments about similar topics and agreed with him a lot, yet was rolling my eyes when I read this. That’s perhaps the simplest way to put it. I understand his logic, but… OK, here’s another way to put it: Mixing tech with politics can do no good. After 9 months on Lobsters, I encountered first deleted comment right here. It’s my fault I didn’t realize I was entering a purely political thread, not Franta’s, but it still shows the level of controversy it causes.

                                                                                          The world needs good developers who follow good practices, not more labels. We can try to create some sort of “standard” for software development, but calling most of the software in existence “insane” is pointless, because it’s not going to change much. If anything, it should be split into multiple standards. We already have a definition of free software, so we could add some definitions for well-tested software, well-documented software, well-managed free software etc. But that just runs into similar problems. Testing games is so much different than testing enterprise systems… I would repeat myself at this point :)