A lot of popular notions in software engineering are based on nothing but superficial plausibility and endless repetition. Fox example, I have heard hundreds of times that we work in a "young industry". This idea is frequently invoked in various comment sections, blog posts and even in conference talks. It usually serves as an explanation for various deficiencies and absurdities of our field. Supposedly, it is the reason why our best practices reliably get recast as worst antipatterns every handful of years. It is also, I am frequently told, the reason so much software is hopelessly buggy, unpleasant to work with and insecure. Heck, even various personnel problems often get explained away by invoking the "age" of our field.
If you pause and think for a second, it's not hard to see why this "young industry" meme is emotionally appealing. Youth is a universal condition that is beyond our direct control. We expect the young to make mistakes because of their inexperience and don't judge them too harshly. Simultaneously, we know that they will eventually grow up. In other words, our field is deficient, but we can't change it, no one is to blame and things will automagically get better. That is the underlying message. How fucking convenient!
I'm not going to even try to establish objective criteria for fields that can be legitimately considered "young". If hundreds of people parroting this meme did not bother to do so, why should I? However, here is something that ought to put things into appropriate perspective: software engineering is exactly as old as nuclear engineering, which no one calls "young". Both fields got kick-started during World War II. People at Los Alamos who were figuring out how to make the first atomic bomb were simultaneously figuring out how to efficiently utilize mechanical computers to run their numerous calculations. One of those people was John Von Neuman, whose experience at the time led him to design Von Neumann architecture, which is still used in most computers today. A decade after war's end both fields went civilian and somewhat more mainstream. The first nuclear powerplant was built in 1957. The first high-level programming language was specified either in 1957 or 1958, depending on whether you want to bestow that title onto Fortran or LISP.
In short, our industry is not "young", it's just dysfunctional. It doesn't have a particularly good excuse either. Not only software is as old as nuclear engineering, it currently is a much bigger field both in terms of the capital and people involved.