loading...
Cover image for You Deserve to be a Software Developer

You Deserve to be a Software Developer

lethargilistic profile image Mike Overby Updated on ・5 min read

This "Juniors" #DevDiscuss tweet struck a chord, so I figured it would be worth expanding.

I've seen it said more than once that people should be "thankful for having a job."

Most often, it's weaponized against low-credentialed workers like those at McDonald's counters or in Amazon's sweat shops when those people advocate for wages high enough to live independently of government assistance or community support. They should be "thankful" for what they get, so say hecklers who often do not work those jobs or have not for a long time. They see themselves as differentiated by experience or economic strata yet still within their station to weigh in on how much those presumptuous chefs deserve from their lives of service. "Their employers didn't need to hire them." "Those jobs are for children." You've heard all this.

Among high-credentialed workers like software developers, the "thankful" line is usually used with a more passive aggressive bent as a signal from developers with more years of experience (from here, "senior" developers) to junior developers. They want juniors to know they are less valuable, are there because the corporation is charitable, or are there in spite of the fact the junior does not deserve their position. Much as with the low-credentialed folks, the phrase is weaponized because it assigns a moral value, thankfulness, to an arbitrary barrier people erect in their minds between themselves and those at other career stages. This separation allows the senior to turn a blind eye to practices that are openly hostile to juniors like wage depression, bullying, or making a show of refusing to hire any juniors at all. It is a proxy for divvying the workforce by who "deserves" work, always conveniently judging the speaker deserving and never at risk of a wage cut.

After all, nobody questions how much a senior developer deserves their position or asks them to be "thankful" for being there. They are bombarded with letters from recruiters looking for applicants to the point they find them annoying. They don't have to question whether or not they'll be able to find work if/when they quit their job, whether the reason is that job actively mistreating them or simple boredom. They would have you believe there must be a reason for that barrier, some intrinsic differentiation that exists between seniors and juniors that makes a senior more deserving of work because they exaggerate the dues paid as a junior. There isn't. We are all workers, and software developers need less elitism at our luxurious intersection of "lucrative" and "not terribly hard."

This difference in perception and treatment has created a critical deficit of empathy because the experience of a senior, constant reinforcement of seniority's value, contrasts so fundamentally with the constant negative reinforcement juniors are subjected to for the crime of having worked fewer hours. This empathy trouble is pervasive among malcontents jealous of their positions in hierarchy, but also reveals itself among would-be advocates. They tell juniors that there is a caring environment out there for them or that they will find work because their skills are in demand during a talent shortage. Well-meaning, certainly, but misleading: there is no shortage of software developers.

This is a perceived shortage of developer seniority, and it is self-inflicted. There is a strong filter in hiring that excludes junior developers from positions that in no way require leadership or overarching design acumen, senior skills realistically earned working with more experienced developers as a junior. That filter is the years of experience requirements for "entry-level" positions. That filter is the laundry list of technologies that may-or-may-not even be commonly used in the position. That filter is only counting experience as valid if it was working for a corporation—I've been programming with Python for about 7 years and just had a very rude hiring manager shout "WHERE?" at me over the phone. The fictional shortage does not need to be perpetuated by senior developers lording their number of years on the job over juniors or exacerbated by thought leaders signalling that junior developers have the power to do risky things and assuredly land on their feet. Telling juniors that everything will be fine if they take the risks a senior developer can afford due to seniority's exorbitant privilege is setting juniors up for failure. The unfair reality is that those risks—quitting abruptly or holding out for super nice employers—are not widely available to juniors perceived badly for being "flight-risks" or generally not valuable.

Aside, it is incredibly common for people who advocate for juniors to be aggressive self-advocates, compassionate, or otherwise bright-eyed to have started their careers as "jerks" or "assholes". Their advised behavior is not what got them hired as a junior, and not what fostered them until they were a senior, at which point their behavior after a good change of heart is irrelevant because they can write "4 years" on their resume. I agree with striving for this idealism as the future for software development, but it is revisionist and highkey dishonest to advise things like that when that was not the advisor's experience. It is cruel to say all it takes to build a successful software development career is a good attitude, being a habitual learner, or insisting that you can "learn on the job" when those traits have nothing to do with getting your first jobs and project weakness and unproductivity to people in charge of hiring juniors.

