Forem: Nicky Hajal

What to Do When Things Aren't Working

Nicky Hajal — Thu, 04 Oct 2018 22:29:44 +0000

You know what I love about programming? There are a lot of problems to solve.

Every step of the way, you're taking something that doesn't do what you want it to do and finding a way to make it work.

As I got better this I thought, "Cool, I'm getting to be a better programmer."

Lately, I've been realizing that the fundamental skills of coding reach far outside the digital world. In fact, programming has made me a better person, largely because it's taught me what to do when things aren't working.

The following applies to programming but I hope you'll see that you can use it just as much in your day to day life.

Sometimes while developing software you come across a bug that you just can't seem to figure out. You swear it must be a problem with the operating system or programming language and have to remind yourself that this is almost never the case - it's your problem to fix.

For a programmer, these really tough issues are, as Seth Godin puts it, the Dip.

There are no clear, sensible paths to go down next. You want to give up because things just aren't working... but if you don't, success is just over the hill.

What I've learned is that in situations like this, the only important thing is to create motion by any means necessary. In other words, changing absolutely anything even remotely connected to what you're working on.

Delete pieces here and see what happens there, add lines of code even to check parts you assume are working fine.

Make changes that you know won't solve the problem because they still may lead you to the solution.

The only objective is to shake things up and unearth new pathways to explore.

When something isn't working, put the priority on trying new things quickly instead of finding a direct route to the solution.

I know this sounds crazy, but making unintuitive, "let's see what else breaks when I do this"-style changes is almost always what leads me to the hardest to find answers.

Best of all, this seems to be a universal tactic; it's improved every facet of my life I've had the insight to apply it to.

With the Wind or Against the Wind? Either is fine.

I'm no sailor but I know that when you're on the open seas and using the wind as your driving force, the problem isn't going into a headwind - even energy going opposite to your desired trajectory can be channeled in a useful way.

The problem is when there is no wind, no motion.

Next time you're completely stuck imagine a sailboat lost at sea, water stretched to the horizon in all directions, with no wind.

Except in this scenario, you're not the sailboat, you're the wind!

Start blowing any direction and let the boat harness that energy into moving the right direction.

When You're Stuck, Make Changes

We treat change as if it's something rare, precious and important to get right.

We believe that there's such a thing as 'good' change that works in our favor and 'bad' change that doesn't.

But, it's only when you make fewer changes that it becomes more critical for each of them to have positive effects.

When you, instead, start treating change as an ordinary reflex to doubt and stuckness, it has a new purpose. It becomes less about being right directly and more about exploring the unknown and discovering solutions to problems along the way.

All changes become good because all of them provide answers settling your doubts one way or another so that we can move forward.

Next time you're frustrated because you can't seem to figure out why your app is crashing or your server isn't responding...

Or why you can't wake up on time, or can't quite capture a character in a novel you're writing... or feel uninspired by your latest design or are just unsatisfied with some aspect of your life...

Start experimenting with changes.

Consider that it may be better to consciously make a few mistakes than to be stuck where you are.

You can't leverage stagnation but a gust in any direction can help you discover what you need to finally get things working.

Mark as read and/or private labels?

Nicky Hajal — Fri, 21 Sep 2018 21:04:04 +0000

Just a thought that my Reading list is growing, even though I'm reading things. Of course I could unmark them so they're off my reading list entirely... but it's also nice to have a log of the things I added there.

So, maybe another option is being able to mark a post as read and the ability to toggle Read posts on and off in the reading list.

Or maybe there's a better solution!

Re-use personal modules via NPM/Yarn?

Nicky Hajal — Fri, 21 Sep 2018 18:07:23 +0000

Hey all!

Just curious if anyone has a work flow for streamlining internal code-reuse between projects via npm/yarn?

For example, most of my projects use sequelize and have models like User, CredentialChange, Transaction, etc. that I'd love to reuse internally.

Is there a best practice for using NPM to pull in that code (ideally still in a form that I can extend).

Why Your Best Work is Hardest to Finish

Nicky Hajal — Thu, 20 Sep 2018 18:48:14 +0000

"The professional does not over-identify with his art, but simply shows up every day to put his time in, to do the work."

Steven Pressfield, the War of Art

When I was 21, I dropped out of college to pursue the life I’d been imagining for years. The life where I could focus on meaningful projects that I enjoyed working on. The life where I could choose how to invest my time instead of being subjected to how others thought I should spend it.

I knew I had to put in the effort and time if I wanted to succeed - and I was doing exactly that. But despite my efforts, I struggled finishing many of the projects I cared about most.

Then I found The War of Art by Stephen Pressfield. It’s a book that had a profound impact on my work and the work of many others...

But there was one sentence that I just hated.

"The professional does not over-identify with his art, but simply shows up every day to put his time in, to do the work."

My mind totally rejected this concept. I just dropped out of college to pursue what I loved, how could I not identify with it?

Luckily, I continued to deliberate over that quote for some time - months, maybe years - until it finally sunk in.

