• bacon_pdp@lemmy.world
    link
    fedilink
    arrow-up
    45
    ·
    5 days ago

    No. Just people are starting to look at the tower of abstractions upon which they built their world.

    You only need to embrace understanding to realize that the stacks could be much smaller and much more stable and more likely to be correctly secured.

    But getting people to think in formal proofs, state machines and boring technologies is quite difficult.

    • thedeadwalking4242@lemmy.world
      link
      fedilink
      arrow-up
      21
      ·
      5 days ago

      I know! I’ll drink a bunch of red bull stay up for 4 days straight and give Anthropic 10000 dollars!! And in a mania induced frenzy rebuild everything! That will fix it! /s

    • arty@feddit.org
      link
      fedilink
      English
      arrow-up
      7
      ·
      5 days ago

      It was curious to me how he takes the PHP vulnerability as an example. You can have your stack of one component: PHP, and you’ll be vulnerable.

    • MachineFab812@discuss.tchncs.de
      link
      fedilink
      arrow-up
      2
      ·
      5 days ago

      I like your characterization of security as a statistical outcome, if not the fact its effectively an anomally leftover from … other … times.

  • MagicShel@lemmy.zip
    link
    fedilink
    English
    arrow-up
    36
    ·
    5 days ago

    I think this is a good article and accurate. I’ve tried to block the rising tide of this within my own company, but my management is pressing forward with plans to implement an AI harness. I pushed forward a design that at least put questions and decisions in the hands of developers, but I got my hand slapped.

    We are announcing 10x dev speeds based on pocs that haven’t been team reviewed or deployed in test. The code looks fine tbh, but I know it’s an illusion. The moment we start signing contracts based on 10x, the writing is on the fucking wall.

    AI can be an accelerator — my teams have seen 30% productivity gains without sacrificing quality, and I think I could push that higher, perhaps as much as 2x, though I’d rather just target continuous progress than predict the benchmark — but we can’t be happy with that and so we are turning an incredible success into an epic failure.

    • HaraldvonBlauzahn@feddit.org
      link
      fedilink
      arrow-up
      6
      ·
      edit-2
      4 days ago

      I have tried that with a small side project - a simple TUI app and parser in Rust - and I wasn’t convinced it is really faster. It spat out some 4,000 lines in about four afternoons, a bit of ratatui and so on. The cursor wasn’t visible. The fix was completely hallucinated, or BS, and suggested downloading and patching another lib. The parser was incorrect. It had over one hundred dependencies. I could fix it with two or three more afternoons time. Now, 4000 lines in a few days still sounds impressive, doesn’t it?

      But then, I wanted to know it, threw the generated code away, and wrote it again from scratch. I got there with half the code and had it working. In the same time. With a working cursor and a better parser.

      I think the speed perception is like when you are using public transport or a commuter train vs a bicycle. The motorized vehicle always feels faster. But at distances like ten miles / 15 kilometers, it isn’t. A car still feels much faster, but often it isn’t worth the cost.

      These things save – seem to save – effort, which our primate brain is wired to. But laziness is a bitch. Lke cars, which when used a lot instead moving our body, only make our life shorter.

  • tias@discuss.tchncs.de
    link
    fedilink
    arrow-up
    23
    ·
    edit-2
    5 days ago

    “Nobody is in charge. It’s a headless blunder operating under the illusion of a master plan.”

    - Worth, in “Cube” (1997)

  • I Cast Fist@programming.dev
    link
    fedilink
    arrow-up
    18
    ·
    5 days ago

    Software hasn’t been working too well lately, has it?

    It hasn’t for a number of decades, if we’re being honest. The difference is that the stakes nowadays are much, much, much higher than, say, in 1999

    About ten years ago, two small revolutions happened in our industry, whilst the rest of the world paid little attention. They were cloud computing, and open source libraries. (…) tools like NPM hit the scene in 2014, it really felt like a gamechanger. You could just add a line to your package.json, hit npm install and - whoosh - now you could reuse code written by any stranger on the internet.

    Python’s pip and RubyGems have been around for many years prior, fyi.

    Open source was great because you had a small number of passionate, unpaid developers, building code that everyone else depended on. (…) But the cost was that everyone stopped knowing the details.

    It’s kinda ironic how one of the takes from that can be “this is why programmers should continue reinventing the wheel”

    • NewDawnOwl@lemmy.world
      link
      fedilink
      arrow-up
      7
      ·
      5 days ago

      It’s kinda ironic how one of the takes from that can be “this is why programmers should continue reinventing the wheel”

      It’s a bit more nuanced.

      1. Software Engineering is about tradeoffs, since it’s a form of engineering
      2. There is more than one topic to address here from a best practices standpoint
      3. There is more than one way to use package managers, and it’s up to you to implement a correct solution for the use case.
      Software Engineering is about tradeoffs, since it’s a form of engineering

      You and your team need to choose where the tradeoff between re-implementing functionalities and re-writing existing things that you have control need to be made. Do you really need to use Left-Pad, or can you write a function and leave it in a JS library for your software to call? Do you have the time to dedicate to reviewing the dependencies and how they function? Is that available for your target language? Is it worth it to use a different language if you don’t get the source code of your libraries?

      There are several other factors to consider these are just some examples.

      There is more than one topic to address here from a best practices standpoint

      In this instance, it’s largely two ideas from the Pragmatic Programmer :

      • DRY : Don’t repeat yourself/don’t reinvent the wheel (NB : the original idea is to refactor code so you’re not copy pasting edge cases all over the place, but similar ideas fit into this perspective)
      • Cargo cult programming : Know what your software is doing.

      Yes, you should not repeat yourself. But also, you should know what it is the dependencies you have are doing and not just blindly trust them. Someone, at some point, should be responsable for vetting the security and reliability of the packages you are choosing to make use of in your software. There is a bedrock level where you need to trust that at least the language or compiler or equivalent is going to work correctly, but the most recent package that you are using that is on version 0.0.1 that is going to make the backbone of your business might need some vetting. Perhaps choose to re-implement that one so you are using something more dependable that isn’t going to be at risk due to external factors.

      There is more than one way to use package managers, and it’s up to you to implement a correct solution for the use case.

      Certain package managers allow you to host your own package store on a network. You can use this functionality to secure a certain version, and ensure that your systems will depend on a vetted, secure version of that library. This way, if a package gets compromised or changed to not include your necessities, you can still continue to function without being affected.

      If you, the reader, found this useful, I am currently looking for work.

    • MachineFab812@discuss.tchncs.de
      link
      fedilink
      arrow-up
      7
      ·
      5 days ago

      “Reinventing the wheel” is part of how programming is taught. Not every “wheel” on NPM is free of un-foreseen consequence either; Not even looking at the borrowed wheel, let alone understanding it, should never have been rewarded.

    • arty@feddit.org
      link
      fedilink
      English
      arrow-up
      6
      ·
      5 days ago

      Python’s pip and RubyGems have been around for many years prior, fyi.

      And PHP’s PEAR, and Perl’s CPAN