If you're looking for one key takeaway from this post, let it be this mantra: "My Job is a Job." Software development is a profession, software developers want to build careers in that profession, and people work jobs as software developers. Maybe you are at a different stage of your career, but there is nothing particularly special or glamorous about working a job, i.e. selling or investing your labor to a project, something both seniors and juniors are doing. Resist the temptation to arbitrarily divide yourself from others based on how much you think they deserve to be there.

The truth is that a junior developer "deserves" to work just as much as a senior developer; every senior developer began their career as a junior. Furthermore, if an organization-of-size doesn't hire any junior developers, then it doesn't deserve its seniors. If your organization does not hire juniors, then it is unconscionable and morally reprehensible to say "everyone should code" and give a generation false hope of overcoming class struggles. This is especially true in the United States, where I'm from, because any time someone says you should be "thankful for having a job" you can feel free to rephrase that for them as "thankful for having health insurance and the means to live independently."

Seniors Deserve to be Software Developers.
Juniors Deserve to be Software Developers.

You Deserve to be a Software Developer.

Posted on by:

lethargilistic profile

Mike Overby

@lethargilistic

Mike Overby is a software developer looking for work, host of a law review podcast called Amicus Lectio, and a moderator of Programming Discussions (invite.progdisc.club). Follow me on Twitter!

Discussion

markdown guide
 

In my opinion, the number of years experience in a programming language or technology isn't what makes someone a senior level developer. It's entirely possible for a developer to have 1 year of experience 10 times over, so years of experience is a garbage metric. I actually consider the title of senior to be absolutely dependent on junior level employees being present. If a senior developer isn't mentoring and growing a junior developer's skills then they aren't a senior level developer.

 

I see this all the time. I can’t tell you how many interviews I have done with a senior person with 10 plus years does not have the competence and experience to do a junior level develops task on my teams.

It comes down to experience.

This is the same reason I have junior developers do code reviews, knowledge shares, and in short treat them like any other developer. As their experience grows, so does there responsibilities.

 

Absolutely agree with this.

 
 
 

In my country there's a saying which roughly translates to "In this country, if you don't have a job , is because you don't want one".

You might track the origin of this saying to another time where this country was well placed in the world ranking, when there was actual prosperity, and when it served as a place where people from poorer countries or countries at war could go to start a new life filled with oportunities.

Of course that time has passed a very very long time ago, but the idea that having a job is a matter of choice remains, even when you can see hard evidence on the contrary everywhere. It's pretty mind boggling.

I see this type of comments coming often either from "older generations" or from people who was born in homes where everything was provided to them, and they didn't have to actually climb the ladder of reality to arrive to their current position, but they feel equally justified to gatekeep their "struggle" from their place of privilege. It's a kind of inferiority complex I think. It's very sad.

 

It's definitely similar here in America. I try to force myself to go easy on older generations by reminding myself that they went through their own struggles to get where they are. However, they never dismantled the systems that oppress the young. Here, instead, they dismantled systems intended to help the young, as soon as they got comfortable and no longer needed them. I just can't feel much sympathy for people who don't regret—or even acknowledge—that that happened.

 

The word junior has become attached with quite some negative connotations. I think instead of using the title junior software engineer/developer, the 'junior' should be dropped and positions should be advertised as simply 'software engineer'. Furthermore, there should be an intermediate position as well as a senior position.

 

When I was looking for a job I really gave no thought to my own title. I sort of just naively proceeded. And it worked. Sometimes I wish other newer devs were less aware of a perceived hierarchy which erects walls in their own ambition.

 