We Don’t Finish When Too Much is On the Line

Often when we start feeling that a particular piece of work has special, unique value we begin to identify with it.

“All that practicing is really paying off!”
“I can’t wait to see what Jessica thinks of this!”
“This is going to be my legacy."

As you continue to blur the lines between your identity and your project, the stakes begin to rise. If your project fails, it becomes less something you can brush off.

It's starts to feel like not just the failure of the project but a failure of you. What people say about your project turns into something they’re saying about you.

Maybe you show it to a friend and interpret some feedback as an attack—or maybe you just start imagining that feedback. But the more over-identified you become, the more determined you are make your work even better before getting your work out to a larger audience so that you don’t have to take any more ego-beatings.

Unfortunately, that doesn't get you any closer to actually sharing your work with the people who would benefit from it.

When We Over-Identify with Our Work, Finishing is Incredibly Hard

The root of the problem is simply that there’s not a separation of your personal value as a human from the value of your project.

It’s very unlikely that your project needs more tinkering. What it needs to some exposure. Get your work out to 10 people. Accept their criticism with gratitude and realize deeply that they are sharing their experience with your work, not their opinion about you.

There's no need to defend your work from their feedback whether you agree or not. Just accept it, say thanks and work it into the next iteration if you think it's worth a shot.

Love Your Craft, Not Your Projects

The reason that it was so hard for me to accept Pressfield’s ideas about over-identifying with my work is because I loved the products I was developing (and still do). I wanted to identify with it, I wanted it to be a deeply rooted part of my life.

What I came to realize over-time is that I was channeling that love towards the wrong thing: a single project. That makes you want to protect the project at all costs, which translates to shielding it from the world.

If you shift that love for your work to love for your craft the exact opposite happens. You realize that you improve so much faster when you get your work out into the world. You start sharing work as fast as you can to whoever it may help.

Commit to your craft, don’t over-identify with your projects and let your best work see the light of day.

Demystifying Array.reduce(): How to understand it and when to use it in your code

Nicky Hajal — Wed, 19 Sep 2018 01:31:07 +0000

ES5 and later versions of JavaScript brought several new methods for handling arrays. Many of them have become the best practice for common tasks with arrays and JavaScript is much better off with them.

Array.map() and Array.filter() are two examples of daily-driver ES5 additions that are staples for most JS developers.

An equally useful but often less understood tool in the kit is Array.reduce(). Lately, I've been using reduce more often, but it took a while for it to feel natural and I often see other developers struggling with it... or just not using it at all.

Reduce is often taught wrong and therefore misunderstood

In my opinion, a large reason for the confusion is that reduce is just taught wrong. In fact, it even feels named wrong to me (even though, of course, the concept and name of a reducer come from well before it was added to JavaScript).

The most common example when teaching reducers is something like this:

const array = [1, 2, 3, 4];
const sum = array.reduce((accumulator, currentItem) => {
    return accumulator + currentItem;
}, 0);

// sum = 10

This fairly cleanly shows how reducers function. You call reduce() on an array and pass it an initial value as well as a function that runs for each item of that array.

To the passed function, reduce sends:

1) The current item and
2) The value returned by the previous callback (or the initial state, when called for the first time)

The final value of reduce is ultimately whatever the inner reducer function returns when called the last time.

As a result, in this case, the reducer is summing the values of the array and returning the total value.

So... adding arrays of numbers, is that all `Reduce` does?

I saw that example so many times, but rarely saw explanations that went much further.

"Hm, interesting.", I'd think, as I went on with my day.

So, what's the real deal with reducers? What are they actually good for?

Here's the real power:

Reducers are useful when you want to process an array but output something that isn't an array

That's really what it boils down to, and that is useful very often.

After all, isn't that what we're doing in the example above? We're taking in an array and returning an integer. In that context, it makes some sense that we're "reducing" the array, but we don't always have to output something as simple as an integer.

Take this example:

const trips = [{type: 'car', dist: 42}, {type: 'foot', dist: 3}, {type:'flight', dist: 212}, {type: 'car', dist: 90}, {type: 'foot', dist: 7}] 

const distanceByType = trip.reduce((out, curr) => {
    const { type, dist } = curr;
    if (out[type]) {
        out[type] += dist;
    } else {
        out[type] = dist;
    }
    return out;
}, {});

// distanceByType = {car: 132, foot: 10, flight: 212};

So here, we're taking in an array, but returning an object of sums, instead of just a single one.

Here we're beginning to see the essence of what a reducer really is:

A reducer is a transformer

It takes in an array and transforms it into something else.

Thinking of it in this way not only helps me understand what reduce does but also helps me realize when I should be using it.

Have an array of users but want to output a string like, Mike, Becka and 3 others will be attending? A reducer is great for that!
Have an array of articles and want an object with them keyed by category? A reducer is great for that!

The use cases go on and on.

Go forth and `Array.reduce()`!

I really hope that helps and would love to clarify things further in the comments if I can.

Got a use case for reduce that you love? Comment below and I'll add it to the article 🚀