DEV Community: Alex Morton

Catch the Attention of Future Employers as an Early-Career Developer \\ Umbraco Codegarden 2021

Alex Morton — Sat, 27 Aug 2022 16:56:00 +0000

This is my talk from Umbraco's Codegarden 2021.

In it, I cover different ways to catch the attention of future employers through building a solid portfolio of personal projects.

At the end of 2019, I decided I wanted to change the trajectory of my life and career by making a transition into the wonderful world of tech and software engineering.

I spent all of 2020 learning new concepts and then applying those concepts into personal coding projects. As my skills improved, so did my portfolio.

Throughout the process, I made sure to share my progress on platforms like Twitter and Dev.to. It was awesome to build a community of other folks who were on the same path that I was.

Near the end of 2020, I was contacted by my now-colleague who was looking into building his team at a very early-stage start-up at the time. Fast forward a week and a half later after a couple of interviews and a pair programming exercise, and I had a job offer in hand for my first role as a junior software engineer!

In this talk, I cover some of the key actionable insights I gained over my year of making a career transition into software engineering!

Here's the link to the talk, and here's a link to the subsequent panel discussion after the talk. Enjoy!

Setting Empty-String JSONB Values to Null When Sorting with Ransack

Alex Morton — Sat, 27 Aug 2022 16:30:00 +0000

This article has been cross-posted from the orbit.love blog. You can find the original version here.

Using the Ransack gem is a great way to add search functionality to your application without the need for additional libraries or dependencies.

One issue you may have is when sorting data by an attribute that is nested in a JSON column. If that attribute’s value is an empty string, it will be included in the sorted list (even when we’ve declared :nulls_last in our Ransack configuration).

In this post, I’ll be covering how to ensure that empty-string JSONB values are treated as null values and placed at the end of any sorted list when searching and sorting with Ransack.

Before we get started, here’s some sample data we’ll be using:

Note: for Member #3 and Member #4 the empty string for location.

Our goal here is to sort our Members table by location, and to ensure that any empty-string Location values are treated as null values in the sorted list.

More specifically, we’ll need the resulting SQL query generated by Ransack to look like this:

