Top 5 DEV Comments from the Past Week

I built mine using React and hosted on Github pages.

Link: sureshmurali.github.io

As I've matured as a developer, and having fit a few of these stereotypes myself, I've realized that the real 10x developers aren't the ones described there. It's possible that, yes, that caricature or a developer may produce more output than the rest of the team, but, at best, they generally have a slight impact on the team and, more often, I've seen them drag the team down. By cutting themselves off from the rest of the team, they negatively impact the team dynamic and often produce code that is not maintainable by anyone but themselves - but they don't want to maintain it, because that's not as fun as "real coding."

As I said, I've been that developer. Luckily, I grew out of it. I've realized that the only true 10x developer is the one who makes the whole team 10x more productive - mentoring others, sharing good ideas, accepting feedback, cleaning up code as they maintain it, writing good documentation, and making the organization the kind of social environment where people want to work. Most of the time, software development is not a single-player game, it's a team sport.

(Edit - Posted on accident before I finished typing - that's what I get for typing one-handed on my phone. The extra bit starts here.)

There's a military term that I find applies to these kinds of developers - Force Multiplier. Simply put, a force multiplier is some factor that makes a force more effective than it would be otherwise - for example, having access to satellite navigation can make a small force as effective as, say, a force 5x larger that doesn't have it.

A great developer is one who acts as a force multiplier for the team. They don't increase productivity by doing more themselves, they help everyone else be more productive.

I really don't care for this perspective. In my mind, there is a negative connotation with blue collar work amongst the "white-collars".

Coming from a lifetime of blue collar work, railroading, manufacturing, construction, I have had the fortune to live both lives. I will tell you, no, coding is not blue collar work. However, coding is brutally exhausting in a different way.

Just because the world of code is open to the "common person" does not mean it is blue collar. I am not working my ass off in a physical manner. I get the great pay, and the benefits of working in an office. I solve complex problems and build amazing systems for very large corporations. And guess what, I did not go to college for it. However, I am working my ass off in a mental way.

With my past experience, I will say that I have met some of the most brilliant people in my blue collar work. Some that would put our 10x engineers to shame if they ever met. Note of heavy sarcasm here please amongst the term 10x engineers.

I think we, as white collar workers need to realize we would not be where we are with out our blue collar brothers and sisters and vice versa. Yes, we may have different working conditions, but I will say that my life as a blue collar was much, much harder than that as a white collar. And no, coding is not or never will be considered blue collar work just because it is open to the "common man or woman". As far as I am concerned.

JavaScript does operations from right to left.

In some cases it does, but not in this case. The reason you see behaviour that may appear to be right-to-left evaluation is because of operator precedence, where the unary ! has a higher precedence than the binary +.

+ actually evaluates from left to right, so more verbosely parenthesized, it looks like this:

(((!(+[])) + []) + (![])).length

Evaluating this parenthesized form step-by-step, we get this:

/*  1. */ (((!(+[])) + []) + (![])).length  // parethesized form.
/*  2. */ (((!0) + []) + (![])).length      // `+[]` is evaluated to `0`.
/*  3. */ (((!false) + []) + (![])).length  // `0` is coerced to the boolean `false`.
/*  4. */ ((true + []) + (![])).length      // `!false` is evaluated to `true`.
/*  5. */ (("true" + "") + (![])).length    // `[]` is coerced as a primitive to the string `""`, which means `true` is also coerced to a string.
/*  6. */ ("true" + (![])).length           // `"true" + ""` is string concatenation, which evaluates to `"true"`.
/*  7. */ ("true" + (!true)).length         // `[]` is coerced to the boolean `true`.
/*  8. */ ("true" + false).length           // `!true` evaluates to `false`.
/*  9. */ ("true" + "false").length         // `false` is coerced to a string because `"true"` is a string.
/* 10. */ "truefalse".length                // `"true" + "false"` is evaluated as string concatenation to `"truefalse".
/* 11. */ 9                                 // the length of `"truefalse"` is `9`.

I am glad to have my peak time today. I started back in 81 as a kid, made it to the 90ies as a hobbyist, had a little pause till the early 2000 and came right back professionally to the birth of the modern web. The browser has become the gateway to the world. And with the rise of the browser as the relevant platform operating systems became less of a thing. I have a Mac in the living room. My workplace is linux powered. I have a Windows machine (somewhere at least). As long as it has a browser, I can watch videos, listen to music, surfing the web. Chitchatting etc.

I am able to sit at my laptop listen to music, switch to my phone listening in my WLAN. When leaving the house my mobile switches to LTE and I am able to listen without big interruptions on my bike on my way to work. We have intelligent IDEs, great tooling, nice languages.

The web is a great learning ressource. And last but not least, we have dev.to:]

What greater time could there be?