Loneliness is weird in many ways. Despite tech connecting us, chronic loneliness still affects people. The threats it poses to a person’s health aren’t talked about often, but they’re very real. Dropping out of school, alcoholism, anxiety, sleep, hormone imbalances, suicide, and other aspects of physical health, can be fueled by our (lack of) relationships.

There’s been research about how chronic loneliness could even be a public health issue. But admitting to loneliness has a stigma equivalent to not being independent or being socially weak. Plus, to be frank, it’s harder to accept loneliness being hazardous to one’s health than something more clearly dangerous, like poison in the water.

Yet it’s easy to get how our bodies would react so badly to social isolation. In humanity’s earlier days, more social connections meant more people to share resources with. That’s why it became hard-wired as a need over time. Yet that wiring hasn’t changed for today, where most of those everyday hazards are gone.

To summarize, a lack of social connections can lead to major health issues due to outdated mental wiring, oft overlooked due to a lack of discussion and negative stigma.

So yeah, loneliness is a curious thing.

The Difference with Solitude

But the most interesting part, to me, is the line drawn between loneliness and solitude. The line between how being alone can either be good or bad for us. Can make us discover new strengths or wither our spirits. How do we define that line?

It was hard for me to understand for a long time. Too much alone time usually made me suffer during high school and college. I have just as much, if not more, as an adult, and it’s the total opposite. I feel productive, at peace, and reasonably happy. What could have caused just a drastic switch in less than a few years?

It likely differs from person to person. The secret ingredient to beating loneliness could be self-awareness, living in the moment, spontaneity, having goals, a sense of purpose, self-control, or any number of vague-sounding yet positive-sounding things that matter a lot.

For me, it was simply acceptance. Being alone is one thing. Being alone without judging myself is another.

Ignoring that Lonely Voice

Loneliness is a feeling that’ll always exist in humans, some more than others (like me). On its own it’s really not that bad. The real pain came from all the thoughts I dumped on myself because of it.

  • Do people not want to talk to me?
  • Did I do something to drive them away?
  • What’s wrong with me that keeps me inside?
  • Am I shy, afraid, or just a recluse?
  • What will others think of me for being so alone?
  • What did I do wrong to deserve all this?

These questions aren’t meant to be answered. Simply asking them was enough to beat down my self-esteem - trying to answer them only made it worse. The only thing to do is shoo them away, like flies buzzing around our head. Emotions like loneliness aren’t really harmful on their own. How we react is where the real harm happens.

Finding the line between loneliness and solitude is important. More importantly, we can choose to cross it or not.

Part of being a junior dev is controlling the overwhelming pressure I put on myself to learn as much as possible.
For my first web project that wasn't a website, I broke down a goal that involved Node, scheduled functions, the Twitter API, and a feed of anime wallpapers.

What time of the year is it? New laptop stickers!

This is one developer cliche I embrace with pride. I love getting new stickers and putting them on my laptop, sketchbooks, notepads, boxing gloves, battering rams, and whatever else. I love them for the same reasons I love buttons - simple, fun, shares ideas, and are convenient drag-and-drop personality. Part of me sees the vanity and consumerism behind them, but that doesn’t outweigh their benefits. Namely their being a testament to the dev quirks I love.

What better way to express individuality than RedBubble stickers?

I aimed for these assorted stickers to send four total messages.

1) Front-end Dev Pride

Despite my increasing focus on back-end code like Ruby and Node/Express, front-end is still what I do best. I figured stickers to convey this would be most important. People have especially enjoyed the one on how “awesome” CSS is. One would be surprised how often text or images not fitting in containers pops up in my work. Those in the field would be less surprised and more filled with frustration bordering on murderous rage.

Those are the rare times I enjoy helping others overcome their murderous rage.

2) The JS Back-end

In my personal projects and research, the closest I’ve gotten to back-end is Node and Express. Mostly since it’s all in JavaScript, so it’s easier to wrap my head around the architecture, syntax, and other areas. I’ve dabbled around with Express apps and am excited to try more later.

Many programmers I know can’t stand this. Most hate JavaScript enough on the client-side, and the thought of it on the server-side is sickening. One literally tried to strangle me over this (not a joke).

I considered their arguments. Then I considered that I’m not using it for my actual job, and I already knew the language and could make programs with a back-end faster and more efficiently this way. Those considerations stuck with me more.

