• sunbeam60@feddit.uk
    1·
    3 hours ago

    Where we vibe code, we don’t need abstractions!

    Just an inglorious soup of notches and work arounds.

    It’s the ultimate shitty transpiler —> from shitty requirements to crappy architecture by fibbergibberting!

  • frog_brawler@lemmy.worldEnglish
    11·
    3 hours ago

    Jr. Devs: My ideas aren’t proven or concrete so I’m going to make memes of sr. devs

    – everyone with a brain… “ok, cool, let me know when you get on board with the sr. devs, till then, shut up and stop being dumb.”

  • ChickenLadyLovesLife@lemmy.worldEnglish
    30·
    19 hours ago

    I started working as a professional programmer in the mid-90s when three-tiered design was all the rage: a data access layer, a business logic layer, and a presentation layer. It seems that nobody actually knew what “business logic” was even supposed to be, because I kept inheriting projects where all the middle tier did was hand data objects from the data layer to the UI. In theory this prevented the UI from being fundamentally bound to the data access, but all three layers were always written in Visual Basic which got kicked to the curb in a few years anyway.

    • Buddahriffic@lemmy.world
      7·
      18 hours ago

      Business logic would be transformations to the data. Like for a spreadsheet, the data layer would handle the reading/writing of files as well as the storage of each cell’s content. The business logic layer would handle evaluating each of the formulas in the cells, and the presentation layer draws it on the screen.

      I think the part where it gets confusing is that each of these layers are pretty tightly coupled. The end destination of the presentation layer might change, one might show it on a GUI, another might print it, and another might convert it to pdf or html, but each of those presentation layers needs to understand the data that it is presenting, so it’s tightly coupled to the data layer. Same with the businesses logic layer, though it’s tightly coupled on both the input and output sides. The design of the data layer constrains the possibilities of the other two, so it’s hard to draw a clear boundary between the layers because they all need to know how to walk the same data.

      My mental flow chart for this is more of a data layer in the middle instead of business logic, where business logic is to the side with arrows going both ways between it and data layer, then the presentation layer also accessing the data layer directly, which I suppose is a different permutation of what you described.

      Though another way to look at it does make sense. For a website, think of the database as the data layer, the server scripts as the business logic layer, and the client side scripts/html/css as the presentation layer. That one also follows the layered approach where the presentation layer is talking with the business logic layer.

      • BeardedGingerWonder@feddit.ukEnglish
        6·
        17 hours ago

        It’s simpler than that, if you’re working on the data layer anything you don’t want to touch is business logic.

        If you’re working on business logic the bad stuff is data layer.

        Presentation layer just isn’t my problem.

    • bitjunkie@lemmy.world
      4·
      17 hours ago

      My first tech job was writing test harnesses for DCOMs. Your post was a weird trip down memory lane.

      • jjjalljs@ttrpg.network
        8·
        21 hours ago
        
