Starting in 2016, I've somehow become a developer with ten years of experience. The reason I called it a "slightly early" retrospective is a nagging feeling that maybe I should write it only after completing a full ten calendar years. The reason I'm writing this early retrospective with that lingering unease, before hitting a full ten years, is that with childbirth ahead of me, it felt like a good time to write while my body and mind are relatively at ease.
Ten years isn't a short span, so I'll be feeling my way through hazy memories, like watching a low-resolution video. And as I organize the things that happened back then, I'll reflect with the mindset of preparing for the next ten years.
I call it a retrospective, but I realized it might turn into a piece where I flail through distorted memories of ten years and grumble out my complaints and gripes. And while I feel stripped bare imagining someone reading about my past, I'll begin with the thought that maybe my foolish moments could be of some help to someone as a "I should never do that."
A Developer in a Well
The first company I started at as a developer builds services and solution programs for editing and viewing documents. My start in front-end development began when I was assigned to a web office development position, building a service that let users manage documents in a PC browser. Back then smartphones were emerging, there was high demand for Android and iOS app development, and since I had studied Android development, I hoped for an Android development position, but I came to feel that a company is not such an easy-going place.
At the time I hadn't applied to start in front-end development, and I had neither Android nor iOS development experience, nor had I studied deeply enough to feel tremendously confident, so front-end development was, for me, nothing more and nothing less than landing a job as a developer.
During the four years of doing front-end development at my first company, I'd say I was thoroughly buried in the service I was responsible for. When I made up my mind to change jobs and boldly interviewed at several companies, the feeling I got was, I think, similar to the fear of a frog out of the well suddenly thrust into a bigger world, chased by countless predators. The truth is, I did front-end development for four years, but I hardly thought of it as studying; I only looked things up bit by bit as needed within the project I was building. The interviews were a place where I had to take an endless barrage of reproach and rebuke with my whole body, like a criminal in a courtroom. As I said earlier, after landing my first job I placed no more and no less meaning on it than "employment as a developer," and I want to call the me who silently did only what the company told me for four years a foolish idiot. Even as I write this, I wonder whether I'm still living like a foolish idiot, while also consoling myself that maybe I've become a little less foolish than back then.
Memories of Overtime
Among the four years at my first company, I have a memory of my very standard for overtime shifting, dressed up now as a fond memory. Back then there was a service tied to a large corporation, and overtime began in order to meet the client's demands on schedule.
When people say "overtime," how late do you imagine working? Having dinner and heading home around ten or eleven? Or, at the longest, one or two in the morning? Back then it was a matter of course for us to grab a separate snack or a meal at midnight as the day rolled over, and there were days when going home at one or two in the morning felt like an early night.
The memory that stays with me most is when the company had a contract with a café in the same building that provided sandwiches or gimbap for breakfast in the morning—and I remember, after pulling an all-nighter, receiving my gimbap in the morning and exchanging bitter greetings with colleagues arriving for work before heading home myself. Another memory: around three or four in the morning, while heading home with a friend who had joined as a new hire alongside me, my friend said in a sad voice, "I don't think development is the right fit for me…"—and it still comes to mind like watching an old black-and-white video.
We kept up overtime with no extra pay for about three months, and we somehow met the schedule, but I remember the contract didn't work out. If, during this period, there had been plenty of developer work and I'd grown a lot from it, that would have been great, but the atmosphere back then was such that even when I had no work of my own, I had to stay with the colleagues working overtime and at least help with testing.
I'm not sure whether the tolerance for overtime this experience gave me is a good thing, but ever since, even as I've moved between other companies, working a bit more doesn't really bring the word "overtime" to mind. That said, based on that experience, when I change companies I don't mind having a lot of work, but I check whether it's a comprehensive-wage system, and if so, whether the compensation for it is decent.
These days, with the peers I spent my new-hire years with, I dress it up as a fond memory—"it was like that back then"—and pull out the "back in my day" routine, talking like veterans who survived a hard war. But if there's someone reading this going through a similar experience… I want to tell them: run away to a place where your effort and ability are recognized.
Between Loyalty and Leaving
At my first company, which felt like a place I'd stay forever—so much so that I wonder if the word "job change" was even in my head—I made up my mind to leave for a trivial(?) reason. The trivial reason stemmed from a personal feeling that, after four years of loyal service, I was being seen as little more than a laborer paid a salary and simply told to work. Looking back now, I think it's only natural for a company to view someone as a laborer paid a salary and told to work. That much shows how thoroughly calculated and coldhearted a company—and society—can be, and I think it's something I must never forget. This way of thinking seems to help me grasp my situation a bit more realistically and make decisions when changing companies or moving teams.
What I realized after preparing to leave and moving on was that the project I had poured my affection into and developed so hard was, in the end, not mine but the company's. Back then, as a rookie developer who was there from the start of the project, the moment the finished program sold and got recorded in the company's revenue felt as joyful as if my own child had succeeded. But the moment I realized the obvious—that this child was not mine—I felt a bit of hollowness. With this feeling, I think I came to develop, as a developer bound to the company, with the mindset of a support agent doing their utmost to respond to a customer's service. The one difference is that, during year-end evaluations or salary negotiations where I settle up a year's worth of work, I look back on the services I handled thoroughly as my own portfolio. Thinking about it again, the program itself was not mine, but the work I did was, in the end, my own asset, and creating that asset and organizing it well was also work I had to do myself.
Even if I'm not leaving the nest right away, I should have been taking good care of the things I have to do, but lately I've been neglecting the things I ought to have done. Just as nothing is forever, I think I should occasionally organize my go-bag as if staying ready for a disaster, and I ought to set aside time to tidy up my go-bag, which has been sprawled about for a while.
Ten Years In, With Debt Piled Up
At my first company, I didn't worry about my competency as a developer, nor did I study hard, so I gave little thought to years of experience. It was only after I began preparing to change jobs and saw requirements like "3+ years," "6+ years senior," and so on that I started to feel both expectations toward high-tenure senior developers and pressure about my own years piling up.
Afterward, as I moved from smaller companies to gradually larger ones, I'd say the expectations around high-tenure senior developers turned out a bit different from what I'd anticipated. What I had expected was explosive growth as a developer thanks to tremendous technical mentorship. But I realized that one's own growth is impossible without the will and effort to grow, even if there are many excellent developers around. A company is not a place that teaches you like a school, and the effort for your own competency, I think, rests purely on your own mindset. Of course, the company I'm at now encourages study groups and supports some specialized training programs, so it offers a path to grow if you have even a little interest. Looking back at myself, I think I should take more interest in these opportunities for growth and work hard to fill in the time I spent as the foolish idiot I mentioned earlier.
I've already become a developer with ten years of experience, but I sometimes doubt whether the current me can even be called a senior developer. Before, I felt my competency fell endlessly short of being called a senior developer, so I called myself a "middle-nior developer" (somewhere between junior and senior). Even now, doing code reviews on projects, there are times I feel endlessly sorry to the colleagues I work with because I can't give code reviews befitting my years, and when I receive code reviews, I blame myself, thinking I should have taken care of these things more carefully in advance. This is the karma of my ten years, and going forward I'll have to study and strive endlessly, as if paying off overdue debt.
Front-end development has seen a lot of technical progress over the years, and right now it seems another change—AI—is underway. To become a developer is, I think, to be someone who must not give up on advancing alongside technology and responding to change, but take it on as if it were destiny. Reflecting, I found myself wanting to ask the developers reading this: What do you think a developer's destiny is? And are you doing that job well?
Wrapping Up a Slightly Early Retrospective
Before wrapping up, to anyone who expected technical insight from the title "Ten Years as a Front-End Developer: A Slightly Early Retrospective," I'm sorry—but I'll offer the excuse that from the start this retrospective began as a reflection on ten years of experience, without any consideration for that. And while I do feel it turned into a strange retrospective mixed with my complaints and gripes, I think I've managed to sort out, in my own way, the things to be careful of and avoid, and the things I ought to do going forward.
For the finish, I don't plan to do the retrospective-y thing of organizing the matters above into a list, or extracting action items and verifying that I'm carrying them out well. That's because I consider them obvious things to avoid and things I must do, and because I also wonder whether, when I read this again later, my thinking might change. If I write down one thing I definitely plan to try, though, it's this: I intend to read other developers' retrospectives and peek at what thoughts they hold that differ from mine.
”Whoso neglects learning in his youth, Loses the past and is dead for the future.” - Euripides -