When I was switched to Senior Software Engineer, it was brought up to me by a "junior" with awe in his eyes (less than 1 year in his career) and I told him I didn't even know since nobody had told me yet and that there was no difference from the week before as far as I was concerned.
Being in Japan, the hierarchy is important and so even the way he started to talk to me was more "reverent" ... It felt so strange that I stopped going to lunch with him.

 

When you are not worried about the title, the wall is the years of experience. When you go through the description and see a 5+ years required, it is hard to go forward. It is obviously aimed to senior developers.

 

Atleast at my company, the different roles in the 'hierarchy' are well defined, which in turn provides a clear idea of where you need to grow and what you need to improve for each jump.

Yeah, I don’t want to dismiss the value of the hierarchy, but my own head-in-the-clouds outlook on the whole thing really wound up being a feature and not a bug. I never felt like I had to pay my dues at any certain level.

The world sort of holds you to your title, but if it’s not important to you, it’s not necessary that you hold yourself to it.

 

TL;DR: You don't need permission to develop software.

If you're looking for one key takeaway from this post, ...

The takeaway that was key for me is this; everyone is afraid. It essentially boils down to, "I don't want to hire the wrong person." (one of "I don't want to make a mistake"'s many children) which reintroduces the catch-22 of needing to get experience and not being hired due to lack of experience. The more money involved/bigger the company, the greater that fear and the more things people will do to try and ensure "hiring the wrong person" ("making a mistake") doesn't happen.

It's probably impossible to change the mentalities of these job-fearing people. After all, "you should be thankful for a job". We still tell kids to get jobs. This is wrong, imo. The problem starts there. Maybe if a job wasn't placed on a pedestal, people might feel confident enough to branch out on their own more often.

No one cares about your experience if you create a functional something that they like.

I get it, bills, food, etc. So, jobs. It just seems disconnected from a domain with such low barrier to entry and unlimited range of application. The next "Blahblahblah" can be written by a 20 year old in their dorm room, they'll then quit college/uni and continue building the thing full time -- this pattern has happened so many times it can be called a pattern. Everything that is Minecraft was essentially started by one man.

So, why lay prostrate for a job?

I say, "Would be software developer, you deserve better."

Not quite a solution, just a different perspective.

 

I find the Jeffersonian outlook comforting at times. (He believed that America should be comprised of individualist and independent yeoman farmers.) However, the reality on the ground is that working for corporations is the way to make money in software unless/until you have an idea of your own. Barring something like a universal basic income (I'm hesitant) or a radical reversion of our global relationship with corporations (they used to not be so scary), I don't think appealing to the market's lottery-like system is so much more realistic and stable for most people.

 

I don't think appealing to the market's lottery-like system is so much more realistic and stable for most people.

It isn't. :(

If everyone said, "F this, rolling my own." we'd have too many chiefs, not enough indians. Is that analogy even PC anymore? Anyway, every ecosystem in every industry would look like JavaScript, and we most definitely can't have that.

the reality on the ground is that working for corporations is the way to make money in software

This reminds me of Pandora's Box. A corporation isn't what it used to be, but, now that it is what it is, there's no going back. That's... unfortunate, even if someone can say, "But look at how many jobs Acme made!" ... kinda like Wal-Mart.

 

Going out on a limb here, my first comment on dev.to...

I agree with everything except that all companies should hire junior developers (not stated directly but implied).

Some companies and teams cannot realistically coach a junior developer if they are dealing with live site issues just about daily and have no or follow very little good software practices.

This environment will sink most junior devs and slow down the team (i.e. may go out of business, yep this is real).

This type of team or company running in emergency mode unfortunately is most likely to under pay, over work, and not treat junior devs fairly. My two cents: Take any job to get experience, but keep searching until you find a 'real' software company. Your career will see a turbo boost and you will be happier.

 

I would argue that if you have a team experiencing this issue, that you already have a team of junior engineers, one more wouldn't hurt. A real senior dev though might help get the team into a good place and put and end to constant chaos by developing the existing juniors that created this sort of mess.

 

I said "organization-of-size" to cover this nuance in passing. The article I linked out to has a good rejoinder to this comment.

 

Hell yeah Mike! :-)

Senior is also a word that means something different to different organizations. Some call senior devs people with 5+ years of experience, some 7, some 10.

I have no qualms to admit that I was hired at my first real fulltime job for two reasons: I was visible on Python local mailing lists AND I knew someone at the company.

Knowing someone who knows someone is still the easiest way to get a job interview at least.

Thanks, you reminded me of this post and the discussion that followed:

 

I was very tempted to write about how deeply rooted referrals are embedded in our "meritocratic" hiring, but thought the article wouldn't be focused enough then.

 

Well, you can still write another one :-)

 
 