with patch("some_file.requests.get", side_effect=SomeException("oh no")):
  result = func_using_requests()

        Though not every language makes mocking as easy, and multiple responsibilities in a single function can quickly get messy.

        • wpb@lemmy.world
          1·
          2 hours ago

          Quickest way to get a test suite so tightly coupled to structure rather than behavior that even just looking at the tests wrong makes them fail. But technically you do get test coverage I guess. Goodhart’s law in action.

        • Tamo240@programming.dev
          5·
          18 hours ago

          Oh I’m fully aware that python lets you cheat dependency injection with patch, its one of the many things python teaches developers to do wrong, which leads them to be unable to use any other language.

          • jjjalljs@ttrpg.network
            1·
            17 hours ago

            I vaguely remember Java also has mocking libraries, as does JavaScript. (Though JavaScript isn’t a language I’d hold up as the ideal.)

            • Tamo240@programming.dev
              1·
              16 hours ago

              While my experience is mostly C++, I assume these mocking libraries are similar in allowing you to create a class that can report it’s own usage, and allow for arbitrary returns values and side effects, which is incredibly useful, especially in conjunction with dependency injection.

              What patch lets you do is directly overwrite the functionality of private member functions on the fly, which if Java/JavaScript can do I’d love to know, I thought this was a uniquely Pythonic magic.

  • addie@feddit.uk
    181·
    21 hours ago

    Abstraction is not very compatible with concurrency, so as well as your your beautiful abstract API, you also need some ‘cut through the layers’ functions to return the underlying classes you need to synchronise on. Now you have a right mess that’s incredibly hard to understand, infuriating to debug, and impossible to refactor. Best you can do is put another layer of abstraction on top. Repeat every six months.

    • Evotech@lemmy.world
      2·
      3 hours ago

      That’s why you build the api first. If you need to “cut through” anything you build an api for that instead.

    • 3abas@lemmy.world
      12·
      19 hours ago

      That’s just bad interface… When you design an API as if operations were independent, but they aren’t, you run into these issues.

      Don’t add “cut through the lawyers” functions, fix your interface.

      • Buddahriffic@lemmy.world
        5·
        18 hours ago

        Yeah, well-designed abstraction can help enable more concurrency. That said, concurrency isn’t easy at any point once there’s shared data that needs to be written to during the process. Maybe it’s not so bad if your language has good concurrency support (like monitor classes and such that handle most of the locking behind the scenes), but even then, there’s subtle pitfalls that can add rare bugs or crashes to your program.

  • WanderingThoughts@europe.pub
    32·
    1 day ago

    Just got out of a discussion with a supplier. We can do what we needed by connecting to the database. Instead we have to go through four layers of different tech to arrive at the same point in the database otherwise it’s not compliant. That the supplier needs to sell a license for those layers is purely coincidental.

    • expr@piefed.socialEnglish
      13·
      21 hours ago

      Obviously don’t have the full context, but rarely is it ever advisable to give third parties direct access to a database. There are many reasons for this, like, for example, the fact that doing so makes schema migrations practically impossible.

  • red_tomato@lemmy.world
    75·
    1 day ago

    Why should I want simplicity? I want to make unnecessarily complex programs to gatekeep those pesky junior programmers.

  • Randelung@lemmy.world
    15·
    21 hours ago

    I recently started a new job. We use Java. There’s a class that does a few things based on explicit arguments only to decide whether to use an FTP or file output, and you supply all parameters yourself. A whole ass Rube Goldberg machine that could be replaced by a single line of Files.writeString.

    Also, there’s a great video on YT “Stop writing classes” that is incredibly relevant.

    • Buddahriffic@lemmy.world
      7·
      17 hours ago

      Yeah, Java’s enforcement of everything must be a class put me off of the language right from the start. I was already used to C++ at that point and hated that I couldn’t just write a quick little test function to check something, it needed a bunch of boilerplate to even get started.

      I still think C++ has a great balance between object oriented and sequential programming. Not sure if it’s the best, but I can’t think of ways to improve on it, other than built in concurrency object stuff (like monitor classes that have built in locks that prevent more than one thread from accessing any of its functions at the same time, basically guaranteeing any code in it has mutual exclusion).

    • Windex007@lemmy.world
      8·
      20 hours ago

      This hits.

      I stepped into a similar implementation. Took like 6 months and 10 people to support…

      … changing the URL of the sftp server we connected to.

  • db2@lemmy.world
    11·
    21 hours ago

    They look so painfully awkward, like a parent should be telling them to knock it off or something.

    • Bosht@lemmy.worldEnglish
      9·
      19 hours ago

      If you haven’t seen the vid it’s 500 levels of awkward cringe that’s hard to watch. Had to do with one of the MS version releases. They’re acting so awkward you can’t tell if they’re yakked out in coke or just that socially awkward. Full disclosure I’d be worse than them in that situation, just calling it like it is.

      • Buddahriffic@lemmy.world
        4·
        17 hours ago

        Sometimes tech presentations make me feel really bad for the person giving it. They are up there trying their best but clearly don’t have the skills to do more than just communicate information but still try to make their presentation cool and fun and it just falls flat.

        Anyone can be cool, but not everyone can be cool on demand or on stage.

        Though on the other hand, just because a presenter can pull off the cool factor, it doesn’t mean what they are presenting is actually cool. The coolness of a presentation has no correlation with the coolness of what is being presented, unless that coolness is just information about the product (though even then, they are probably skipping over the flaws and enshitification).

      • RedFrank24@piefed.socialEnglish
        5·
        21 hours ago

        I’m not sure what you mean? Doing composition over inheritance is considered good practice across the board, regardless of whether it’s frontend or backend.

        • aaaaaaaaargh@feddit.org
          1·
          13 hours ago

          True but due to the framework in use it’s more or less applicable and I can’t think of a single commonly used backend stack that’s relying on composition whereas I know a bunch of frontend stacks. I guess composition is handy for widget trees so that’s why you see it more often in frontend apps.

          • RedFrank24@piefed.socialEnglish
            2·
            8 hours ago

            If you’ve used Dependency Injection before, you’ve used the principle of composition over inheritance. So, if you’ve ever used .Net (C#), Spring Boot (Java) or Laravel (PHP), you’ve likely used it. Modern C++ also has the DI pattern.

            Rust and Go force you to use composition and don’t support inheritance at all, so if you’ve used either of those languages, you’ve followed the practice, though Go doesn’t support DI out of the box. Functional languages like Haskell also use composition over inheritance.

            • aaaaaaaaargh@feddit.org
              2·
              4 hours ago

              I think you’re confusing composition with aggregation. DI can’t be composition because the injected object is shared/borrowed, strong composition on the other hand requires the object to be owned. A composed child does not exist without its parent.

              • RedFrank24@piefed.socialEnglish
                1·
                50 minutes ago

                Only if you’re going by the strict UML definition of composition, which doesn’t really apply here, since the industry has moved on a bit since UML was king.

                Either way, you can use DI to do composition in the strictest UML way, provided every single dependency is transient and creates a new instance every single time. Even then though, when most devs talk about composition, they aren’t referring to the strict UML definition.