3) Ace Attorney Awesomeness

As my “About Me” page states, I’m a clear Ace Attorney fanboy. As such, whenever I see a search form on a site, I search that before anything else. It’s lead to some amusing search results, but on RedBubble I found many good stickers I couldn’t refuse.

I ordered at least three, but only one got some coveted laptop real estate. The others, which are just different stickers of Athena Cykes, are to be saved and/or admired until my world needs them most.

4) Favorite quote

Simply put, I saw one of my favorite quotes and had to include it. Not much more to say. Not much I’m allowed to say either, less I risk the wrath of a certain pair of demon overlords living under my bed.


Many things can be reliably said about almost all web developers:

  • They’re willing to fight it out over what tools, conventions, and frameworks are best.
  • They’re never 100% satisfied with what they name something.
  • They have stickers on their laptops.
  • They drink lots of coffee (I’m an exception to this one).

But of all the blanket statements/annoying stereotypes, the worst will always be:

  • They’ve dealt with Impostor Syndrome.

Impostor Syndrome is Prevalent in Web Development

Impostor Syndrome (IS) is a feeling of not being able to accept or internalize one’s successes. Basically, one isn’t confident in themselves, feels like a fraud, and is afraid of being exposed. It’s not exclusive to web development, but it’s extremely common in it. Go ahead and search “impostor syndrome web dev” online and just see how many results pop up. Popular and respected devs deal with it. Virtually everyone in my front-end Slack channel has talked about struggling with it. Now as the only junior dev in a company full of much more experienced ones, it’s certainly hit me hard these last few months. Left unchecked it can make one’s life extremely stressful, which hurts their health and their career in the long run.

Image Credit to <a href=''>Alan Levine/Flickr</a>. Image has been cropped from original version.

It’s not surprising IS is such a problem for devs. It’s an industry built on knowledge, full of people who will always know more than another. No matter how much someone learns there’s always more, so it’s hard any progress was made.

This drag on for weeks, months, years, for one’s whole career. It will hit hard. It will sting. It’ll be hard to get back up. And once they do it’ll happen again. And again. And again.

What Defines a Developer?

Overtime I’ve found my own solution to IS. It’s rooted deeply in what devs do everyday and how we view ourselves, so I adjusted my definition of a web developer. I define my career less around how much I know in total, and more around how much I learn each day. This is something I can control over regardless of the dev landscape, or how much smarter other devs are. It makes me a better dev and helps me feel accomplished. So far it’s worked great, even as the only junior dev at my current company.

Devs should measure themselves more by how much they learn, not how much they know.

I break down this “learn fast and often” mindset into four specific habits:

1) Focus more on fundamentals than specifics

Regardless of what tool is hot or been overused by a company, 95% of the time the principles behind it will be the same as others. For example, most frameworks in many languages use the MVC model, so knowing that will cover the basics of how most work right away. Syntaxes can easily be looked up or searched. The principles and fundamentals are what smart devs remember and emphasize instead.

2) Learn at least one thing a day, even if it’s small

This is less about building a obscure knowledge toolbox and more about being able to absorb new things fast -that’s much more valuable. Even if it’s just skimming new info on something different, it should be a habit. This week my focuses are Vim and Git on the command line. Even if it’s just a few new tricks or basics, I spend an hour a day looking them over.

3) Ask questions, even if they’re silly

No question is stupid in the sincere pursuit of new knowledge. Even if it is, it’s better (and cheaper) to ask a stupid question now than to make a stupid mistake later. Lately I’ve been asking “stupid” questions, but they paved the way to do more useful work while relying less on co-workers.

4) Experiment, even in small ways

A dev doesn’t need to make a groundbreaking app with every new tool or language they learn. It’s more important to get just comfortable enough with something. That way if a serious project comes up, it’s easy to dive right in. Set up the basics, know the problem areas, and make a scalable starting point. One only needs to play with something for a short time to get that far. Save it as a skeleton and then see if there’s something else you want to try. It’ll be waiting when you need it later.

Redefining what a Dev Does

All the above has helped keep IS almost completely out of my mind for weeks. When I see devs making advanced apps, writing about topics over my head, or making great stuff with shiny new tools, I keep these four habits in mind. I remember that for me, a dev isn’t defined by the amount they learned, but instead how they learned it. That tightness in my chest and biting in my skull quiet down.

