• 67 Posts
  • 350 Comments
Joined 1 year ago
cake
Cake day: July 29th, 2023

help-circle



  • i interpreted the “trend” correctly, “devops” was bastardized away from its original meaning to now mean “sysadmin”, at least in most cases.

    I don’t think I agree. The role of a sysadmin involved a lot of hand-holding and wrangling low-level details required to keep servers running. DevOps are something completely different. They handle specific infrastructure such as pipelines and deployment scripts, and are in the business of not getting in the way of developers.



  • Every job lately seems to have been infected by Meta/google “data driven” leadership. Its so painful and wasteful sometimes.

    It’s cargo cult mentality. They look at FANGs and see them as success stories, and thus they try to be successful by mimicking visible aspects of FANG’s way of doing things, regardless of having the same context or even making sense.

    I once interviewed for a big name non-FANG web-scale service provider whose recruiter bragged about their 7-round interview process. When I asked why on earth they need 7 rounds of interviews, the recruiter said they optimized the process down from the 12 rounds of interviews they did in the past, and they do it because that’s what FANGs do. Except FANGs do typically 4, with the last being an on-site.

    But they did 7, because FANGs. Disregard “why”.


  • In the 2010s, the mindset at tech giants seemed to be that they had to hire the best developers and do everything they could to keep them.

    Not really. The mindset was actually to hire skilled developers just to dry up the market, so that their competitors would not have skilled labour to develop their own competing products and services.

    Then the economy started to take a turn for the worse, and these same companies noted that not only they could not afford blocking their competitors from hiring people but also neither did their competitors. Twice the reasons to shed headcount.

    It was not a coincidence that we saw all FANGs shed people at around the same time.


  • A comment on the YouTube video makes a good point that we already have a better word for the concept of dealing with multiple things at once: multitasking.

    I don’t think that’s a good comment at all. In fact, it ignores fundamental traits that separate both concepts. For example, the concept of multitasking is tied to single-threaded task switching whereas concurrency has a much broader meaning, which covers multi threaded and multiprocess execution of many tasks that may or may not yield or be assigned to different cores, processors, or even nodes.

    Meaning, concurrency has a much broader meaning that goes well beyond “doing many things at once”. Such as parallelism and asynchronous programming.


  • Do we really need a video about this in 2024? Shouldn’t this be already a core part of our education as software engineers?

    I’m not sure what point you tried to make.

    Even if you believe some concept should be a core part of the education of every single software engineer who ever lived, I’m yet to meet a single engineer who had an encyclopedic knowledge of each and every single topic covered as a core part of their education. In fact, every single engineer I ever met only retained a small subset of their whole curriculum.

    So exactly what is your expectation?






  • Does anyone have any good sources or suggestions on how I could look to try and begin to improve documentation within my team?

    Documentation in software projecte, more often than not, is a huge waste of time and resources.

    If you expect your docs to go too much into detail, they will quickly become obsolete and dissociated from the actual project. You will need to waste a lot of work keeping them in sync with the project, with little to no benefit at all.

    If you expect your docs to stick with high-level descriptions and overviews, they quickly lose relevance and become useless after you onboard to a project.

    If you expect your docs to document usecases, you’re doing it wrong. That’s the job of automated test suites.

    The hard truth is that the only people who think they benefit from documentation are junior devs just starting out their career. Their need for docs is a proxy for the challenges they face reading the source code and understanding how the technology is being used and how things work and are expected to work. Once they go through onboarding, documentation quickly vanishes from their concerns.

    Nowadays software is self-documenting with combination of three tools: the software projects themselves, version control systems, and ticketing systems. A PR shows you what code changes were involved in implementing a feature/fixing a bug, the commit logs touching some component tells you how that component can and does change, and ticketing shows you the motivation and the context for some changes. Automated test suites track the conditions the software must meet and which the development team feels must be ensured in order for the software to work. The higher you are in the testing pyramid, the closer you are to document usecases.

    If you care about improving your team’s ability to document their work, you focus on ticketing, commit etiquette, automated tests, and writing clean code.





  • lysdexic@programming.devOPtoProgramming@programming.devRFC 7493: The I-JSON Message Format
    link
    fedilink
    English
    arrow-up
    5
    arrow-down
    1
    ·
    edit-2
    2 months ago

    Why restrict to 54-bit signed integers?

    Because number is a double, and IEEE754 specifies the mantissa of double-precision numbers as 53bits+sign.

    Meaning, it’s the highest integer precision that a double-precision object can express.

    I suppose that makes sense for maximum compatibility, but feels gross if we’re already identifying value types.

    It’s not about compatibility. It’s because JSON only has a number type which covers both floating point and integers, and number is implemented as a double-precision value. If you have to express integers with a double-precision type, when you go beyond 53bits you will start to experience loss of precision, which goes completely against the notion of an integer.



  • lysdexic@programming.devtoProgramming@programming.devSafe C++
    link
    fedilink
    English
    arrow-up
    2
    arrow-down
    2
    ·
    2 months ago

    It’s very hard for “Safe C++” to exist when integer overflow is UB.

    You could simply state you did not read the article and decided to comment out of ignorance.

    If you spent one minute skimming through the article, you would have stumbled upon the section on undefined behavior. Instead, you opted to post ignorant drivel.


  • I wouldn’t call bad readability a loaded gun really.

    Bad readability is a problem cause by the developer, not the language. Anyone can crank out unreadable symbol soup in any language, if that’s what they want/can deliver.

    Blaming the programming language for the programmer’s incompetence is very telling, so telling there’s even a saying: A bad workman always blames his tools.


  • lysdexic@programming.devtoProgramming@programming.devSafe C++
    link
    fedilink
    English
    arrow-up
    8
    ·
    edit-2
    2 months ago

    Well, auto looks just like var in that regard.

    It really isn’t. Neither in C# nor in Java. They are just syntactic sugar to avoid redundant type specifications. I mean things like Foo foo = new Foo();. Who gets confused with that?

    Why do you think IDEs are able to tell which type a variable is?

    Even C# takes a step further and allows developer to omit the constructor with their target-typed new expressions. No one is whining about dynamic types just because the language let’s you instantiate an object with Foo foo = new();.