Discover more from The Software Sense
Human Aspects of Working as a Software Engineer
A small collection of cases that frequently occur when working in the field of Software.
We are Software Engineers. We pride ourselves on writing the most concise code, to create good architectural designs. We tend to believe that our professional life is full of code, debugging, drawings on whiteboards, and software problems to solve.
There are other aspects of working as a developer, however, which usually affect one’s mindset and productivity when working. Whether you are the manager of your company or a developer in a big team, you should not ignore these less technical aspects of the Development’s lifecycle.
Thanks for reading Christos’s Substack! Subscribe for free to receive new posts and support my work.
Let’s take some time and elaborate on some common cases that have happened to almost all of the developers I know (including me).
The case of idea proposals in a development team
It’s not uncommon for me to become part of discussions where new ideas are thrown to the table faster than they can be processed. That’s awesome, and it should be done regularly. It shows a healthy team and a willingness to participate in collective decisions. It is also an indicator of how good are the relationships between colleagues. If a colleague proposes a radically new idea, it means that this person values your opinion at a level that overcomes the possible discomfort of being rejected — and that’s a good thing.
An example of a new idea would be to follow a new artistic direction inside a computer game, to use a new programming language for specific tasks, or to implement a new feature.
Ideas always come at both a cost and a potential gain. Often, people will reject one because it may bring the team a level of effort that it may become unmanageable before it is fully materialized.
I have been lucky enough to participate in teams where thought-sharing was widespread, but so were rejections. One thing I noticed is that rejections are often done by seniors, leads, or stakeholders (product owners, managers). To me, that makes sense because a high level of familiarity with a project also brings a better view of future software risks. Especially in the case of stakeholders, visibility about time plans, and the dangers of project deviation is much higher than the rest of the team — regardless of the level of communication.
The route of discarding a new idea always has an emotional headstart when compared to the path of taking a new risk, usually because of the following reasons:
Doesn’t fit with the time plan nicely
The proposal requires refinement, and often this refinement is eventually done by the senior devs, who may or may not be willing to risk their productive time for something that may not work in the end.
The feature may not offer the benefits that it should, considering the effort that would have to be put into it.
But here’s the thing — the proposer almost always has a different view, a complete picture of the proposal in its end state. Since the rest of the team may not be able to grasp the new idea in its entirety, it’s more likely to avoid spending time in trying it.
In these situations, if you are the one suggesting something new, the best thing to do is for you to put yourself in the place of a stakeholder.
If you are a developer, this means that the next time you propose something, suggest to materialize/implement it yourself. Offer yourself to implement it, and create a proof of concept. This will not only give you a considerable amount of knowledge but will also earn you more respect from your peers.
The case of shifting development direction
Smart people (and teams) change their minds
- Jeff Bezos
This applies everywhere — in Software, even more so. There is a reason why, in big projects, there is something called iteration. It means that you had an idea of what you wanted to do and started with path X. Later, you need to scale, and you intend to follow path Y, which will allow you to scale up. This is called “changing your mind”.
The practice of clinging to an idea just for the sake of it has a name, and it’s called “unhealthy fixation”. We live in an industry where mind-shifting is very common. As professional developers, we need to adapt, think new ways of implementing what we want, learn from our mistakes, avoid the pitfalls of the past. As people working in Tech, we need to change our minds, and we need to do it often. As long as we can always justify our choices, of course.
Until I realized this little piece of advice, I was getting annoyed each time that I would have to throw away some of the work previously done, because (as I believed back then) the original specifications were not solid enough. Now, I know that what is going to stick for years to come is not the lines of code I write, but the solution I provide as a whole, and the small joy a feature made by me brought to the users of it. This realization made me change my mind radically as well at some point in my life, and so far, I haven’t regretted it.
Here’s a fun fact: When Steve Jobs presented the iPhone 1.0, it didn’t have any apps or an App Store. It was supposed only to have web apps and expand its ecosystem there. At the time, it seemed like a logical decision, and the media were very fond of the idea of having a web-based platform for web apps in the palms of all people. When the iPhone 2.0 was released, Steve Jobs announced the new App Store, a radical change of direction, providing a platform for 3rd apps to be written in Objective C and published to the end-users.
Imagine how the world would be today if that mind shift hadn’t occurred.
That doesn’t mean that you shouldn’t pay attention, though. If you believe that you are shifting directions in a way where your team/company/wallet is starting to show signs of burnout, it’s time to stop and rethink what you are doing. You are then not just changing directions, you are chasing your tail, and you may also be suffering from the Leonardo Da Vinci Syndrome.
The case of deciding on a technology to develop with
I believe we (as Software Engineers) can consider ourselves very lucky to have decided to follow a profession revolving around Software in this era.
Never before were there so many diverse technologies to choose from and so many sources of knowledge to be taught. However, in this glorious era where the science of Software Engineering is thriving, we often find ourselves amid echoes of an “echo chamber” when trying to figure out what technology is appropriate for us. The Internet is filled with articles about how X is better than Y, with big phrases like “the next big thing”, and “don’t miss this out…”.
It’s all a windmill or technologies priding themselves to be the best for your use case. However, you should realize that numerically-quantifiable technological metrics (like “performance” metrics, compilation times, etc.), are temporary. Any measurements you see at any given point in time are bound to change as technology progresses. No matter what technology you use now, it’s probably going to be surpassed by something bigger, faster, better, or simpler.
When researching the stack you are going to use, you must have a “decision framework” that’s more likely to stick and apply to your project even if something faster comes along.
In other words, you need to invest in your approach to solving your problems and not just rely on frameworks. What should differentiate right from wrong appliances are project requirements — not technological trends.
For example, NodeJS being all-async with high performance is not why someone should choose to use it. NodeJS has been surpassed by other frameworks for quite some time now in this regard. I usually prefer to work with NodeJS because of its great programming model (middleware logic), its fast iterations, and its enormous ecosystem. However, when it came to deciding on a framework for a team of developers working across the globe, I thought differently. I proposed a piece of technology that heavily relies on a statically typed language that would facilitate communication through code and future refactorings. I put my personal preference for NodeJS aside and put the priorities of the project/team first. The team then invested time in devising an approach to solving our problems, which would also allow the team to make pivots (even in the language used) without rewriting the project from scratch.
I believe this is the basis of a well-thought “Software Engineering” process. Cold, hard math — all choices should be the result of a careful analysis of the requirements at hand. Perform analysis and accompany it with a proper architectural design before you start developing. Otherwise, you may end up with a failing implementation — which will stem not from bad technologies, but bad choices.
The case of the Brilliant Jerk in the office
Working in Tech requires a certain kind of skill and knowledge. It also necessitates the ability to learn, adapt, and communicate. Especially in software teams that have undertaken a big project that is going to last more than just a few months, communication and adaptation are essential.
It’s not uncommon in the profession of Software Engineering to come across people who are considered “Uber-skilled jerks”, or “Aggressive Rock-Star Engineers”.
I have had my fair share of such encounters during my career, and I have witnessed firsthand the negative impact on a team’s performance such a person can have. Managers were too afraid to give them any negative feedback because they didn’t want to lose them. Team members were too scared to confront them because they didn’t want to end up in a fiery argument about the implementation of each task. The biggest loser in this situation is the project.
The solution may seem straightforward — letting those people go. In my opinion, this approach is too simplistic (sometimes amoralistic). Firing a good developer means losing a skilled person with in-depth knowledge of the project, without examining alternatives or the causes of this problematic behavior. If you aren’t sure what is causing this behavior, it’s very likely that you stumble across the same situation in the future, even if that person is moved away from the project.
Most of the time, those high-skilled engineers have a much deeper motivation than satisfying their ego. They usually tend to believe that their hard-earned knowledge is being thrown into the trash when a less experienced engineer questions their methodologies. They may have been working overtime for years to obtain this kind of expertise, rapidly committing pull requests to projects past midnight, to solve one more hard-to-find bug before the deadline. Let alone the implications of a possible inability of these individuals to delegate, which results in constantly being overworked, and always being in a bad mood.
If you are the manager of such engineers, keep in mind that much of the time, situations such as those are solvable, not by laying these people off but by performing the exact contrary. Acknowledge their hard work but do not miss out on the opportunity to give them honest feedback regarding how their actions affect the rest of the team. At the same time, alleviate their burden by assigning some responsibilities to other members. Try to create space for other people to grow. Stress those “problematic” employees to acquire some new skill sets — those of becoming more of a mentor and less of a coder. If this works, you will be creating future Leaders.
“There is no level of technical expertise that can justify breaking a team’s morale”
I feel like I barely scratched the surface of the cases above. There are so many things I could talk about (as I’m sure others have many thoughts, too). Working in the Software Industry is competitive, messy, and at times chaotic. But it’s also beautiful, creative, and rewarding.
The only thing that can guide you through this creative chaos is always to keep an open mind, question everything respectfully, contribute your ideas, and not be afraid to change your ways.
Thanks for reading Christos’s Substack! Subscribe for free to receive new posts and support my work.