Liquid error: internal
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.