Stories
Slash Boxes
Comments

SoylentNews is people

posted by hubie on Sunday January 22 2023, @07:02PM   Printer-friendly

An opinion piece but some pretty good advice here. Below is a sub-sample of "20 years of software distilled down into 20 pithy pieces":

1. I still don't know very much
"How can you not know what BGP is?" "You've never heard of Rust?" Most of us have heard these kinds of statements, probably too often. The reason many of us love software is because we are lifelong learners, and in software no matter which direction you look, there are wide vistas of knowledge going off in every direction and expanding by the day. [...] The sooner you realize this, the sooner you can start to shed your imposter syndrome and instead delight in learning from and teaching others.

2. The hardest part of software is building the right thing
I know this is cliche at this point, but the reason most software engineers don't believe it is because they think it devalues their work. Personally I think that is nonsense. Instead it highlights the complexity and irrationality of the environments in which we have to work, which compounds our challenges.
[...]
4. The best code is no code, or code you don't have to maintain
[...] Engineering teams are apt to want to reinvent the wheel, when lots of wheels already exist. This is a balancing act, there are lots of reasons to grow your own, but beware of toxic "Not Invented Here" syndrome.
[...]
8. Every system eventually sucks, get over it
Bjarne Stroustrup has a quote that goes "There are only two kinds of languages: the ones people complain about and the ones nobody uses". This can be extended to large systems as well. [...]

12. People don't really want innovation
People talk about innovation a whole lot, but what they are usually looking for is cheap wins and novelty. If you truly innovate, and change the way that people have to do things, expect mostly negative feedback. If you believe in what you're doing, and know it will really improve things, then brace yourself for a long battle.
[...]
18. Software engineers, like all humans, need to feel ownership
[...] Give a group of passionate people complete ownership over designing, building, and delivering a piece of software (or anything really) and amazing things will happen.

19. Interviews are almost worthless for telling how good of a team member someone will be
[...] No one is going to tell you in an interview that they are going to be unreliable, abusive, pompous, or never show up to meetings on time. People might claim they have "signals" for these things... "if they ask about time off in the first interview then they are never going to be there!" But these are all bullshit. If you're using signals like these you're just guessing and turning away good candidates.

20. Always strive to build a smaller system
There are a lot of forces that will push you to build the bigger system up-front. Budget allocation, the inability to decide which features should be cut, the desire to deliver the "best version" of a system. All of these things push us very forcefully towards building too much. You should fight this.[...]


Original Submission

 
This discussion was created by hubie (1068) for logged-in users only, but now has been archived. No new comments can be posted.
Display Options Threshold/Breakthrough Mark All as Read Mark All as Unread
The Fine Print: The following comments are owned by whoever posted them. We are not responsible for them in any way.
  • (Score: 5, Interesting) by gznork26 on Monday January 23 2023, @12:03AM

    by gznork26 (1159) on Monday January 23 2023, @12:03AM (#1288111) Homepage Journal

    Back in the late 70s, one of my first jobs through a contract house was at a steel mill. Mill management had decided that the direct hire software people only had to write new code. Maintenance would be handled by contractors like me. So one day I got a short request: make it possible for the company auditors to access the company's custom production database using their off-the-shelf application.

    The database in question was a hierarchical disk-based creature in which data was stored in trees of an arbitrary number of variable-length nodes. The production software traversed it easily, using flags in node headers to indicate field lengths, repeat counts, and links to child nodes. The auditors' application, however, could only read sequential files. Fortunately, it was smart enough to be able to interpret header info that told it how to read the rest off record.

    Once I understood what was possible, I designed a program to create a sequential record from each tree. It was doable. But there was a problem: they insisted that it be written on COBOL. That wasn't a problem. I could redefine the 32K buffer as an array of bytes, and put anything I needed into each byte. Running it, however, would take forever, since I was forcing COBOL to do things it was never in tended to do. A test run, for example, took 10 minutes of mainframe CPU time, which meant I was hogging the mainframe when I ran it.

    That one routine that assembled the array was the sticking point. It would be simple to do that in assembler, and as it happened, that exact routine already existed, and was sitting in a drawer. I informed management and asked for a waiver so I could use it, but was denied. So I set about repeatedly running tests, trying tricks to speed it up a bit, which I knew would fail, until they gave in and let me use the routine. With that installed, m the program ran in 10 seconds clock time. An enormous time savings.

    So yeah. It's real important to consider maintenance. But also ALL of the users and use cases for the project.

    Starting Score:    1  point
    Moderation   +3  
       Interesting=2, Informative=1, Total=3
    Extra 'Interesting' Modifier   0  
    Karma-Bonus Modifier   +1  

    Total Score:   5