If a company cannot hire junior devs because its senior devs don't have time to mentor them, then that company is already stretching its senior devs too thin.

I personally agree with those that say that people who have been coding for less than a year will hardly have enough knowledge to work a realistic junior developer position. However, I had been coding for 10 years on my own before landing my first real, dev job (as a junior dev) and found myself doing most of the mentoring. Part of my responsibilities as a junior was to integrate and teach the use of Docker, Javascript, Angular and Go to all of the senior devs who worked almost exclusively with Java (directly on Windows) for the last decade. Obviously, the company leveraged my lack of "real" experience to try and stick me with a miserable salary (for dev positions). This is a common practice in neoliberal America where salaries are based off negotiations not credentials.

I obviously receive mentoring from the senior devs in matters of management and design which IMO is more valuable than any of the technologies I brought along. They may be outdated soon but software development is still a growing field when it comes to the administration of labor and organization of tasks.

I think companies are mistaking "junior dev" for "experienced software developer that hasn't worked for a F500 company".

 

The most hype I have heard about “we must hire juniors” actually comes from (surprisingly enough) juniors.

When I was "junior", I didn't know anyone or advocate for anything. I think most juniors keep their heads down and do their work. There may be some outspoken, but I think most of the actual discourse on this subject comes from experienced developers who have good relationships with their newbies and want other orgs to do the same.

I agree with your suggested method of evaluation. However, most companies wont even call you back if you don't have some big name on your resume. And, in my experience, a large enterprise has more "wiggle room", for lack of a better term, to hire junior developers. In a startup, there are fewer safety barriers between the junior dev and the production codebase. A large company often has a large amount of non-critical projects that a junior dev can join to learn the non-technical processes that are critical to the stability of the client facing product.

 

Seniors need juniors as much as juniors need seniors. When I started being in charge of reviewing developers job applications, I wanted all our new hires to be seniors, but I ended up having to "settle" for junior developers. And I'm really thankful for that, now I see you can't call yourself a senior developer if you can't guide a junior through his learning process.

 

Like many others who have commented, here, I generally don't care for the words "Junior" or "Senior". The use of the word "junior" has become somewhat pejorative and used to establish a sort of pecking order, as others have pointed out, and "senior" is has become bankrupt.

I think what matters most is really what John Allspaw calls "maturity".

 

We were all developers jr at the beginning, so I do not understand the problem. There are people who believe they have a great knowledge and therefore less value to others. But in the world of technology, there is always something you do not know.

When I started working I did not have those problems and now that I help with the recruitment, I make sure that everyone has the same opportunities.

A serious mistake is to judge without knowing.

 

Programmers are procrastinators. Get in, get some coffee, check the mailbox, read the RSS feeds, read the news, check out latest articles on technical websites, browse through political discussions on the designated sections of the programming forums. Rinse and repeat to make sure nothing is missed. Go to lunch. Come back, stare at the IDE for a few minutes. Check the mailbox. Get some coffee. Before you know it, the day is over.

 

You can't really "learn to become seniors sooner" if your seniority is measured in years of experience working in a classic enterprise environment.

 

This article was one of the best reads I've had in a while! Thanks for sharing and writing I can relate to this!

 
 

Fortunately companies like this are likely to fail if this attitude persists. The ability to work in teams is just as important or more so than individual competence.