As long as I keep my learning fast and flexible, those knowledge gaps will never get to me. As far behind as I may get, I’m still in the same race. I won’t be leaving anytime soon. I’ll only get faster.


My first official app idea came in a weird way. I needed placeholder text for a web project and thought, “There’s lots of weird Lorem Ipsum makers out there. Is there one for my favorite video game?” That game is the Ace Attorney franchise. And no, there wasn’t. Cue personal outrage.

Fast forward to today, and Ace Attorney Ipsum is now available for all, deployed on Heroku as a simple Node app.

It doesn’t have much complex code since, unsurprisingly, spitting out random text isn’t that tough. But I thought I’d break down the steps to making a custom Lorem Ipsum generator with JavaScript, since it was an easy yet enjoyable challenge. Hopefully someone reading this can make placeholder text from their favorite franchise available to the world too!

Make an Array of all the Text

The first step was obvious: I needed quotes. A LOT of quotes. In my case I got lucky and found the WikiQuote page for all the released Ace Attorney games at that time. The page was just what I needed - I just had to copy the HTML, remove the tags, put them in a JS array, clean up the punctuation, and it was done. My final result looked like this:

const lines = [ 
    "Random sentences go here, one at a time!",
    "Here's another one! Just keep adding them on.",
    "Look, here's another one.",
    "And yet another. Along with dozens of others."

    // ...lots of other lines here

The more lines the better, and mine has at least 1300. Obviously this is overkill, and 100 lines should be a safe minimum. You can maybe get away with less, since people likely won’t care about some repeat lines every now and then.

Get a Random Line

I worked backwards from my final goal of creating paragraphs of Lorem Ipsum. For that I’d need to make a paragraph. For that I’d need a random bit of text.

I started with getting a single line from the array. The function is simple with ES6 and fits in one line:

const random_quote = () => lines[Math.floor(Math.random() * lines.length)]

Make a Random Paragraph

Using random_quote() now gives me a random quote! Now I needed to do this several times to make a paragraph.

The function for that was slightly less simple. The only difference is setting the number of lines. I wanted some variance for a mix of short and large paragraphs. This function gets 3-6 random quotes and puts them together like so:

const random_paragraph = () => {
    num = Math.floor(Math.random() * (6 - 3 + 1) + 3),
    lines = ''

  for (var i = 0; i < num; i++) { lines += (random_quote() + ' '); }

  return lines;

Make Lots of Random Text

Now random_paragraph() makes a placeholder paragraph. The last task was making lots at once.

The catch is I wanted to let users decide how many paragraphs. This function accepts a parameter to do just that. Plus this is final function the app used, so I needed to export it.

exports.ipsum = function(num) {
  let ipsum = [];

  while ( ipsum.length < num ) { ipsum.push(random_paragraph()); }

  return ipsum;

Now it can make any number of Lorem Ipsum paragraphs a user asks for! Here’s how it’s used in the app itself, using Express for the routing:

  express   = require("express"),
  router    = express.Router(),
  generator = require('./_javascript/ipsum')

router.get("/", function(request, response) {

  response.render("index", {
    title: "Ace Attorney Ipsum",
    ipsum: generator.ipsum(3)
});"/", function(request, response) {

  let paragraphs = request.body.paragraphs

  response.render("feed", {
    title: "Take That!",
    ipsum: generator.ipsum(paragraphs)

I use this generator.ipsum function twice. The first creates three example placeholder paragraphs on the homepage. The second creates however many a user asks for from the homepage. The output is an array without <p> tags, so the template adds those when looping through the ipsum variable.

Keeping a Modular Approach

Once the functionality was done, I decided against combining these three functions into a single exportable one in the name of maintainability. Three simpler functions are always better understood than a single, large one. Plus if I want to use these pieces elsewhere, each is already separate and easy to carry over. The code’s more readable and flexible in the long-run.

I encourage keeping this modular approach if someone uses these three functions for their own Lorem Ipsum generator. Or even better, find a different approach! One of my favorite parts of coding is the same problem has near-infinite solutions. And Lorem Ipsum generators are one of those great projects that’s simple, but allows for creative solutions.

So choose your own favorite video game or television franchise, find some quotes, and give it a try! I’m sure your fellow fans will enjoy it too.