SELECT DISTINCT "members".*, NULLIF("members"."data" ->> 'location', ")
FROM "members"
ORDER BY NULLIF("members"."data" ->> 'location', '') ASC NULLS LAST

Sorting by JSONB nested attributes using Ransack

ransackers: special methods provided by Ransack for creating additional search functions via Arel

By taking advantage of ransackers, we can sort our table by the members’ Location JSONB attributes.

Let’s add the following to our Member model:

class Member < ApplicationRecord
    # ...

    ransacker :location do |parent|
          Arel::Nodes::InfixOperation.new(
             '->>', 
             parent.table[:data], 
             Arel::Nodes::Quoted.new(‘location’)
          )
        end

     # ...
end

The ransacker above ensures that a member’s location (a nested JSONB attribute) is available as a top-level attribute so that we can build a table that can be sorted by members’ locations.

Our Ransack result is defined as:

def search_result

     members = Member.arel_table
     data_column = members[:data]

     workspace
         .members
         .select(members[Arel.star], jsonb_attr(data_column, 'location'))
         .ransack(ransack_filter)
         .result(distinct: true)
 end

 def jsonb_attr(column, attr)
     Arel::Nodes::InfixOperation.new(
         '->>', 
         column, 
         Arel::Nodes::Quoted.new(attr.to_s)
 end

With the code above, we are making the Location JSONB attribute available in the SELECT statement of our SQL query:

SELECT DISTINCT "members".*, "members"."data" ->> 'location'
FROM "members"

When we sort our table by Location, it works. Kind of.

The issue is that the empty-string Location values have been placed at the beginning of the sorted list:

For one record, this may not be a big deal.

But consider dozens of records where the member’s Location attribute is an empty string. In that case, a user would need to sift through several blank Location values just to get to the beginning of the alphabetized list.

Setting NULLS LAST doesn’t account for empty-string values

According to the Ransack docs, we can use :nulls_first or :nulls_last to decide if we want null values to appear before or after non-null values when sorting.

We can also force nulls to always be first or last by using :nulls_always_first or :nulls_always_last.

While this is helpful, it doesn’t apply to the empty-string values that may be present in a JSONB column.

What to do? We need to set any empty-string values in the Location column as null values so that they’re sorted after the non-null values.

Setting Empty-String JSONB Values to null values
The method below will allow us to take any empty-string value and return it as NULL when Ransack builds our #search_results query:

def null_if(column, value)
    Arel::Nodes::NamedFunction.new "NULLIF", [column, value]
end

In our code, we can place this method below our jsonb_attr method:

def jsonb_attr(column, attr)
    Arel::Nodes::InfixOperation.new(
        '->>', 
        column, 
        Arel::Nodes::Quoted.new(attr.to_s)
     )
end

def null_if(column, value)
    Arel::Nodes::NamedFunction.new "NULLIF", [column, value]
end

Next, we need to update our jsonb_attr method by wrapping the method’s code in the null_if helper:

def jsonb_attr(column, attr)
    null_if(
            Arel::Nodes::InfixOperation.new('->>', column, Arel::Nodes::Quoted.new(attr.to_s)),
            Arel::Nodes::Quoted.new('')
        )
end

For the null_if arguments above, the column is the InfixOperation object, and the value is an empty string built by the Arel::Nodes::Quoted class.

Updating the Location ransacker to return a NULLIF ORDER BY clause

Now, if I try to sort by Location in the table, I get a Postgres error:

ActiveRecord::StatementInvalid (PG::InvalidColumnReference: ERROR:  
for SELECT DISTINCT, ORDER BY expressions must appear in select list)

We’re seeing this error because we are trying to ORDER BY the following:

ORDER BY "members"."data" ->> 'location'

When what is stated in the SELECT statement is the following:

SELECT DISTINCT … NULLIF("members"."data" ->> 'location', '')

Since ORDER BY expressions need to be the same expressions set in the SELECT list, we need to make sure that the NULLIF statement is present in the ORDER BY clause.

To do this, let’s update our Location ransacker on the Member model:

class Member < ApplicationRecord
    # ...
    ransacker :location do |parent|
            Arel::Nodes::NamedFunction.new 'NULLIF',
                                   [
                                     Arel::Nodes::InfixOperation.new(
                                       '->>',
                                       parent.table[:data],
                                       Arel::Nodes::Quoted.new('location')
                                     ),
                                     Arel::Nodes::Quoted.new('')
                                   ]
        end

    #...
end

Here, we are taking the code within our null_if method and using it explicitly in our ransacker in the Member model.

The null_if method takes two arguments: column (the InfixOperation object) and value (the Quoted object).

Adding the null_if wrapper to the Location ransacker allows us to ORDER BY that same NULLIF(...) argument that we’ve stated in our SELECT statement (via our Ransack query).

Here’s what the resulting query looks like:

SELECT DISTINCT "members".*, NULLIF("members"."data" ->> 'location', ")
FROM "members"
ORDER BY NULLIF("members"."data" ->> 'location', '') ASC NULLS LAST

And there you have it! With this, the resulting sorts by location place the empty string values at the end of list, no matter the sorting direction.

Sorting by Location - alphabetical

Sorting by Location - reverse-alphabetical

Conclusion

This post covered how to set empty-string values of a JSONB column as null values when using the Ransack gem to search and sort data.

I hope this helps in all of your table-sorting endeavors that involve Ransack, JSONB nested attributes, and null values!

Thanks to @hadees on GitHub for a useful Arel gist that provided the null_if method we used in this post.

‍

10 Things I've Learned After 3 Months as a Junior Software Engineer

Alex Morton — Mon, 19 Apr 2021 18:01:23 +0000

It's been about 3.5 months since I landed my first job as a software engineer with an awesome startup called Orbit and I've definitely learned a thing or two in this short time.

In fact, I started out wanting to jot down three simple things for this blog post, but as soon as I started, I just couldn't stop!

So, my friend, here are three (plus seven more) things I've learned after three months as a junior software engineer.

1. Developers are literally always learning.

That's the job. Learning and solving problems, every single day. No matter what level you're at, there's always going to be a new and more complex problem to solve.

I recently took on a task where I had to find a solution to something and I'd ask my teammates for help, almost expecting a "here's how you do it," step by step kinda thing, but it was so interesting to experience putting our heads together to both work to figure it out. It's all thinking and solving a problem. And repeat day after day!

2. Don't let your insecurities get the best of you.

I had a week or so recently when I was really anxious for some unknown reason. I could tell that I wasn't on the right path with my thinking, and I even had these irrational fears of being fired. Seriously, for no rational reason.

I was doing good work, learning actionable things, and completing my tasks - but for some reason, my brain was having this bizarre negative field day (or week).

Looking back, the only way out was getting ahold of myself and my thoughts. Anytime I'd start to feel myself spiral, I'd reframe my mind to something concrete like "I'm capable of focusing on one thing at a time to get my work done and do my best today."

Doing this often sets me on a good path and allows me to focus on one actionable thing at a time without going into this unpleasant and irrational work doom spiral.

3. Embrace the honeymoon period, but also embrace the normal day-to-day.

I think with any new job or opportunity, there's always the rose-colored period for the first three months where everything feels amazing and perfect and nothing can get you down.

I love my job, but now I have a more level-headed view of everything.

That's not to say you shouldn't be over-the-moon when you first start something! Embrace the honeymoon period but then also remember that it's okay to get out of the honeymoon and feel a little more settled and accepting of the good days that come with the "meh" days - as with absolutely anything in life!

4. Progress is progress - even when it doesn't feel like it.

As soon as we get more into the routine of a new job, we become less aware of just how much we're learning. To keep myself motivated and proud of myself for what I'm learning, I try to keep track of my learning by documenting new processes so that I can can refer back to them later or just feel proud when they start feeling more natural and second-nature to me.

5. "The only way out is through."

I saw this advice in a Twitter thread a couple months ago when I was having a hard time not understanding a difficult topic and getting down on myself about it.

Learning and growth are great (so great!) but actively going through those growing pains is uncomfortable as hell.

The only way to improve and get to the other side is to stay the course and trust the process.

In any given moment of learning or growth, it may feel like it'll always be this hard, but it's only a matter of time before you're through it and a better developer than before.

6. Every hard issue that takes you hours is just time invested to get you through it in a fraction of the time in the future.

(I'm looking at you, local environment troubles and convoluted errors yet unbeknownst to StackOverflow!)

7. Try not to ask the same question twice.

This goes back to documenting any process that feels confusing or difficult. Especially if a teammate helps you through something - take the time after the discussion to write it down and truly absorb and understand it.

I personally don't enjoy explaining something over and over again, so I try to never be the cause of a teammate feeling the need to do so for me.

8. Whenever you're learning a new thing - pay special attention.

I'm thinking specifically of recently learning about Rails decorators and services - subjects I had no clue about before (though I'd seen them around the codebase every now and then).

When I had a task where I had to use and code with them, it was the ideal moment to learn what their purposes were and how I could use them in the future.

Reading documentation, blog posts, and using other learning resources helps to get a broad overview of the big picture so that you're able to understand unfamiliar topics, little by little.

9. Always understand and consider suggestions from your teammates in code reviews.

Recently I'd worked for a long time on a certain issue and I wanted nothing more than to push it over the finish line.

One of my teammates had some suggestions on ways to refactor the code and I literally almost did a "thanks, but no thanks" and pretended to understand it when I didn't.

Thankfully, I gave myself an order to fully understand the suggestions before making my next move. To do this, I wrote in my notebook exactly what my teammate was suggesting (this helps me fully conceptualize something that's not yet clear to me).

Surprise, surprise -- it was really helpful advice for cleaner code and a more organized architectural solution.

10. Truly understand the scope of your problem before diving in to a solution or asking for help.

I've found that if I'm confused about how to frame a question I want to ask a teammate, chances are pretty good that I haven't done my true best to figure out the problem itself.

By making a serious effort to understand the question or problem you're trying to solve, I think it gives you such a good leg-up for ultimately finding the solution.

Plus! It's a great feeling when you eventually do ask a teammate for help as you discover that your instincts were actually pretty close to the answer you're given!

There you have 'em! Ten things I've learned after three months as a junior software engineer.

Thanks so much for reading! I wanna know what resonated most with you! Feel free to leave a comment below and let me know what you think!

P.S. I send weekly newsletters about the self-taught coding journey and inspiration for other early-career developers! Let's be friends! >>

Reuniting with an old friend over coding

Alex Morton — Wed, 14 Apr 2021 07:06:17 +0000

Recently, I caught up with one of my good friends from college whom I'd lost touch with over the years. I knew it would be just like picking up where we'd left off, over Zoom, and it definitely was.

The reason we'd actually gotten back in touch was coding of all things!

He's actually teaching himself to code at the moment and going through something of the same thing I did with making the whole career transition, step by step and improving his skills over time.

It's so funny to think about because we came from totally different academic backgrounds - I studied English Literature and he studied architecture.

I remember us during our first year of college, traipsing all the way to the other end of campus on Tuesday and Thursday evenings for our Existentialism lectures. (We still don't know why we ended up taking that course, and as mere freshmen! We seriously had no idea what was going on.)

But I remember us in that course together, sitting near the back of the rickety lecture hall in one of the old and charmingly haunting philosophy buildings and trying to understand what was going on all while rolling our eyes at another student who would constantly ask questions to find out more about what Heidegger meant by this or what Nietzsche meant by that. (Recall: we still had no idea what was going on.)

Throughout college, D and I remained close. We never took another class together again, but there was a feeling of deep friendship there.

After college, we lost touch. I think I reached out when I'd heard the news that our philosophy professor, a true giant in the field, had passed away after a long life and career.

Catching up with my friend, it was like picking right back up from where we'd left off but with pieces missing that we'd just have to fill in as we went. I didn't even know he'd gotten his masters in Architecture. And was now living in London, just mere hours from me on a plane.

Catching up, and being able to find that link of friendship again, over coding of all things. And what a reunion it was - seeing that spark that I felt when learning and still do even now (and I hope will always feel). Being able to share this passion when it feels difficult to share with others who aren't in the same sphere and don't necessarily know what we mean when we throw around terms and phrases like "React" or "static site generators" or "back-end engineering."

All the while, I kept thinking about how different our paths were - English lit and architecture, respectively - the steps of our walks to classes across the map of the sprawling UC Berkeley campus, and how we had no idea that they'd one day lead us to this career in coding and building and constant learning and discovery.

Yet again, we don't always know where things will lead us. But we'll always be glad for the way we got there.

I send weekly newsletters about the self-taught coding journey and my own coding adventures (and misadventures!) Sign up here! >>

Dreams about coding solutions?

Alex Morton — Mon, 12 Apr 2021 07:21:10 +0000

This post was originally published on April 12, 2021 on my blog.

Good Monday morning. I'm a little tired today. All of my dreams this weekend were about the current problem I'm trying to solve at work in terms of getting scope added to a certain integration.

I feel like even in my sleeping and restful moments where my brain should be recuperating, it's filled with trying to find a solution or at least new ways forward.

It's kind of miraculous. Because even while I was asleep, I was somewhat conscious of my brain branching out in all kinds of different directions.

Well, I'm bent on finding my solution today. This morning, even! I'm visualizing myself wrapping up this section of work and putting it out into the world (fingers crossed)!

I'm interested to see and curious about what today will bring. There are lots of possibilities and as long as I keep making my way forward, I'll come to the solution.

Pssst! I send weekly newsletters about the self-taught coding journey and my own coding adventures (and misadventures!) Sign up here! >>

The Only Way Out is Through!

Alex Morton — Mon, 29 Mar 2021 07:15:34 +0000

This post was originally published on March 29, 2021 on my blog.

Happy Monday! I'm looking forward to starting this week off on a fresh, clean slate.

I feel like last week I wasn't at my best, and it stemmed a bit from having trouble with my local development environment acting up and not working as well or as seamlessly as usual.

I made the mistake of getting down on myself about that and made it mean something negative about me and my skills as a developer. Thankfully, after talking to some of my teammates, I came to the realization that all developers of all levels face finicky problems with their environments at different points throughout their careers.

Just hearing that made me realize that it wasn't just me doing something wrong. So helpful and validating.

Another thing on my mind is that this journey is supposed to feel really hard and uncomfortable at times - especially in moments of true learning and growth. If you're not feeling at least a little uncomfortable (and let me tell ya, I'm feeling it!) then you're not giving yourself as much of an opportunity for growth.

So I'm reframing everything from this moment. The only way out is through, and I'm here for all of it.

Pssst! I send weekly newsletters about the self-taught coding journey and my own coding adventures (and misadventures!) Sign up here! >>

Always Chipping Away at Finding that Balance

Alex Morton — Mon, 22 Mar 2021 07:19:20 +0000

This post was originally published on March 22, 2021 on my blog.

Ah, this weekend was definitely one of those sloooow and relaxing weekends meant for total reenergization.

Over the past couple of weeks, I've been feeling like I've been pushing myself in all areas of my life without necessarily being on the lookout for working too much or spreading myself too thin.

Thankfully, I've been becoming increasingly aware of it and have been able to take some conscious steps back as a result, before I tread into more dangerous territory where burning out is the next logical outcome.

What this looks like is taking inventory of all of the things on my current plate, planning and managing around those, and (most importantly) not taking on any other tasks or responsibilities in the meantime - no matter how small.

I think my first reactions tend to be 'Oh, yeah I can do this' or 'I can definitely manage this,' but then I have to stop and remind myself that taking on any sort of extra responsibility means actual time taken out of my actual calendar.

In other words, if I continue saying yes to things, I continue to fill up space within a limited container (my calendar) until a certain point where there's just not enough time for balancing work with rest.

On my mind over the next week:

continuing to learn and doing my best at work
getting ready for a new developer cohort with the Collab Lab
a big project I've been working on (and will share soon!)
living slowly with my family in my non-work time

Pssst! I send weekly newsletters about the self-taught coding journey and my own coding adventures (and misadventures!) Sign up here! >>

Got Myself into a Pickle Last Week!

Alex Morton — Mon, 15 Mar 2021 07:20:08 +0000

This post was originally published on March 15, 2021 on my blog.

I got myself into a pickle last week at work!! It was one of those "you have to make the mistake to learn from it" kind of realizations, and it's because I'd bitten off much more than I could chew when it came to the number of PRs I had open at a given time.

The work I've been working on recently involves implementing a new design that was created for the emails the app sends to users on any given event (i.e. confirm account or forgot password, among other things) and I was working on about three different ones.

However, my mistake was starting new PRs when I still had another one that wasn't merged yet. Because the thing is, when you have multiple works in progress, you don't realize how much the production code is changing each day with new code being merged from other teammates.

So the moment you go to work on one project or PR, you realize that the code you started writing has maybe been completely changed and then you run into all sorts of merge conflicts.

Thankfully, it's gotten me better at not being as intimidated of conflicts (because let me tell ya - I was scared of those before!), and it's definitely become easier to navigate them on my own and actually now what I'm doing and what's going on.

With the help of a teammate last week, I was able to unravel myself from the fiasco I'd created (where I just didn't know where one file started and another one ended!) and by the sheer grace of God (and Git!), I was able to get my head above water again.

This week, I'll be focusing on only one thing at a time - especially since it's going to be a pretty eventful week.

Yay for making mistakes and learning from them and ultimately becoming better than we were yesterday!

Pssst! I send weekly newsletters about the self-taught coding journey and my own coding adventures (and misadventures!) Sign up here! >>

Two Months into Software Engineering!

Alex Morton — Thu, 11 Mar 2021 07:33:14 +0000

This post was originally published on March 11, 2021 on my blog.

It's been a little over two months since I've started my career as a software engineer, and I'm so unbelievably convinced that this was the ultimate move for me.

Yesterday, I was thrilled to wake up to a wonderful article that was written about my journey teaching myself how to code in 2020 and making that transition.

Here's a little excerpt:

'“I feel like I’m at the start of this amazing adventure. And there are so many different avenues to take or doors that can be opened,” Morton said. “I’m here. I’m doing the work every day. I’m in it. And the opportunities are endless — that’s how it feels."'

Feel free to give it a read here >>

At work, I'm working on coding up the new designs for the emails that are sent from our Rails application. I've been learning a ton about ActionMailer in Rails, MJML formatting for email code, and setting the email to send at the right time.

It's really exciting stuff for me! As always, I'm taking it step by step and even when I'm faced with a big mountain of things that I don't quite yet know how to do, I always fall back on the solution of breaking everything up into smaller steps and working my way down the list.

Soon enough, the bigger picture starts to make more sense and before I know it, I have a fully polished bit of code ready to be submitted and reviewed!

Pssst! I send weekly newsletters about the self-taught coding journey and my own coding adventures (and misadventures!) Sign up here! >>

Collab Lab: Cohort 19 Recap (Winter 2021)

Alex Morton — Sat, 06 Mar 2021 17:35:01 +0000

For the Winter 2021 Cohort of the Collab Lab, we were honored to be able to lead the charge for Cohort 19, a team of developers and mentors located in the EMEA regions.

Below, you'll find some insights from our mentors about the entire experience, an overview of the app our developers created, and the developers' contact information via LinkedIn should anyone wish to learn more about them (hint: they should!!)

The (Dream!) Team

Our team was made up of four developers (Chiamaka in Nigeria, Joseph in Uganda, Julia in Austria, and Rebecca in the UK) and four mentors (Luka in Georgia, Golfo in Greece, Muhammad who joined us for part of the cohort in Pakistan and the other part in Finland, and me in France).

On the part of the mentors, Luka had been the only one who'd had past experience with the Collab Lab (as a participant!), so he was instrumental in helping to manage our team of mentors and developers.

I think in general, those of us who were first-time mentors were a little bit nervous at first, but the entire team's dynamic worked so well that we soon became comfortable with each other and fell into a very productive rhythm.

Over the course of the past eight weeks, we've had weekly syncs on Sunday evenings where we'd watch the developers' demos of the past week's work and issues, lead learning modules on various topics, have retros to discuss what was working or could be improved on, and discuss the next week's issues.

I have to say - it's been absolutely amazing to see how well everyone collaborated with each other, worked as such a cohesive team, and just overall had an awesome time.

Our team's brilliant developers were extremely dedicated to their project, tasks, and responsibilities each week, and they created some truly professional-level work. Seriously, such a wonderful joy to witness and be a part of.

The Project

The team was responsible for assembling a Smart Shopping List concept created by the Collab Lab from various issues in a GitHub repository.

Each week over the course of the 8 weeks, our team of four developers paired up in teams of two and tackled issues one by one down the list.

The Finished Product

You can tour the finished application right here >>

Hire these amazing developers!!!

Debugging: What's the Simplest Explanation?

Alex Morton — Fri, 26 Feb 2021 07:48:45 +0000

This post was originally published on February 26, 2021 on my blog.

Friday already, this week really flew by, yada yada yada (the usual post intro words to get the writing flowing...)

It's Friday and we're here, doin' it live. I've been working all week on solving a bug, and I finally found a solution for it yesterday only to realize that the fix warranted a mere 10 characters or so to the changed file.

Yet again, I need to keep this idea in mind that the likely solution to any problem or bug is most likely the simplest solution you have on hand.

And yet, we don't think about that right when we go into investigation mode on a bug, do we? I think, for me, I gear myself up to do a deep-dive and learn everything I can about why something is happening to be able to really scope it way down and isolate the issue.

But once I do that, I think I need to ask myself, 'Okay, what is the simplest explanation and most straightforward approach to fixing this?'

Maybe it's not investigating how a certain instance variable is carried throughout the entire application's architecture and creating new functions to manipulate different variables.

Maybe it's just making sure to parse a variable to an integer and move on with your day.

Pssst! I send weekly newsletters about the self-taught coding journey and my own coding adventures (and misadventures!) Sign up here! >>

5 Tips for Getting Through a Tough Coding Issue

Alex Morton — Mon, 22 Feb 2021 11:31:22 +0000

Happy Monday! Last week at work was excellent - I really feel like I was fully able to give myself the time and space to explore, investigate, and solve a few tough-for-me code issues, and that was a great feeling!

Something I was super conscious of during my time figuring things out was how supremely unpleasant it can be to feel like you're right on the cusp of figuring something out only to try a different solution and not have it work out.

From there, it's easy to spiral down into frustration and driving yourself insane by trying different iterations of the same ultimate solution over and over and over again with the same result.

So, during that time of resisting the spiral and opting instead for pushing forward, I also took a few notes that could help other developers on whatever problem is currently stumping them.

1. Get back to the basics of your problem.

I think when we're working through a tough issue, it can be easy to Tarzan-swing from post to post on StackOverflow with the hope of finding the perfect solution. While doing this can definitely help from time to time, and we might in fact find the perfect solution - I'm finding that this actually takes me further and further away from the most efficient way to find the solution.

Getting back to the basics of your problem means making sure you're understanding every single word of the story in the Trello card that was assigned to you or every single word of the GitHub issue or every single word of the helpful hint your teammate or manager gave you on your pull request.

More often than not, the right direction can be found right from those words, so get back to the basics and circle yourself around those hints before going on a StackOverflow scavenger hunt in the hopes that something (anything!) will miraculously pop out at you.

2. Read the docs.

If you're using another bit of software or an open-source tool within the code you're currently investigating, read through the documentation for a helpful hint around what your solution could be.

I don't think I'm the only developer guilty of just skimming a few parts of any documentation before throwing my hands up in despair and whining about there not being an appropriate explanation.

Really read the docs of any tools involved in what you're working on. Chances are - there'll be some helpful hints there to add to your investigative journey. Set yourself a 15-minute timer if you have to just to focus on truly reading through the documentation. I promise - it helps.

3. Ask questions.

As junior developers, I think it can be easy to get stuck in this weird limbo of not wanting to ask questions, and then thinking we should ask questions but then feeling a strange anxiety that you'll be criticized for waiting too long to ask said questions, and then it's just this cycle that has gotten out of control and no one's the wiser.

If you're really stuck, and you're driving yourself crazy in the meantime, ask for a hint. Your teammates will be happy to give their input. And you'll be a bit less frazzled.

4. Take breaks.

One of my favorite lines from Mad Men (and believe me, there are so many to choose from) is when Don tells Peggy "Just think about it deeply and forget it. An idea will jump out at you."

Sometimes too much focus can be, well, too much. Try working on something else or stepping away from the code for a bit. Don't worry - your brain will still be churning away in the background, but you'll be able to calm down a bit more and then come back feeling refreshed and wondering why there's an idea jumping around in front of you.

5. Celebrate your success!

Once you find your solution - and you will - celebrate your hard work!

That sheer rush of dopamine is what everyone's talking about when they say that coding is the best thing in the whole world. It's that crushing frustration paired with the soaring euphoria of solving your problem.

Before moving on to your next thing, stop and celebrate and feel proud of yourself. You did it and you overcame those obstacles.

Plus, it's important to cherish that rush of happiness before starting all over again and going through the same hurdles as before.

Hope this helps! I think it's good for juniors, but I suspect it could also work for developers at any level since there are always challenges to solve and overcome, no matter what.

Cheers!

P.S. I send weekly newsletters via email about the self-taught coding journey and my own coding adventures (and misadventures!) Sign up here if you want in on that! >>