Introduction
The book Modern Software Engineering is extremely fascinating. It is the first book I read that doesn't dive into specific pieces of knowledge nor teach you what an acronym means, but it goes back to analyzing what software engineering really is, and what we need to succeed in this field.
I mean this when I say it, if I had to recommend you a single book, I would recommend you read this one. It really changed the way I think, and how I view software engineering.
Mindset change
Before, I sort of had the mentality:
I learn. I use what I learn. I believe in most of what the author says and contemplate a little. I try to incorporate what I've learned wherever it fits.
Now, that has changed. I instead think more thoroughly and question things. I even question things I currently like, such as TDD.
What I loved about the book Modern Software Engineering is how it made me think about what software engineering is and what we really do.
This has opened my eyes. I try to not just blindly read and learn things but question them, and understand as I put things into practice and experience them, my views will change, whether negatively or positively.
I think this is what many of us are lacking in today's age of our industry. We're lacking the beginner's mind and critical thinking.
Observation of the past
I read a lot of books. Some of them were published between the year 1995 and 2005. The old days of programming.
One thing I found was that during those days, the thinking seemed different. People were breaking out of the waterfall ways of developing software, and embracing being agile, embracing change during development.
It seems to me during that time, people had the mindset: We're trying to figure out the best ways to develop software and how we can improve the way we work in software engineering.
It was a time when people were really trying to figure out new ways of doing things, in a good way.
A time when more people than today were thinking critically. Back then, they didn't have all the fancy buzzwords or acronyms. In today's age, we don't just have those, but there are a lot of misconceptions going on. One of the biggest which I myself fell into is that being agile means going faster.
Being agile is about correcting the course sooner, changing the direction of development sooner to always be delivering value, not going faster.
I might be wrong, but misconceptions that we're encountering seem to be happening because we're not asking too many questions or questioning things, instead we blindly accept and trust things.
We should not trust what's out there. You shouldn't trust this article you're reading. Not trusting isn't bad, it just means you're extremely curious and always want to dig deep and truly learn.
Listen, but don't trust. Don't trust, but ask. Ask, and make sure to dig deep. After you've dug deep, question your own understanding. Once you've done that, always ask: what could be better?
We need to think critically. We need to question things. We need to be humble too, being able to question things we prefer and like.
Don't fall for the silver-bullet syndrome.
Conclusion
The point to take from this article is to not just ask more questions, but question things, question things you know and things people will share with you.
We need to think critically. We're in the early stages of software development. 50 years ago was literally the year 1972!
We're extremely early in this field and NO, we haven't figured things out yet, there is a lot of work to do, and will always be work to do.
Keep in mind, there are no silver bullets, we are and will always be figuring things out.
