This is something I learned first hand in the previous year. I joined a company that purposely seeks out known entities in a specific space. These are people I've seen do tech-talks and lead meetups. I specifically joined with the idea of mentorship and gleaning as much information as I could.
What I learned is that some of the ideas being pitched via tech-talk were actually introducing some of the most convoluted and inefficient practices into the department. I learned that some of those individuals were in untouchable ivory tower positions, and crossing them would cost you your job. I learned that upper-management didn't actually know a damn thing about the space and sought after those known entities to cover that gap and make themselves appear more relevant.
Before Google, business listing websites competed by being the most disciplined in listing business data — they had humans doing this. Along comes Google and gains a huge advantage by leveraging technology — not human discipline. And we all know who won.
Most outspoken Software Craftsmanship proponents eschew technologies like a strong type system à la Haskell in favour of manually-written tests — somehow not realising that you gain most leverage by taking advantage of types, and tests, and other formal verification systems.
Furthermore, in my experience, many architectural patterns talked about at these events (onions, ports and adapters, etc) are over-engineered piles of garbage in practice.
Wanting to be a better programmer is a good thing, of course. Dogmatically doing TDD (and yes, I write tests!) and adhering to SOLID principles is not the way you go about it.
For me, software craftsmanship (lower case) is just having pride in what you are making, and constantly improving your work based on a multitude of things, performance being only a small part of it.
Software certainly shouldn't be about adhering to strict processes and principles; software is a creative endeavor. Sometimes you can write novels, sometimes you can write haiku, sometimes you can write sonnets, sometimes you can write long form articles.
I've only been in this field for about 18 months and I'm so overwhelmed by all these conflicting ideas and have no idea where to turn.
Do you have any advice for juniors on how to internalise good engineering principles and how to avoid dogma?
Imagine a future co-worker coming in to fix a bug in your code - that person should ideally be able to say, aha, write a fix, and afterwards nobody can tell you didn't do it yourself.
If an abstraction makes things easier to understand, do it. If it doesn't, don't. Sometimes an extra test can make something easier to understand or modify, or handling more edge cases can make it the code more robust against future uses. But it's always a trade-off: less code is plainly easier to understand.
With that yardstick, lots of hyped tech just isn't good enough, advice given goes plainly against understandability or APIs that may look nice on paper result in hard-to-understand code full of accidental complexity. This applies to a lot of software method thinking too - does it result in me understanding the use cases better or in more understandable code? If not, don't waste time doing it.
By the way, writing code that's easy to understand and APIs that result in usage of said APIs being easy to understand is really hard. I spend a fair deal of my time rewriting code that I'm not comfortable with because it's too hard to understand. If you practice that, I think you might end up as an excellent programmer. Understandability extends to user interfaces and system design - a beautiful program that requires its users to jump through hoops to get everyday tasks done is an abomination in my book.
Read the "classics" - Code Complete, Pragmatic Programmer, Clean Code etc. Google "best books about programming" and you'll find plenty.
When you're reading think about the why. You're job is dealing in complexity and there is no one true way. Understand as many of the different ways as possible.
If you think an idea is weak, try and figure out a question that exposes the weakness (how does this handle a date before 1970?). Expect that sometimes this question will reveal the idea isn't as weak as you initially expected.
Remember you only need to solve the problem that's in front of you. If that problem doesn't seem easy try to break it up into smaller problems.
Complicated solutions are often bad solutions.
Complicated solutions can be good solutions.
Write your code for people to understand.
Advice on good writing is often very applicable to code... See Orwell(1), particularly "Break any of these rules sooner than say anything outright barbarous" 1.https://www.writingclasses.com/toolbox/tips-masters/george-o...
- Get comfortable on the command line — it's almost a running joke now that modern tools are often outperformed by awk/sed/grep/cut/etc
- Go through the book 'Seven Languages in Seven Weeks' — You won't thoroughly learn those seven languages, but you will learn how to learn programming languages
- Get good at recognising hype and reducing marketing language to their core ideas. This seems especially applicable in the JavaScript world (though this may just be my confirmation bias speaking)
- Get good at accurately defining the problem you intend to solve. This would seem so fundamental that it isn't worth mentioning, but you'd be surprised how often people jump to "Ah! An excuse to play with shiny new framework/tool/languge/whatever" before knowing what it is they're solving
Most of these seem quite fundamental, but you go an awful long way in this industry on fundamentals.
"Not only working software, but also well-crafted software
Not only responding to change, but also steadily adding value
Not only individuals and interactions, but also a community of professionals
Not only customer collaboration, but also productive partnerships"
I fail to see the "scam" here. Your follow-on comments seem to take issue with some of the popular opinions on how to best accomplish the goals above, but that hardly disqualifies the effort to improve software development as a profession outright as a "scam".
In practice however, it's a different reality.
Let's not forget that SC's perhaps most infamous proponent once said that C++ is a "man's language", and that Java is an "oestrogen" language.
I feel like C++ is the antithesis to the "manifesto" posted in the parent. I /like/ C++, but it seems to me like it is nearly impossible to write code that is easy to read, easy to change, performant, and correct, all at the same time.
I'd love if you could expand on this topic. What do you mean by charlatans?
I am not saying this is the common case. Naturally, there are many brilliant people in our industry. I am however saying that this happens enough for it to be a concern of mine.
As tempting as it is, I won't name names.
The 'Appeal to Authority' fallacy creates a feedback loop here too. They mislead to gain authority. They use that new authority to gain more opportunities to mislead.
- There is no integrity in keeping silent when witnessing wrongdoing, even when speaking out may harm your current business prospects.
- Most "interesting" ideas in tech currently simply aren't.
- "Software Craftsmanship" is a scam.
- Programmers are far less logical than they would themselves believe.
- Non-tech project managers in tech teams are beyond useless; they're often plainly harmful to the business.
This is not an exhaustive list, and I didn't learn all these things in the past 12 months. Some have just been beaten into me more over the past year.