DEV Community: Carlos Fuentes

Being an Impostor

Carlos Fuentes — Tue, 03 Mar 2020 22:13:10 +0000

Everybody at some point in time we heard about the Impostor Syndrome and how hard if to deal with it.

Stress, anxiety, and depression are the most common symptoms when we talk about feeling like an impostor. Like many people, I suffered and I'll suffer in the future, in this article I want to share with you a couple of my experiences dealing with this hard stage in my career as a Software Engineer.

Me as an Impostor

First of all:

Impostor syndrome (also known as impostor phenomenon, impostorism, fraud syndrome or the impostor experience) is a psychological pattern in which one doubts one's accomplishments and has a persistent internalized fear of being exposed as a "fraud". - Wikipedia

For me, 2019 was a complete adventure. I didn't only start working for an amazing startup like Taxfix, 2019 marked a point of change in my life; I achieve my dreamed job and move from my home country (I'm from Mexico) to an amazing place like Germany, all of that with only 23 years (I'm a child, I know 😅).

In the beginning, everything was like a dream, everything was amazing and I was so excited to achieve one of my life goals. But after I while, I started to feel like I didn't deserve any of these things.

You may wonder, why? Was because, seeing around and looking at a group of amazing people from so many different countries, with different experiences and a lot of knowledge became to be really stressful for me.

With thoughts like you're just a lucky guy or you're not soo smart like anybody else here started rounding my mind. Just ask a couple of questions like where is X service or what are flow to deploy something? make me feel like the most naive person in the world.

It was a hard time for me, but worth it.

Is not easy, but give it a try

What did I do? Just learn the following...

Learn to rest
Your health is more important than anything else in this world. In my forced way of trying to be better and not understanding my limits, I spend too much time reading articles and contributing that most of the time sleep really bad (or I didn't sleep at all).
Take rests, do exercise, eat healthily (junk food is valid but not all the time 😅). Once you understand that more healthy you're, more productive and in better shape, you will be.

Lose the fear to ask
If you don't know something or your stuck, ask. We're lucky that most of the people who code are really friendly and happy to help you. From junior to senior, everybody asks questions.
If you are in an environment where if you ask, somebody complains or just doesn't help, is better if you leave ASAP. Believe me, you will thank me for it.

We don't know everything
We're incapable of know everything, we're just humans and we have more in our mind that only machine code, design patterns or data structures. It is completely fair. Where you're right now, a Senior dev was, and if you understand this point and agree with yourself that you're in a constant learning path, you will be where the Senior dev is right now.

and...

The most important thing about all of this

Don't compare yourself with anybody

It is not fair for you, it is not fair for all your sacrifices, all your time invested learning by yourself or going to the University. Nobody knows all the things you did to be where you are right now. Only you understand better than anybody what are you capable of and how important you're. Be proud of what you achieve and be happy with the path you're walking of, only you know where you're and where you want to be.

Even with that, be careful

Impostor Syndrome could appear at any time, at any level, at any seniority. It is something that most of the time we don't expect, but we should be aware and capable of understanding why this happens and make a small stop in our lives to re-negotiate with ourselves and make a deal to keep moving improving ourselves.

Feel free to share your thoughts and experience dealing with Impostor Syndrome, will be nice to read you! 😄

Big-O Notation: Beginners Guide

Carlos Fuentes — Mon, 12 Nov 2018 06:26:48 +0000

In the world of programming write code as today is your last day on earth is not the main thing in the art of programming. Beyond understand what's the problem that our code will solve, we have other variables that we need to take care when we are writing code. For example:

Complexity
Maintainability
Design Patterns
Algorithms
and beyond...

One of the most important things and the main topic of this article is the performance of our application when we are implementing an algorithm.

The performance of our algorithm helps us to make more user-friendly our application, letting the user invest only the necessary time to do the tasks and focus on other things before the go bored and close the window (browser or anything else). No matter how fast and proficient was the device from where the user is using our app. In today's world, the time is the most precious thing that we have.

Are many variables to take care when we talk about performance like the use of memory, disk space, execution time and another long beyond.
One of the most important tools to determinate the performance of our algorithm is the Big-O Notation.

Big O Notation

The Big-O Notation is a tool that let us determinate the complexity of an algorithm, letting us take a measure of the performance of a specific algorithm. This tool measures the worst case scenario where the algorithm goes to the highest point of demand.

The main Big-O terms are these:

O(1) -> Constant
O(n) -> Linear
O(log n) -> Logarithmic
O(n ^ 2) -> Quadratic
O(2 ^ n) -> Exponential

O(1): Constant Complexity

The constant complexity is the easier, all the algorithms who, no matter the size of the input or output, the execution time and the resources used will be always the same, have this complexity. No matter how many times or where the algorithm is executed, this one will have exactly the same behavior all the time. For example:

As we see, no matter how big is the size of the array given as an argument, the behavior will always be the same. The only thing that might change will be the output, this because the array might not have the same data stored all the time.

O(n): Linear Complexity

We say that an algorithm has linear complexity when his execution time and/or resources used are directly proportional (grows up in a linear way) to the input size. For example:

To get an easier way to understand this complexity, we can compare this to an activity that we do every day (or mostly), for example, read a book or watch a movie. The time that we spend reading a book or watching a movie, depends on the number of pages of a book and the duration of the movie. For example, if a movie has a duration of two hours, you'll spend two hours watching a movie. If the book has one hundred pages and you read fifty pages in one hour, you'll spend two hours to read all the book.

O(log n): Logarithmic Complexity

This complexity is present where the impact of an algorithm is directly proportional to the logarithmic result of the input size. In other words, when we have an input size of 10 and we need 1 second to accomplish the task with our algorithm, we need to do exactly the same task with an input size of 100 in 2 seconds, with an input size of 1000 in 3 seconds and so on.

One interesting example is the binary search. In this algorithm, we divide the array (previously ordered) into two parts. We take the middle index as a reference to get the value at the middle of the array. If the number in that spot is equal to the number we are looking for, we return the middle index adding up the prefix that we use to find the spot where the number we are looking for is stored. Thanks to that, if the number is bigger than the number stored at the middle of the array, we look for the number in the right side of the array, instead, if is lower, we look in the left side of the array. After that, we use the prefix to use as the new prefix in the next iteration as a recursive way. We repeat this loop until get the given number.

O( n^2 ): Quadratic Complexity

The quadratic complexity is present when the impact of the algorithm is directly proportional to the square of the input size. This means, if we have an array as input with a length of 4 spots and we want to compare to look if the array has repeated items, we need to do 16 comparations to accomplish our task. This complexity is common in sorting algorithms like bubble sort, insertion sort, and the selection sort.

In this function, the complexity can grow up if we add more for loops. This could make us go to an O(n * n) complexity.

O( 2^n ): Exponential Complexity

When an algorithm has exponential complexity, this means that the complexity will double with each additional item in the input. If 10 items take 100 seconds, 11 would take 200 seconds, 13 would take 400 seconds and so on.

This doesn't mean that only exists O( 2^n ), this is just for explanation purpose. Can grow to O( 3^n ), O( 4^n ) and so on.

Wrapping Up

I hope this helps you to understand more the Big-O Notation, it's a great help to measure the complexity of an algorithm, exists many more tools to do this but this is one of the more common.

If you have questions or want to correct some mistakes, feel free to leave your comment below. I'm leaving below a little list of resources about Big-O Notation.

More resources

Let's talk about Hard Binding in JavaScript

Carlos Fuentes — Mon, 06 Nov 2017 06:09:01 +0000

After a busy week, I'm here and I want to talk with you (the reader) some confusing (at less for me) and interesting concept in JavaScript.
Currently, I'm involved in different groups on facebook where we have as a principal topic talk about programming. Advice, trending, news and much more about that; obviously, all in Spanish (I'm from Mexico if you don't know).

One of these groups is exclusively about Node.js and JavaScript (if you're Spanish-speaking, I invite you to join. Here's the link). After reading posts for a while, I found this code:

function foo() {
console.log(this.bar);
}
var obj = { bar: "bar" };
var obj2 = { bar: "bar2" };
var orig = foo;
foo = function(){ orig.call(obj); };
foo();
foo.call(obj2);

Take your time to think about what this piece of code is going to print and then continue with the article. I wait for you, do not worry.

Whether you get it or not, this code snippet prints bar twice in a row.

Here the link to see it and yeah, is his code.

Well, we get this result because of one thing: Hard Binding

And what is Hard Binding?

To have a good understanding of Hard Binding is important to reach some confusing things before getting a hard binding. One of these is this.

This

Is a mechanism that is most commonly used in the OOP programming paradigm. In that cases, we talk about the context of the object what are creating. For example, the uses of his functions and global variables. In JS, the history is some confusing but nothing of the other world.

In JS, this is a contextually based mechanism which, in turn, is based on the function invocation and not in the where the function was declared. When a function is invoked a call-stack is created and with this call-stack, a kind of record too. In this record is saved the information of the function with data of how and where has invoked, what parameters are passed and more. With all of that information, this comes as one of those properties. At the end, the record is alive as the duration of the function execution.

Binding

In JS, the context in where we invoke a function has a lot of importance.

Think about this function:

function something(){
  var a = 2;
  console.log(this.a);
}

var a = 5;

something();

What is going to print?

I let you try that code and explain what exactly happens.

When we call this, we are invoking the context of the global object. In other words, we are taking properties (in this case, the variable a) declared as global outside of the function. Doesn't matter if I create a variable called as the same of the outside variable, I taking properties from the global object, not from the function context.

Implicit Binding

Now, what about this code. What is going to print?

function something(){
  console.log(this.a);
}

var a = 5;

var obj = {
  a: 10,
  something: something
}

obj.something()

When we have this, we are applying something called Implicit Binding . . . and with what I can eat that?

Well, as you see in this case, we are assigning the context as an object to the function. In a more simple way, we are creating the context of the function as an object. So, instead of taking the global context, take the context of the object we made.

With this comes a problem, what if we do this?

function something(){
  console.log(this.a);
}

var obj = {
  a: 10,
  something: something
}

var cake = obj.something

var a = 5;

cake();

Well, we lost the object context and we had the global context again, but why?
Remember when I told you that the invocation matters? Well, this is the reason why.

We lost the context of the object because we assign the function to a variable, obtaining a reference to that function, changing the context. When we do that, a implicit lost occurs and we obtain the global context (for this case).

The same happens if we do this:

function something(){
  console.log(this.a);
}

function anotherFunction(fn){
  fn();
}

var obj = {
  a: 10,
  something: something
}

var a = 'Five';

anotherFunction(obj.something);

Remember, invocation matters

Explicit Binding

As everything, every problem has a solution (or we can make one, but in this case has one as default).

If we want to force a function to get a particular context of an object without an implicit reference, we can use functions like call(...) (more info) or apply(...) (more info).

Calling call() and passing the object that you want to apply as an argument, forces the function to use the context of the object. For example, like this:

function something(){
  console.log(this.a);
}

var obj = {
  a: 10,
}

var a = 'Five';

something.call(obj);

As above, we can use apply(this, []) instead. Passing an object and an array as arguments.

Hard Binding

At this point, I hope everything is fine. You understood everything I wrote, I suppose. Now with this, maybe you want to know: and a hard binding, what about that?

Well, let me tell you something. With this solution we do not solve all the binding problems, you know?

We back to the first code that I found:

function foo() {
console.log(this.bar);
}
var obj = { 
  bar: "bar" 
}
var obj2 = { 
  bar: "bar2" 
}
var orig = foo;
foo = function(){ 
  orig.call(obj);
}
foo();
foo.call(obj2);

Why do that?

Put attention just in this line: foo = function() { orig.call(obj) }
Ok, you see it? That's is hard binding.

That function makes that foo always do the same action every time that is called, no matter what is the invocation context. Make a function that calls internally and manually an explicit binding and force to do the same instruction no matter where and how you invoke that function

As we talk above, Every problem has a solution (or we can make one):

function foo(something) {
  console.log(this.bar + something);
  return this.bar + something
}

var obj = { 
  bar: 2
}

var obj2 = {
  bar: 4
}

function bind(fn, obj){
  return function(){
    return fn.apply(obj, arguments)
  }
}

var result = bind(foo, obj);

var result_2 = bind(foo, obj2);

result(2);

result_2(2);

Or, we can use the one that ES5 gives us

function foo(something) {
  console.log(this.bar + something);
  return this.bar + something
}

var obj = { 
  bar: 2
}

var result = foo.bind(obj);

result(2);

This utility was introduced by ES5 in Function.prototype.bind (more info), it gave us the hard binding in an easier way.

One more thing

Feel free to make comments and corrections to this article. I do this article just for explain and understand more clearly how Binding works and what is Hard Binding. If you want to know more about Binding or JavaScript in general, you can read You-Dont-Know-JS and understand more clearly this and more things about JS.

See ya.

Is the use of scaffolding a good idea for a junior dev?

Carlos Fuentes — Mon, 23 Oct 2017 03:52:58 +0000

The last week, after I finished my first article (here is a link to go) I started a simple project just for implement some stuff that I read and learned in some articles here and in the wide world of the internet. Once I took in mind what stuff I will implement in the project, I searched in google (just for curious) for generators to start the project (like express-generator for Expressjs).

I found a great one called rest using yeoman. Once I installed and ran the generator, I took a look at the folder structure and the files, looking how it works all the stuff. When I finished understanding how it works, I took the time to think and make me one question: It's a good idea for a Junior Dev the use scaffolding?

To answer that question I decided to write this article, so I want to explain my point of view about scaffolding.

First, What is a Scaffolding (Generator)?

If we take a look how Yeoman describes itself, we can have an idea: "Is basically a plugin that can run a command to scaffold complete projects or useful parts".

In other words, it's a helpful command to create an entire project or partial project to get started.

Like yeoman, we can find other scaffolding tools to create skeletons for applications for various frameworks. We can find it in form of Ruby gems for Ruby on Rails, a NPM Package for Nodejs and much more.

Beyond good and evil

What is the good if I use it?

The use scaffolding it's a good way to start a project. The creators of this tools research in books, internet, and other ways; giving to you the best of design patterns and best practices that they can find. They took his time to give you an approach of how you should structure your code and files to get a good and readable project.

This tools are made or should be made, with a module architecture. Giving to you the skeleton of an app that can grow in an intelligent and a readable way. This means that you have a support to build and grow your actual product.

Scaffolding is a very useful time-saver, giving to you a quick code that it works. This is an opportunity for saving time starting a project from scratch and giving to you the way to implement the things that you need with less stress. More of the generators implements tools that can take you a long time to implement by yourself, more if you don't have experience with that. It's a good way to know how the tools work and with an extra by the way, getting implemented in our project.

So, what is wrong if I use it?

Well, if you are new in development or a Junior Dev like me, a lot I guess.

Most of the scaffolding that we can find outputs of some generic code. Some of them maintain that generic code up to date, others are up to date if you live in 2014. We can get the same if we talk about some packages or tools that have preinstalled or implemented.

With that generic code comes the customitation. Some of the generators are prepared just for bootstrapped quickly and have a hard way to modify to your needs. Obviously, depends on the level of the scaffolding. Some come with a scaffolding only in the structure of your code and files, and use of some tools, another come even with a pre-migrated ORM's, etcetera. Just making more unflexible for the developers to customize by what they need.

Conclusion

The scaffolding and the use of generators is a good way to begin and understand design patterns and best practices, only if we are careful in how we use and what we use. The way to get the best experience with the use of scaffolding is always getting to understand how it works, not only what command make it run. Going deeper in how it works, how each file communicates with each other, how the tools are working and how are configurated it's the best practice to get experience and prevent get problems with the use of generators.

The point is to always be curious. With the curiosity comes the experience and the knowledge.

Introduction: Hi! My name is Charlie & this is where I started

Carlos Fuentes — Wed, 18 Oct 2017 00:03:10 +0000

Hi! My name is like I said in the title and I'm from Tecate, Mexico. At the time I do this post, I'm recently graduated from my Bachelor Degree in Computer Science in UABC (University Autonomous of Baja California) in Tijuana, Mexico. So, like you imagine, I'm a noob developer trying so hard to be into the magnificent world of Web & Mobile Development.

Like most of the recently graduated, I have zero professional experience & so much energy to do a lot of stuff, almost everything that my mind can imagine I try to put into code and . . . well, maybe you know the rest.

What I do?

At the moment that I writing this, I'm a Web Developer with some knowledge of Mobile Development (in Android using Java, sadly I don't have a Macbook for iOS and I prefer native before hybrid).

My favorite programming languages are Javascript & Python (I put in this order because it's the way in that I prefer it). Maybe you imagine what is the most thing that I use and (if you got it) yeah, it's Nodejs. That incredible run-time environment for Javascript on the server. And yeah, if you have experience working with Nodejs for the web development, maybe you know what I use. . . *drums* Hapijs! (Obviously Expressjs too).

With this in mind, most of the frameworks that I use are for back-end development. Using MongoDB for my NoSQL database and MySQL, PostgreSQL for a relational database. If you wanting to know if I use an in-memory database, yeah, I used Redis before (only for sessions data, but it's something).

I need to say, I'm not so good in front-end terms but I worked before with Angular2 (when it recently release and had a lot of work only to know how made routes because. . . it's Angular). I know something about HTML5 & CSS3, enough to build a web page from scratch, about manipulating the DOM with Javascript it's something that I need to improve, but don't worry I can promise you I'm working hard to solve it *wink wink*.

Why I'm doing this?

Like I said in the begin of the article: I'm a Junior Developer, who are looking how I can get some presence, some experience and improve my knowledge, I'm a huge noob at this point. So, after reading some articles like this and others, that I lost the links, I decided to follow his advice and begin writing some experiences, troubles, new stuff that I learn and something more in my road to being a FullStack Developer.

And, as an extra point, get improve my English. So important at this days.

This is where my road begins

From this point, I will try to write articles every week as possible I can. Wait for my next article next week. I really don't know what I could be, but I can promise I would be a great stuff (I guess).

I invite you to begin this road with me. If you want to come, follow me and we can talk about programming and more.

Thanks! and see you next week.