DEV Community: KCoder

The biggest enemies of a developer - Part 1

KCoder — Tue, 30 May 2023 16:49:07 +0000

Dealing with frustration and overwhelmness as a Dev

As a developer, there will be a lot of things trying to make your life harder. Whether its your boss or a stupid bug. Its important to cope with all this and not get overwhelmed by it.

I noticed that I wasn't really good at coping with these things. I felt frustrated and overwhelmed a lot. It affected not just my work but also my personal life.

So I researched a little and summarized a couple of points that might help you out.

How to cope with frustration

Coding is frustrating, ok?
I don't care what anybody says it is not easy to code.

At first, your code runs fine, then you accidentally remove a semicolon and your whole house catches on fire.

But jokes aside. Here is what I found helpful over the years:

Take a break

I found that 99% of the time when you feel frustrated about programming the best thing you can do is hit the shutdown button and take a break(please don't be like me and save your files first...).

Close your laptop and go for a walk. Play with your kids. Read or do something that would make you forget about that bug you are currently stuck on.

Then when you feel ready get back to it, and you will feel way better.
This lets your mind take a break. This way it can process all that information you dumped there unconsciously.

Fun fact: Our unconscious is way more powerful than our conscious.

Accept it

Remind yourself that frustration is normal.

You are doing hard things that not everybody would be capable to do so it's understandable if you feel frustrated.

Try to view it as a sign that you are getting out of your comfort zone and making progress.
Essentially that's what is it all about - constantly learning new things.

Remember that you are not alone

Come on now, there are a lot of developers out there just like you who got stuck on the same problem. No reason for you to feel frustrated.

Try Googleing the problem.
Somebody probably already encountered it and uploaded the solution for it. If not ask for help on forums such as Stack Overflow(and hope not to get downvoted to depression).

If you don't find a solution online but still manage to solve the problem try to be your own savior and upload it somewhere.
This way the next person won't have to go through what you went through.

Thanks for reading this article. Part 2 is coming soon.

Iterating over emojis with for/of?

KCoder — Wed, 24 May 2023 17:14:18 +0000

This will be a short one

In ES6 strings are by default iterable with a for/of loop character-by-character. When iterating over strings, they are iterated by the Unicode codepoint, not by UTF-16 characters.

This can leave room for unexpected behavior. Let's look at this string for example: "I🧡😀".

let str = "I🧡😀";

console.log(str.length); // => 5

for (let char of str) {
    console.log(char); // => "I", "🧡", "😀"
}

This string has a .length of 5 because the two emojis require each two UTF-16 characters to represent. But when you iterate over them with a for/of loop, the loop body will run three times, once for each codepoint "I", "🧡", "😀".

How to learn way more from coding than ever before

KCoder — Thu, 18 May 2023 09:09:39 +0000

Want to become a superhero programmer?

As a developer, learning is your superpower. It is especially important now that frameworks and new tech emerges every 2 days. The faster you can learn something, the more valuable you will be. So let's look at a couple of tricks I use to help me learn new stuff and not forget what I already learned.

Make sure that you understand the concepts
Apply what you learned(Practice)
Take notes
Debug
Find a community

1. Make sure that you understand the concepts

When learning to code you can't memorize code, I know because I did it for a long time. But memorizing code won't get you far. If you actually want to learn something, make sure you understand the working of it. But not just what it does but why it does it too.
For example: Take an "if...else" statement or a logical operator like "&&". Besides understanding what it does when you use it in your code, you should look a little deeper and understand why it does that thing.

2.Apply what you learned(Practice)

We can all agree, that learning without actually applying the concepts you learned, is just wasting your time. I mean, why did you even learn it if you are not going to apply it in real life? It doesn't make sense.
You need to apply things to avoid eventually forgetting them. When you apply them in practice your brain builds connections. This way you will actually remember those concepts you applied.

3. Take notes

I do this when taking courses, or just generally learning new concepts that I didn't know about before. And let me tell you that taking notes, is just as important as watching a course. Because when you take a course writing down a couple of concepts throughout it, after finishing, you will have a summary of it on paper, that you can come back to any time.
This method also helps you to better understand concepts because it forces you to write down concepts in your own words.

4. Debug

The majority of programmers HATE debugging(not that I love it). It is a tedious process and sometimes the problem is just a missing semicolon.
But what I noticed is that when I actually find the bugs in my code and solve them. I remember those problems and the solutions to them way better in the future. This is because I already encountered them before.

5. Find a community

Finding and joining a good community can be a little tricky, but it's definitely worth it. In a community, you can share your code and finished projects, and the community would give feedback on it. You also would be able to provide feedback on other people's code.
Be open to feedback, whether it's good or bad because it's all an opportunity to learn something new.

Thanks for reading!

The Struggles of Becoming a Self Thaught Developer

KCoder — Fri, 05 May 2023 19:46:22 +0000

Want to become a web developer?

Cool, you don't need a degree for that.

You don't even need to go through a boot camp or pay for an expensive course.

You can learn web development by yourself. This is known as a self-taught developer. While it can be a rewarding experience, it also comes with its own set of challenges. But if this doesn't scare you off. Let's see a couple of the problems self-taught developers face.

1. Learning resources

When it comes to learning how to code, the first step is to decide which method of learning is best for you. With so many resources available, such as courses, YouTube tutorials, and so on, this can be a daunting task.

Afterall, the decision is yours to make, as you know yourself best. But, I can offer one piece of advice: no matter which route you choose, stick with it. Don't jump from one course to the next halfway through. I know from experience that this is not a productive approach. Instead, commit to the path you have chosen and stick with it through to the end.

2. Burnout

Burnout can appear at different times and levels for each individual. It might happen to you too at some point in your career, no matter how motivated you are. Self-taught web developers are particularly vulnerable to burnout. Thankfully there are a few ways to combat it.

Having a purpose/vision

Having a clear purpose or vision in front of you will help you to avoid burnout and push through harder times.

Taking a break

Taking a break when you start to feel burnt out is also beneficial. It allows you to take a step back and look at the situation from a new perspective.

Loving what you do

If you love to do something, or if you are interested in that thing, it will be way easier to avoid burnout.

3. Loneliness

Loneliness is one of the biggest demons of a self-taught developer. Having friends is great. But if you can't share your journey with someone, it can be difficult to stay motivated and inspired.

Of course, it is possible to be a lonely web developer. But it is much more enjoyable and rewarding when you have someone to share it with.

If you don't have someone in your life who does the same thing you do, don't worry - you are not alone. There are thousands of lonely developers out there. My advice would be to join a community, whether it's online or in person. Doing so can be a great experience and can open up a wealth of knowledge and support.

4. Study methods

When it comes to learning something on your own, the key is to create a plan and then turn it into a habit. This way, it will become almost automatic and you won't have to think about it - you'll just do it.

If you're learning to code, you're likely juggling other responsibilities too. So how do you find the time to code every day? If you're having trouble finding time, it's likely because you're not dedicated enough. But let's say you can make the time - the next question is how much time should you dedicate to coding daily? The answer to this depends on you and your goals, but dedicating 1-2 hours a day is more than enough.

Remember, it's not about who does the most work in a day, it's about who is the most consistent.

5. Tutorial hell

You've likely heard of the term "tutorial hell" before. It's one of the biggest mistakes you can make when learning to code.

Tutorial hell looks something like this: You start out learning from a course. You watch the course and copy the code, feeling amazing that you've learned something new. But when you try to recall it the next day, you realize you've forgotten it and have to start from the beginning again. When you're stuck in this never-ending cycle, you might feel like you're learning to code. But that is an illusion. When you want to build something without a tutorial, you get stuck.

My suggestion to you is to take notes. That's right - take a course and take notes. When you finish a lesson, review the lesson notes and I guarantee you'll remember way more than before.

Thanks for reading!

Mutable Object References

KCoder — Mon, 01 May 2023 11:00:00 +0000

Mutable values are values that can be changed without an entirely new value. In JavaScript objects and arrays are mutable by default.
As already said in a previous post about Immutable Primitive Values, there is a fundamental difference in JavaScript between primitive values (undefined, null, booleans, numbers, and strings) and objects (including arrays and functions).

First, objects are mutable:

let obj = { x: 1 }
o.x = 2              // obj = { x: 2 }
o.y = 3              // obj = { x: 2, y: 3 }

Second, objects are not compared by value, two objects are not equal even if they have the exact same values, this is true for arrays too:

let o = { x: 1 }, p = { x: 1 }
o === p                         // false
let a = [], b = []
a === b                         // false

JavaScript objects and arrays are compared by reference, two objects values are the same if and only if they refer to the same underlying object:

let a = []
let b = a     // b refers to a
b[0] = 1
a[0]          // 1 - changes are also visible in the array a
a === b       // true

Thanks for Reading!

Immutable Primitive Values

KCoder — Thu, 27 Apr 2023 11:00:00 +0000

In JavaScript, a primitive is data that is not an object, and has no methods or props, such as:

null
undefined
number
string
bigint
boolean

There is a fundamental difference between primitive values and objects. Well first primitives are immutable: there is no way to change a primitive value. This is obvious for numbers and booleans. It is not so obvious for strings, however.
Since strings are like arrays of characters, you might expect to be able to alter the character at any specified index. In fact, JavaScript does not allow this, and all string methods that appear to return a modified string are, in fact, returning a new string value. For example:

let str = "hello world"
str.toUpperCase()  // "HELLO WORLD"
str                // "hello world" - the official is not modified

Primitives are also compared by value: two values are the same only if they have the same value.
Again this sounds fair for numbers, booleans, null and undefined because there is no other way to compare them. But again this is not so obvious for strings. If you compare two string values, JavaScript treats them as equal if, and only of, they have the same length and if the char at each index is the same.

Rounding errors in JavaScript

KCoder — Fri, 21 Apr 2023 09:16:00 +0000

JavaScript uses the IEEE-754 floating-point representation, which is a binary representation, that is capable of exactly representing fractions like 1/2 and 1/8. This is great and all, but the fractions we most commonly use are decimal ones, such as: 1/10 and 1/100.

Numbers in JavaScript have a lot of precision but the problem is that floating point representations cannot exactly represent numbers like 0.1 or 0.01. They can very closely approximate decimal numbers, but the fact that numbers like these can't be exactly represented can lead to problems.

Example:

let x = .3 - .2;
let y = .2 - .1;
x === y              // => false: They are not the same
x === .1             // => false: .3 - .2 !== .1
y === .1             // => true: .2 - .1 === .1

Because of rounding errors the approximations of x is not exactly the same as the approximations of y . They are very very close to each other, but not the same!
Also it's important to note that this problem is not specific to JavaScript, it affects all of the languages that use binary floating-point numbers.

Mindset of a web developer

KCoder — Sat, 15 Apr 2023 05:43:20 +0000

There is one thing that all good programmers have in common and that is that they have a good mindset. They built their mindset throughout trials and tribulations that they went through while they learned to code and even after that. Of course not all developers or programmers have the same mindset, but there are some basic elements of these mindset that all developers have, or should have.

So what are these basic mindset shifts or perceptions that every developer should master?

Well, here they are:

Remember your goal
Put your ego to the side
Look at your code from a different angle
Learn when you need to take a break

1. Remember your goal

This is especially important when you get stuck with one of your projects or just simply go through a hard time developing something.
In these times it is really important to remember why you are doing what you are doing, and what are your goals because that's the only way you can push through these hard times.

But please be aware that simply keeping your goals in mind won't make you succeed in life. To succeed you need to be consistent on your journey. If you are interested on this topic, I highly recommend you checking out a book named Atomic Habits.

2. Put your ego to the side

Putting your ego to the side is especially important when you have to ask someone for advice or when you have to google something because you forgot it, and these times your ego can be a barrier telling you that you don't need help, because you know the answer to that problem, but in reality we all know that that is not true all the time. There are times when you simply need to ask someone, or you need to google something, and for that you need to let go of your ego.

3. Looking at your code from a different angle

When you are seemingly unable to solve a problem in your code with a specific approach, maybe what you should try is take a step back and look at the problem again and try to solve it from a different angle or with a different approach.

4. Learn when you need to take a break

You need to learn when to take a break. Why? Because when you are stuck on a problem you can get overwhelmed or frustrated, and when you are frustrated it's going to be very hard to solve that problem, because you won't be able to think with pure logic.

It is very important to learn to take breaks, so you can calm your mind, regroup your thoughts and solve that problem.