• AmiceseOP
      link
      3
      edit-2
      1 year ago

      deleted by creator

      • @mesapls@lemmygrad.ml
        link
        fedilink
        4
        edit-2
        2 years ago

        Complexity can emerge from a simple set of rules or mechanisms. It’s better to create simple fundamentals that emerge into complex interaction patterns both in terms of UI design and programmer implementation.

        I don’t think KISS conflicts with diamat. I would sooner say that complexity emerging from simple sets of rules and, therefore, a system maintaining a state of both simplicity and complexity at the same time is itself a contradiction. Correct me if my thinking here is wrong.

      • @redtea@lemmygrad.ml
        link
        fedilink
        32 years ago

        This may be a good opportunity to consider the ‘internal contradictions’ aspect of DiaMat, Amicese.

        I’m not a programmer, which may affect my assumptions about programming. Hopefully I still make sense.

        A basic but long block of text with very little formatting could load quickly even on an older computer. The speed would be due to the simplicity. But it would be difficult to read or retrieve information from the text. That’s not a problem for a user who wants to read a story chronologically. But it is a problem for a researcher or reader who only needs to highlight extracts of the text.

        So you might add formatting (headings, contents with links, etc) and a search function, increasing complexity (contradicting KISS) but improving usability. The casual story-reader will not complain about the added complexity unless it makes the text harder to read or slower to load.

        DiaMat, then, allows us to see the internal contradictions within the KISS principles. So, unless KISS demands that programmers cut all superfluous features from programming, applying KISS must mean striking a balance between simplicity and complexity. (Although this raises the question of superfluous ‘to who’? A casual reader may be fine with text with limited formatting, but a researcher may need the search function and clearer headings. The search function is not superfluous if you need it.)

        DiaMat is not necessarily incompatible with simplicity or (referring to the cross-post) formal logic. If a straightforward syllogism (A + B = C) explains something about programming sufficiently, there is no obvious reason to make things more complicated than that. I imagine an online shopping basket operates with this kind of logic.

        DiaMat, however, also invites a more abstract, contextual view.

        Consider programming in capitalism. The capitalist owner of a website or app is always seeking profit. Otherwise, they are not a capitalist. This leads to loads of distracting ads on websites, apps, and within audio-visual media. Not to mention premium (add free) versions of the same product, in-app purchases, and DLC extras for games.

        Those ads are not necessary, but without them, in capitalism, the app / website will not be made. 1) The ads provide the revenue from which the programmers income comes. 2) Capitalists do not advance the capital needed to produce anything (here, hardware, software, a building, a server room, internet connection, etc) unless they can monetise the result. (Or unless the result facilitates another form of profit-making.)

        Then, e.g., Google, realises that browsers running ad-heavy websites are slow, so they create a version of Chrome that can use as much ram as it likes. This makes older computers with low specs become too slow to use. And customers have to buy machines with higher specs. Then tech companies make programs for better machines, which makes older machines become redundant. And so on.

        From the other side, the programmer must seek to write for the new, more powerful technology or: they will not be hired; consumers will not have the (older) technology to run their code; etc. Imagine a creator of iOS apps. They can write apps for iOS 1, but there won’t be many users because Apple has long since made iOS 1 redundant. The app creator must keep their code up to date with the latest version of iOS.

        From this perspective, programming and it’s philosophies (such as KISS) are historically contingent. ‘Simple’ in 1960 or 1999 is not the same as it is in 2010 or 2022. (Even in 1960, though, ‘simple’ would have been affected by the political economy and would have had a class character: see below.)

        Rhetorically, how much programming is done just to keep up with other developments, which add complexity without any real improvement for the user?

        A DiaMat analysis of programming would have to account for the way that profit-seeking encourages some practices while discouraging others.

        DiaMat allows us to see how the political economy affects programming. Expanding on the first point, above, it is not just the user’s needs that lead to increased complexity, but the producer’s needs, too. So there are at least two internal contradictions ‘within’ programming; and these are ‘internal’ because all that programming happens within a capitalism setting. Currently, the two (capitalism and programming) cannot be separated.

        We could also consider the DiaMat concepts of monopoly rent and the surplus capital absorption problem (explained in David Harvey, Rebel Cities).

        Rhetorically, how much of the programming related to a mobile phone is only written because the phone manufacturer wants, e.g., to be the first to say that theirs is the only one with 2, 3, or 4 cameras, etc? The manufacturer does this in search of monopoly rent, in the same way as Coca-Cola or Champagne is claimed to be unique.

        The capitalist goes to bed with more money than they woke up with. The successful capitalist spends some of that extra on luxuries and essentials but re-invests a portion to further increase the profit that they go to bed with the next day. This leads to an increasing surplus and an increasing need to reinvest.

        A lot of money going into, say, Silicon Valley is an attempt to invest surplus capital in something productive. If those investors did not invest, their money would depreciate with inflation and they would not have the resources to maintain the competitive edge of their (other) business interests. This leads programmers to come up with new code and ever more ways of monetising take that code.

        Following from your other post about your account… How much code is only included because it harvests user’s data? Or stops someone from harvesting data? I’m not sure if the mechanics but, again rhetorically, how much code have Lemmy developers had to add to protect against DDOS attacks?

        It’s like commercial lawyers. (I’m not a huge fan of David Graeber, but his bullshit jobs thesis helps here.) Commercial lawyers are only necessary if the competition and the consumer has access to legal advice and their own lawyer. Once one person gets a lawyer, everyone needs one. Otherwise the one with the lawyer will use the law to defeat the competition, and use the law to justify increasing prices and decreasing quality.

        Once everyone has a lawyer, the lawyers add more and more terms into contracts. Before you know it, ‘terms of use’ for software licenses are hundreds of pages long, and even the lawyers don’t really know what they mean until a dispute gets to court. From this point, programmers have to add the terms of use, prominently, to their code to ensure the terms are binding on users. So the code for the install package has to get more complex.

        This brings us back to DiaMat and the need for a further class analysis. Almost every website now displays a cookies bar, asking users to agree to the terms of data collection, etc. Why? From the user’s point of view, this is pointless complexity. But it is necessary complexity if the law requires the user’s consent to share their data and if the producer wants to harvest that data. DiaMat requires us to consider the class character of programming and it’s various aspects.

        I think you’re on the right track with your DiaMat analysis of KISS, but it may be helpful to reframe things. It is not that KISS conflicts with DiaMat, it is instead that DiaMat reveals the internal contradictions of the KISS principles.

        I’d suggest that DiaMat and KISS are compatible. One aim of a progressive society is surely to give programmers the freedom to write code without all the complexity required by profit-seeking capitalists. Rhetorically, how many children must work in mines, for example, or how much carbon must we release into the atmosphere, so that capitalists can sell us games consoles and smartphones that will soon become obsolete and to sustain bitcoin markets?

        As Parenti argued: demand can create supply, but supply can also create demand. With all the resources used to develop every games console since the Commodore 64, we could have built high-tech hospitals throughout the third world. But manufacturers keep producing ‘better’ consoles, creating a profitable demand, and there’s only one option for the capitalists – focus on the consoles, etc. This system creates a demand for new types of programming. (I’m not saying that the technology in consoles is entirely pointless. I’m sure there are examples of where games tech has been applied in medicine, such as using VR to train surgeons, maybe. I recognise that these things are connected, and i’m not saying that society would be better today had we not developed consoles, etc. We can’t really answer that hypothetical question as we only know how existing society developed.)

        From this perspective, it is capitalism that is incompatible with KISS. Any insistence of using KISS without a DiaMat analysis will lead us away from this conclusion and prevent us from criticising the very system that is undermining a full application of KISS in programming. (I’m not making any claims about whether KISS is the best philosophy for programming, btw; I don’t know enough about it to say that.)

        It is possible to see DiaMat as just another philosophy, to be compared and contrasted with other philosophies (be it KISS, Kant, or Dennett). To me, DiaMat precedes and sits above all other philosophies. Indeed, I would say it is not a ‘philosophy’. It is the method that allows us to understand, explain, critique, reject and / or improve the world and those other ways of thinking.

        • @holdengreen@lemmygrad.ml
          link
          fedilink
          32 years ago

          KISS is kinda stupid because everything gets more complex as it evolves. Programming is just labor like any other field. If you want something nice people need to be able to work together and put in their labor efficiently.

          That’s how libre software works and I think it works relatively well despite capitalism. I think it will work better as we develop more advanced tools and systems and we defeat capitalism so programmers can have a lot more freedom.