DEV Community: Adrian Perea

Better Python String Formatting Using f-strings

Adrian Perea — Sun, 13 Dec 2020 03:24:54 +0000

As an avid Python user, I've always been jealous of how JavaScript users can seamlessly put together strings and expressions using template literals:

>>> const a = 5;
>>> const b = 10;
>>> console.log(`Fifteen is ${a + b}.`
Fifteen is 15.

That is an extremely elegant solution, as opposed to the de facto standard of using Python string formatting:

>>> a = 5
>>> b = 10
>>> print('Fifteen is {}.'.format(a + b);
Fifteen is 15.

You might say, "But, Adrian! The Python version doesn't seem so bad." And you're correct... when we're talking about using single expressions. But what if we're using more than one?

Skim through the following code examples in both JavaScript and Python to see how quickly things can get tricky.

Here's the JavaScript version:

>>> const name = 'Adrian';
>>> const age = 25;
>>> const major = 'Computer Engineering';
>>> const occupation = 'Software Engineer';
>> console.log(`Hello! My name is ${name}. 
                I am ${age} years old.
                I studied ${major} in college,
                and I am currently working as a ${occupation}.`);
Hello! My name is Adrian.
I am 25 years old.
I studied Computer Engineering in college,
and I am currently working as a Software Engineer.

And the Python version:

>>> name = 'Adrian'
>>> age = 25
>>> major = 'Computer Engineer'
>>> occupation = 'Software Engineer'
>>> print('''Hello! My name is {}.
             I am {} years old.
             I studied {} in college,
             and I am currently working as a {}.
          '''.format(name, age, major, occupation)
Hello! My name is Adrian.
I am 25 years old.
I studied Computer Engineering in college,
and I am currently working as a Software Engineer.

The problem with the Python version is that it requires you to have a mental mapping between the expressions you need to include in the string and the supplying the expressions at the end of the string. It's easy to mess up the arrangement, especially when you're working on more complex code.

Compare this with the JavaScript version that has the expressions in-line. There's less room for errors.

Python has a solution for this, and it's naming the string formatting braces. This allows you to supply the expressions in the format method as keyword arguments, depending on where on the string you want it to go:

>>> print('''Hello! My name is {name}.
         I am {age} years old.
         I studied {major} in college,
         and I am currently working as a {occupation}.
      '''.format(name=name, age=age, major=major, occupation=occupation)
Hello! My name is Adrian.
I am 25 years old.
I studied Computer Engineering in college,
and I am currently working as a Software Engineer.

While this solves the problem of mental mapping, it can get quite verbose. It's not exactly the best solution.

So what are our options? Fortunately, the smart people at Python have introduced f-strings

What the f-strings

F-strings are nominally called Formatted String Literals. They're usually called f-strings since you construct them by adding an f before a string, like so:

>>> f'I am a formatted string!'
I am a formatted string!

So what can we do with f-strings? Actually, its usage is very similar to the string formatting in JavaScript examples we saw above. Let's see the first example rewritten using f-strings:

>>> a = 10
>>> b = 5
>>> print(f'Fifteen is {a + b}.')
Fifteen is 15.

Nice! That already looks so much cleaner. Now let's rewrite the second example:

>>> name = 'Adrian'
>>> age = 25
>>> major = 'Computer Engineer'
>>> occupation = 'Software Engineer'
>>> print(f'''Hello! My name is {name}.
             I am {age} years old.
             I studied {major} in college,
             and I am currently working as a {occupation}.
          '''
Hello! My name is Adrian.
I am 25 years old.
I studied Computer Engineering in college,
and I am currently working as a Software Engineer.

As you can see, using f-strings allow us to string together literals and expressions seamlessly, just like in JavaScript! But since I am a hardcore fan of Python, I want to show you additional things you can do with f-strings that you can't do with JavaScript string formatting:

Rounding Off Digits

>>> import math
>>> print(f'The value of pi is {math.pi}')
The value of pi is 3.141592653589793
>>> print(f'The value of pi is approximately {math.pi:.3f}')
The value of pi is approximately 3.142

Aligning Items

This ensures that name is at least 10 characters wide, and quantity is 4 characters wide.

>>> shopping_list = {'Bananas': 2, 'Apples': 4, 'Grapes': 6}
>>> for name, quantity in shopping_list.items():
...     print(f'{name:10} : {quantity:4}')
...
Bananas   :    2  
Apples    :    4  
Grapes    :    6

String formatting is not fun

I think many of us can agree that string formatting is not fun, so we may as well use methods that make it easier not only to us, but also the readers of our code. Using Python f-strings allows us to write cleaner, more concise, intuitive, and especially, more readable code by seamlessly embedding expressions within string literals.

The examples I showed above are only the tip of the iceberg. You can find out more examples and inspiration for string formatting through the following:

The official documentation on f-strings
The format specification mini-language to learn more about how to modify expressions within the strings

How to Iterate Through Multiple Python Lists at Once

Adrian Perea — Mon, 23 Nov 2020 01:18:36 +0000

The Python zip built-in function makes it easy to iterate through multiple iterables all at once. It aggregates elements from each iterable to create an iterator of tuples. The i-th tuple contains the i-th element of each of the constituent iterables. For example:

>>> x = [1, 2, 3]
>>> y = ['a', 'b', 'c']
>>> zipped = zip(x, y)
>>> for x, y in zipped:
...    print(x, y)
...
1 a
2 b 
3 c

Getting the zipped elements as a list

The zip function returns a -- wait for it -- zip object. You can confirm this by printing the zipped variable out in the console. You should see something like this:

>>> zipped = zip(x, y)
<zip object at ox7f45ddba2c08>

To convert it into a list you can manipulate, you use the very aptly named list function like so:

>>> list(zipped)
[(1, 'a'), (2, 'b'), (3, 'c')]

Unzipping a zip object

If for any reason you need to reverse a zip operation, you can do so with the zip function, in conjunction with the destructuring operator (*) to return the original itertables as tuples:

>>> x = [1, 2, 3]
>>> y = ['a', 'b', 'c']
>>> x2, y2 = zip(*zip(x, y))
>>> x == list(x2) and y == list(y2)
True

Zipping unequal list lengths

Zipping unequal list lengths causes the elements of the longer lists to be dropped:

>>> x = [1, 2, 3]
>>> y = ['a', 'b', 'c', 'd']
>>> list(zip(x, y))
[(1, 'a'), (2, 'b'), (3, 'c')]

Fortunately, we can use the itertools.zip_longest function to solve this. zip_longest takes iterables as paramaters like zip, but with an additional fillvalue parameter which substitutes for missing values. It defaults to None. Here's how you use it:

>>> from itertools import zip_longest
>>> x = [1, 2, 3]
>>> y = ['a', 'b', 'c', 'd']
>>> list(zip_longest(x, y))
[(1, 'a'), (2, 'b'), (3, 'c'), (None, 'd')

And with a fillvalue:

>>> list(zip_longest(x, y, fillvalue=-1))
[(1, 'a'), (2, 'b'), (3, 'c'), (-1, 'd')]

As you can see, with Python, it's very simple to iterate over multiple lists at once.

Better Python for Loops Using enumerate

Adrian Perea — Thu, 19 Nov 2020 01:52:10 +0000

It's a common use case to iterate over a list together with its index. Traditionally, this has been done by using a for loop, utilizing range and len to create a list of indices. The items of the list then are accessed using [] notation, like so:

shopping_cart = ['apple', 'cereal', 'banana', 'cola']

for i in range(len(shopping_cart)):
    print(f'{i}: {shopping_cart[i]}')

# 0 apple
# 1 cereal
# 2 banana
# 3 cola

But this solution is very imperative, reminiscent of older programming languages. We have a better, more pythonic solution.

Using the enumerate keyword, we can get an iterator that already gives both the item and index of the list. Using this, we can simplify the above code as follows:

shopping_cart = ['apple', 'cereal', 'banana', 'cola']

for i, item in enumerate(shopping_cart):
    print(f'{i}: {item}')

# 0 apple
# 1 cereal
# 2 banana
# 3 cola

I personally think that this solution is cleaner, more elegant, and simpler to write.

Hey! My name is Adrian. I'm a software engineer who likes to write. If you liked this, why not follow me on Twitter?

Learn Docker by Dockerizing a Flask Application

Adrian Perea — Fri, 23 Oct 2020 01:16:34 +0000

The value proposition of Docker Containers is that they allow you to create applications that run practically everywhere. While this makes it sound like it's a nightmare to create, it's actually pretty simple!

In order to demonstrate this, we'll attempt to dockerize (the act of transforming a standalone application to a container-compatible one) a simple Flask application. By the end of this article, you'll be up and running with Docker containers!

All the files can be found in this repo.

Let's first create a folder for our project:

$ mkdir docker-flask-demo && cd docker-flask-demo

Then, let's create our simple Flask application and name it app.py:

# docker-flask-demo/app.py
from flask import Flask
app = Flask(__name__)


@app.route('/')
def hello_world():
    return 'Hello world, from your container!'


if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0')

You might be thinking that we need to install Flask at this point. But instead of installing Flask (and any other dependencies) in our own local system, we'll instruct Docker to install these dependencies inside the container. By doing this, our containers can run independently in any environment. Neat, right?

One thing that we have to do is to tell our container what dependencies are needed. Since we're using Python, what we need is a requirements.txt file.

Let's create this file and tell our container that we need the Flask module:

# docker-flask-demo/requirements.txt

flask

The last thing that we need is a Dockerfile. The Dockerfile is responsible for specifying our Docker Image, which we'll then use as a blueprint for our containers. Think of it as a container prototype.

Create the Dockerfile (no extensions) in the project folder and write the following:

FROM ubuntu:18.04

RUN apt-get update -y && \
    apt-get install -y python-pip python-dev

COPY . /app

WORKDIR /app

RUN pip install -r requirements.txt

ENTRYPOINT [ "python" ]

CMD [ "app.py" ]

Let's look at the different parts of this file one by one:

FROM: Specifies the base image to be used for all the commands. This allows us to reuse existing Docker images and add our own rules. In this case, we're using with a clean Ubuntu image.
RUN: Allows us to run shell commands. We're using this to update our system and install system dependencies.
COPY: Copies files from our local system to the container file system. Here we're copying our local requirements.txt to the container's /app/ folder.
WORKDIR: Changes the current working directory in the container. All the subsequent commands after this command will be ran in this directory. Here we're moving to the /app/ folder.
We then use RUN to install our application requirements using pip.
ENTRYPOINT: Determines the executable that will be invoked when we run our container.
CMD: Specifies default arguments to our executable. This means that by default our container will run our flask application.

Let's now build this image! Run the following command:

$ docker build -t docker-flask-demo:latest .

This command tells docker to fetch the Dockerfile present in the current directory (hence the . at the end). Docker then uses this file to create an image and names it docker-flask-demo with the tag latest.

We won't delve much into tags for now, but think of them as ways to specify the version of your image. In this case, we're saying that this build is the latest verion of our image.

After the command runs, we can see that our image is now installed using the following command:

$ sudo docker image ls

This would give a result similar to the following:

REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
docker-flask-demo   latest              676bb635f471        18 seconds ago      446MB

We can finally use this image to create our own containers! A simple way to do this is through the following command:

$ docker run -d -p 5000:5000 docker-flask-demo

After running this command, our container should be up and running our application! Go open your browser and go to localhost:5000. You should see the following page:

The docker run command that we just ran creates and runs a container based on the docker-flask-demo image we created. The -d option allows us to run the container in the background, and the -p command maps the port 5000 of our local system with the port 5000 of the container. We add this command because by default, the ports of the container are not accessible by our local system.

We can see all our running containers by issuing the following command:

$ docker ps

Which should give the following output:

CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS                    NAMES
d95eb8940835        docker-flask-demo   "python app.py"     4 minutes ago       Up 4 minutes        0.0.0.0:5000->5000/tcp   keen_jackson

And finally, we can stop our container (and consequently, our application) by issuing the following command together with the CONTAINER ID of our container:

$ docker stop d95eb8940835

And there you have it! We successfully dockerized our Flask application and made it run in a container. We installed all the dependencies inside the container, so we can be sure that this application will run in any environment.

Reinvent the Wheel, then Display It Like a Trophy

Adrian Perea — Thu, 16 Jul 2020 08:55:37 +0000

People talk about "reinventing the wheel" as if it's some sort of curse. It's true: in this day and age, tons of libraries are already available for your picking. These libraries have a lot of people working on it, so you can be assured that all the bases have already been covered (as much as possible).

Why recreate something that's already been created? And more: why recreate something that has a very likely to be a worse version of what's already there?

If we were talking about utility, then the recreation has no point. But from the point of view of the craftsman, it means the world.

Caring for our Craft

Engineering has always been associated with logic. We work daily with equations, syntax, optimizations, and all of those nuts and bolts to make sure that our products are working as smoothly and as fast as they can. We decide -- through logic -- everything: from architecture all the way to the last semicolon.

But at the end of the day, it's our innovation, creativity, and ingenuity that drives all of these decisions. We won't have a project without an idea.

The paradoxical truth is that engineering is art more often than it is engineering.

And for any craft that works with art, care is a must.

A baker has to hand-pick ingredients, knead the dough properly, measure accurately, and understand the nuance of every decision in order to create the perfect batch of bread. Truly, bread created this way will be said to have been made with care.

On the other hand, if the baker uses stale ingredients, kneads the dough hastily, measure inaccurately, and just perform random decisions (possibly due to inexperience), the result would be stale and lifeless bread.

Only by creating, making mistakes, destroying, and once again recreating, will a baker be able to create bread with heart. That is, bread that's been cared for.

Reinvent the Wheel

Just like the baker in our story, us engineers would get by just fine by using bottled up solutions without truly understanding the nuances behind them. Our customers would most likely be none the wiser.

No. Reinventing the wheel is not for them.

Reinventing the wheel is for us. It's for the author of the code. It's for the readers of the code. It's for other engineers who want to master the craft, and learn how to be master craftsmen in the field.

Reinventing the wheel allows us to learn from what other engineers have experienced, and then make their experiences our own. It allows us to understand every decision, why a function was broken down, and why a variable was named as it was.

Reinventing the wheel is the most efficient way for engineers to assimilate knowledge from those who've already walked our paths.

We do this not for any clout, or to please anyone else. We do this for the love of the craft.

So reinvent the wheel, and display it as a trophy. Be proud of the art you've created.

A Gentle Introduction to Genetic Algorithms

Adrian Perea — Mon, 13 Jul 2020 15:06:57 +0000

The genetic algorithm is a search heuristic inspired by Darwin's theory of evolution. This algorithm borrows the following concepts from natural selection:

Each individual (solution) has an associated fitness score
Individuals with high fitness scores are selected for reproduction
Chosen individuals reproduce to create offspring with the characteristics of both parents
Some offspring would have random mutations applied to them

The idea is that if the parents have high fitness, the offspring would have high fitness as well.

This entire process of selection, reproduction (more commonly known as crossover), and mutation will repeat many times. At the end, only the fittest individuals will remain. These fittest individuals represent the solutions to our problem.

Only the fittest will survive - Charles Darwin

Before diving deeper, let's first understand what genetic algorithms are trying to solve.

The Infinite Monkey Theorem

The infinite monkey theorem pictures a monkey hitting keys at random on a typewriter.

It suggests that if the monkey hits on the keyboard for an infinite amount of time, it will be able to type any given text. Yes, even the works of William Shakespeare.

Although, the probability of doing so is extremely low.

Let's see an example.

Imagine that the monkey has a primitive keyboard with only 27 characters. These are the small letters a to z and the space character.

The monkey's task is to write the phrase: if music be the food of love play on.

How likely will the monkey write this phrase?

To write "i": 1/27

To write "if": 1/27 * 1/27

To write the entire phrase (36 characters, including spaces): (1/27)^36

In other words, the probability of the monkey typing this phrase in random is:

1 in 3,381,391,910,000,000,000,000,000,000,000,000,000,000,000,000,000,000.

And even if the monkey were able to write one million phrases per second, to be able to write this phrase randomly at least once, it would take this much time:

5,142,335,400,000,000,000,000,000,000,000,000,000,000,000,000 years

(As a comparison, the universe is only 13,800,000,000 years old)

Nobody has this kind of time. So, how can we improve this?

The Power of Genetic Algorithms

The answer is through genetic algorithms. Genetic algorithms arrive at a solution magnitudes faster than brute force search. To do so, it uses the following two ideas:

Some solutions are better (or more fit) than others
We combine fit solutions with each other to get a high chance of getting fitter solutions

We'll discuss these two ideas more shortly, but for now, keep them in mind. Genetic algorithms make use of these ideas in 6 different steps:

Let's discuss them one by one.

Initial Population

Genetic algorithms begin by defining a set of individuals called a population. Each of these individuals is a potential solution to the problem you want to solve.

Each individual is defined by a set of parameters called genes. These genes are joined together to define an individual's chromosome. It's the individuals' chromosomes that define our solution.

But what should these parameters be?

It depends on the problem, but generally, the set of genes comes from a pre-defined alphabet. Usually, this alphabet is the binary alphabet: each gene can have a value of 1 or 0 (chosen at random).

In our case, we want each of our individual (solution) to be a guess of the phrase: if music be the food of love play on. To create solutions for this, we need a much more sophisticated alphabet than 1s and 0s.

What we can do is define our alphabet to be 27 characters: small letters a to z and the spacebar. Each individual defines itself by a string of small letter characters (and the spacebar).

For example, if we were trying to solve for the word apple, our solutions would look like the following:

These are all randomized strings that are 5 characters long. As you can see, the solutions can range from being completely off the mark to being close to the target. There’s even a possibility to get the solution on the first try!

What we want to do is to tell our algorithm that we should choose more solutions that are closer to our target. By eliminating bad solutions and choosing the ones that are closer to our target, we can converge to the right solution faster.

But how can we tell how good (fit) each solution is? That’s what the fitness function is for.

Fitness Function

The fitness function determines how "fit" or how good a solution an individual is. The fitness function assigns a fitness score to an individual based on its genes.

Individuals with a higher score are more likely to be chosen at random for the next generation of individuals. By selecting individuals close to our solution, we can ignore all the other solutions that are off the mark.

You can define the fitness function any and which way that you want. That's what makes it powerful. It can be flexible enough to accommodate any problem.

In our case, we can define it as "the number of matching characters in our individual and the target phrase." So for example, if we were trying to guess the phrase apple, these individuals will be scored as follows:

Since the second and third solutions are closer to our target, we want to prioritize those two over the first solution.

Selection

The selection phase lets us select the fittest individuals and allow them to pass their genes to the next generation. The individuals chosen in this phase are called the parents.

There are many ways to select the parents. One of the most common ways is called Roulette Wheel Selection or Fitness Proportionate Selection. As the name suggests, the probability of choosing an individual is proportionate to its fitness score.

Crossover

Crossover is the workhorse of genetic algorithms. It allows the parents (chosen from the selection phase) to exchange their genes.

The idea is that if we exchange the genes of two fit solutions, we'll arrive at a solution that's fitter.

Like selection, there are many different ways we can perform crossover. The simplest is Single Point Crossover. For each pair of parents we chose during selection, we create new individuals (offspring) by:

Choosing a random crossover point from the genes
Selecting genes from the first parent until we reach the crossover point
Selecting genes from the second parent until the end of the string

These offspring are then added to the new population.

Mutation

When we create our initial population, we also define the genes that are present in the population. During crossover, these genes are exchanged amongst each individual to arrive at our solution.

But what if we never get genes that are required for the solution? Going back to the apple example, what if our individuals, never randomly generate the letter a? Crossover only exchanges existing genes. Even if we perform crossover till the end of time, we will never find our solution.

To resolve this, we perform mutation. Mutation is as the name suggest. We subject a gene to mutate (in our case, to a different random letter) with a low random probability.

This allows us to maintain diversity in our population and ensure that we arrive at a solution.

Stop Condition

The algorithm repeats the loop until the population has either:

Converged (the generated offspring isn't much different from the previous generation)
Reached a certain number of generations

Once the algorithm stops, we can say that the final set of individuals is the solution to our problem.

Solving the Infinite Monkey Theorem

Let’s see how we can apply what we learned to solve the infinite monkey theorem.
As a refresher, we are trying to solve for the phrase if music be the food of love play on.

This phrase has 36 characters, so each individual will have a chromosome with 36 genes. Each gene will start with a randomized lowercase letter (or space). A chromosome represents a potential solution of the phrase.

The fitness value of each chromosome is calculated based on how many characters it got correct in the proper position. A chromosome that guesses the phrase exactly has a perfect fitness score of 36. A chromosome with no correct characters, on the other hand, has a fitness score of 0.

The aim of our genetic algorithm is to maximize the fitness function. So, individuals with higher fitnesses are selected over individuals with low fitnesses. At the end, we expect our population to have an individual with the perfect score of 36.

By doing this, we can achieve the following result:

Here are some few comments about it:

For each iteration, the algorithm loops through the process we described above until either A) it reaches the maximum of 10,000 generations, or B) it reaches our target phrase.
Out of the total population of 5000, the top 50 solutions are displayed.
The right number shows the fitness, i.e. the number of correct genes in the solution.
Incorrect genes have a red background.
The solutions are ordered according to fitness, with the solution with the highest fitness on top and the one with the lowest fitness at the bottom.

In the next part of this series, we’ll walk step by step on how to code this. For the curious, here’s where you can find the final result and the source code.

Note: since genetic algorithms are relatively resource intensive, the demo might be slow on mobile.

Conclusion

Genetic algorithms are algorithms inspired by Darwin’s theory of evolution. In a nutshell, it uses:

Natural selection to select the best solutions to a problem
Crossover mix the best solutions to create even better solutions
Mutation in order to maintain diversity in the population

Through these, best solutions are kept and bad solutions are removed quickly. This allows us to arrive at the ideal solution for a search problem relatively ease.

Genetic algorithms are a prime example of how much we can learn from nature. I hope that through this article (and the rest that will come from this series), you will find a new appreciation for how sophisticated and beautiful our natural world is.

See you around next time!

What is name in Python?

Adrian Perea — Mon, 29 Jun 2020 14:13:30 +0000

You’ve most likely seen the following piece of code at the bottom of a Python script:

if __name__ == ‘__main__’:

You've most likely seen the following piece of code at the bottom of a script:

if __name__ == '__main__':
   # some code here

While this line of code may seem mundane, it's actually quite powerful! It allows you to run python code as standalone scripts or import them as modules.

How does it work?

The __name__ variable is a special "dunder" or magic variables in Python. Dunder stands for "double underscore", hence the two underscores on both sides.

Dunder variables hold special meaning in Python. The value of the __name__ dunder variable depends on how you execute the script.

If you run your script from the command line, the __name__ has the value __main__. If you import it, it will contain the name of the script.

Let's see how this works through code.

A simple example

Suppose you're making a simple greeter module. You want it to behave as follows:

When it's run as a standalone script, it asks the name of the user and prints "Hi, {user}!". It repeats this until the program exits.
When it's imported, it exposes a greet function that can create a greeting given a name

Seems simple enough! Let's code it.

# greeter.py

function greet(name):
   print(f'Hi, {name}!')

print('__name__ is:', __name__)

if __name__ == '__main__':
   while True:
      print("What's your name?")
      name = input('> ')

      if name == 'q':
        break

      greeter(name)

When you execute this script, you'll see the following output:

__name__ is: __main__
What's your name?
> Adrian
Hi, Adrian!

The magic happens before the code runs. Python assigns the value __main__ to __name__ since the script is ran standalone.

Importing our greeter function

What happens then if you import this script as a module from another script?

# client.py

from greeter import greet

names = ['Jeff', 'Annie', 'Britta']

for name in names:
   greet(name)

When you run this, you should see the following output:

__name__ is: greeter
Hi, Jeff!
Hi, Annie!
Hi, Britta!

Since we imported greeter as a module, Python assigned the name of the module, i.e. greeter, as the value of __name__. Due to this, the code block inside __main__ never gets executed.

Conclusion

Congratulations! You made a Python script that you can execute standalone or as a module. All you had to do was to include the following if statement:

if __name__ == '__main__':
 # some code here

You can find the sample code used in this article right here.

As a recap, this works because when you run a Python script, the __name__ dunder variable is:

__main__ if you run the script from the command line
The name of the module if you import it from another script

I hope this short tutorial was helpful!

7 Simple Ways to Increase Your Productivity

Adrian Perea — Sat, 27 Jun 2020 12:08:19 +0000

This post already appeared on adrianperea.dev

There are only so many hours in the day, so how can you make sure you're making the most of your time?

It's easy to get lost in a sea of code (even clean code!) and completely lose track of time. That's why before tackling any coding project, you need a plan of attack.

This post will walk you through 9 simple tools and strategies to boost your productivity.

1. Avoid Mental Mapping when Trying to Understand Code

You might think that you're good at juggling things in memory. But research has shown that we can only have up to 7 items in our short-term memory at a time. So avoid mental mapping! Don't try to keep everything in your head when trying to understand code.

Write it down. Draw diagrams. Draw flow charts. Pen and paper works best for me. Find out what works for you!

Make sure your brain is doing what it's best at: processing. Leave everything else to auxiliary tools.

2. Practice Whiteboard Programming

Whiteboard programming is the practice of solving a problem outside your text editor. You do this by writing down what you're trying to solve and breaking it down to individual steps. You can write it using pseudocode or natural speech. Whatever works for you!

But why do this? Whiteboard programming offers the following benefits:

It makes sure that you understand the problem completely
It allows you to break the problem to individual steps

Once you know the steps to solve your problem, everything else is a matter of syntax. Programming, then, will be a breeze.

3. Write Learning Tests for Third Party Libraries

Learning tests are exactly what they sound like. They're tests that help you learn third party libraries.

Writing tests for libraries may seem anti-productive (how can more work help productivity?) but it's not! Writing tests assures your understanding of the library.

Once you start using it in your production code, you can make sure that everything works as you would expect. So, you will be able to write your code with confidence.

As an added benefit, if a library gets updated, you can run the tests and immediately see if anything breaks.

4. Leverage Creative Momentum

An object at motion stays in motion! Program a lot, and keep on building! The more you program, the more your mind gets attuned to programming, the better/faster you code!

5. But also take breaks. Use the Pomodoro Technique

Not all productivity is active productivity. If you're tired, the most productive thing to do is to rest. If you're stuck at a problem, the best way to solve it is by taking a walk to clear your mind.

The pomodoro technique allows you to systemize this. The technique uses a timer to break work into 25-minute intervals followed by a short rest. After four work intervals, you get to take a longer rest. A short rest usually lasts 5 minutes, and a long one lasts 25 minutes.

If you followed tip #2 and broke down your problems into steps, it takes no effort at all to map them to work intervals. For longer tasks, it helps to assign more than one work interval.

I hear from a lot of other programmers that 25 minutes is sometimes too short of a work interval. That's very true. Once we get into a state of momentum (tip #4), it can be counter-productive to force ourselves to stop.

If 25 minutes is too short for you, the good news is you don't have to follow pomodoro to a fault. But you should learn from its principle: take breaks! Your mind will thank you for it.

I use Focus To-do for my daily pomodoro needs. But there are already a lot of other apps out there for different platforms.

6. Manual Time Tracking

Manual time tracking is no more than tracking how much time you take to perform different tasks. By doing manual time tracking, you get better at estimating how long tasks take.

This is essential, because then you can get insights like:

How much time you've actually spent on a project
Which tasks take most of your time
Why do some tasks take a lot of your time (are you getting distracted? Do you need more practice doing that particular task?)

Once you know patterns in your behavior, you can then make steps in knowing what problems to solve!

You can use any application that you like that can keep track of time. I use Clockify. It can break down tasks into projects, and offers free analytics.

7. Automatic Time Tracking

Manual time tracking is for general tasks. Automatic time tracking is for programming.

Automatic time tracking tracks the following:
How much time you spend programming
Which languages do you spend most time on
Which IDE do you use most of the time

I found out through this technique that I spend more time on CSS than in JavaScript. This made me realize that I needed to step up my CSS game!

I use WakaTime to do automatic time tracking. It integrates with a ton of IDEs and text editors. For Visual Studio Code, all you need to do is sign up (for free) and download the extension. After that, you'll be able to see your stats in their web dashboard.

Bonus!

As a bonus tip, the best -- and possibly hardest -- way to keep yourself a productive developer is to be kind to yourself.

Our jobs are difficult! There will be days that things will be overwhelming. There will be days you will feel imposter syndrome. During these days, the last thing you need is kicking yourself while you're down.

Take a step back, take a deep breath, and relax. You're doing fine.

Keep on coding. We’re all waiting for your next big thing!

Quick! Share your awesome coding tunes!

Adrian Perea — Tue, 23 Jun 2020 17:11:10 +0000

Mine may be kind of basic, but I love Carbon Based Lifeforms and God is an Astronaut.

I find myself too distracted if the music has lyrics or any flashy melodies, so I listen mostly to post-rock tunes and instrumentals.

However, whenever I find myself strangely pumped, I put on something a little more upbeat like Amy Winehouse or Bruno Mars. It steals my focus but I tend to enjoy more 😅

What's your coding 🎶🎶🎶?

Watch AI Evolve to Play Flappy Bird

Adrian Perea — Sun, 21 Jun 2020 10:01:46 +0000

AI evolves to play flappy bird using genetic algorithms and neural networks 🎉

Assets are still in beta, but happy that the data model and UI interaction are finally done!

Here's a demo:

You can see the site live right here.

For the curious, pre-compilation ones and zeros are here. 😎

Let me know in the comments if you want a step-by-step on how I did it!

Of Classes and Constructor Functions: How JavaScript is Different from Other OOP Languages

Adrian Perea — Thu, 18 Jun 2020 16:07:35 +0000

This post originally appeared on adrianperea.dev

A question was raised about the difference between functions and constructor functions in JavaScript. The question follows JavaScript's notorious reputation of not being a real Object Oriented language.

And while this is true (which we will get into later), popular literature mostly explains why in comparison with traditional OOP languages like C++, Java, or Python. Not only is this not helpful, it's also confusing for those who aren't familiar with those languages.

So in this article, I will try to clear up how JavaScript classes are different from traditional OOP classes. I will be using Python as a representative of those languages because it's easy to understand and its relatively close to JavaScript.

Traditional OOP Languages

A class is often defined as a blueprint for for objects. It serves two practical purposes:

Abstraction: which information is relevant? Which is irrelevant?
Encapsulation: how do I show or hide what is relevant or irrelevant?

At its very core, a class has two types of properties: members and methods. These properties define the data stored in the class and what operations the class can do on that data.

To make use of a class, we create instances of the class through a process called instantiation. Each instance gets isolated copies of the members and methods of the class. Let's see how this works in Python:

class Person:
  def __init__(self, first_name, last_name):
    self.first_name = first_name
    self.last_name = last_name

  def print_full_name(self):
    print(f'{self.first_name} {self.last_name}')

person_a = Person('Adrian', 'Perea')
person_b = Person('Ben', 'Halpern')

person_a.print_full_name() # Adrian Perea
person_b.print_full_name() # Ben Halpern

In this example, person_a and person_b are instances of Person. Each of them gets their own first_name and last_name members, and their own print_full_name method.

Now in Python, you perform instantiation by just calling the class directly (like how we created person_a and person_b). Traditionally however, this wasn't always the case. In C++ and Java, for example, you need to add the keyword new in order to be able to instantiate the class. I believe that this is where the confusion starts.

JavaScript

In JavaScript, we have something called constructor functions that we called with the new keyword. These constructor functions are the JavaScript analog of the class. Now while it seems that this is the same thing as the other languages we've mentioned, JavaScript behaves differently whenever we use these constructor functions. See, whenever we use the new keyword to execute a constructor function, we're essentially telling JavaScript to run the function normally, but with two extra steps behind the scenes:

An implicit object is created at the start of the function that we can reference with this.
The resulting instance has a copy of the constructor function's prototype property inside its own prototype.

Don't worry about the details for now as we'll get to those later. Let's see first how we can make a JavaScript object without any fancy constructor functions:

function Person(firstName, lastName) {
  return {
    firstName,
    lastName,
    fullName() {
      console.log(`${this.firstName} ${this.lastName}`)
    }
  };
}

const personA = Person('Adrian', 'Perea');
const personB = Person('Ben', 'Halpern');

personA.fullName() // Adrian Perea
personB.fullName() // Ben Halpern

This works fully well! Why not call it a day and be done with it?

Well, the brutally honest truth is, we can. There are a lot of things that we can accomplish by simply creating objects this way. But in so doing, we're missing the entire point of JavaScript being what we call a prototype-based language. This is what makes it unique (not necessarily better nor worse) from the traditional OOP languages.

Now let's see how we can implement this another way. While you're reading the following snippet, remember the extra two steps that happen behind the scenes when constructor functions are called with new.

function Person(firstName, lastName) {
  // 1. An implicit object is created that we can reference with `this`
  this.firstName = firstName;
  this.lastName = lastName;
}

// 2. The resulting instance has a copy of the 
// constructor function's prototype property 
// inside its own prototype. 
Person.prototype.fullName = function() {
  console.log(`${firstName} ${lastName}`);
}

const personA = new Person('Adrian', 'Perea');
const personB = new Person('Ben', 'Halpern');

personA.fullName() // Adrian Perea
personB.fullName() // Ben Halpern

Now this is where the magic happens. As you can see, when we created the Person class, we separated where we defined the members (firstName and lastName) and where we defined the method (fullName). firstName and lastName are right where you expect them: inside the constructor function definition. But the interesting part is where we define fullName and that's in the prototype of the constructor function.

Why is this important? It's important because whenever we create a new instance of the Person constructor function through the new keyword, a reference to the prototype property of constructor function gets added to the __proto__ property of the object. Read that again. After that, read it one more time. This part is important.

personA.__proto__ === Person.prototype;

As opposed to traditional OOP languages, methods are not copied to each instance of the constructor function (or class). When we call personA.fullName(), instead of finding the method in the instance itself, JavaScript looks at the __proto__ property of personA and climbs up until it finds fullName. Since we defined fullName in Person.prototype, and since Person.prototype is the same as personA.__proto__, when we call personA.fullName(), we're calling a method that exists not in the instance but in the constructor function itself! This provides performance benefits since the methods only have to be defined once (on the prototype of the constructor function). That's to say:

personA.fullName === personB.fullName === Person.prototype.fullName;

This means that whatever we define on Person.prototype will be available to all instances of Person. In effect, we can do something weird (in traditional OOP sense) like this:

Person.prototype.sayHi = function() {
  console.log(`Hi! I'm ${this.firstName}`);
}

// Note that we did not recreate the objects here
personA.sayHi(); // Hi! I'm Adrian
personB.sayHi(); // Hi! I'm Ben

So there you have it. To sum things up:

Constructor functions do two things in the background whenever they are called with new: create an implicit object that can be referenced with this, and assign the __proto__ property of each instance to refer to the prototype property of the constructor function
When a function is called on the instance, the __proto__ property is climbed until a reference to the called function is found. This means that each instance doesn't have a reference to the method, but all share the same method that's defined on the constructor function.
In traditional OOP, all instances have a copy of each method. There is no concept of prototypes.

What about ES6 "classes"

ES6 "classes" don't really introduce the classes as we traditionally know them. It makes writing constructor functions easier since you wouldn't have to write prototype for each method you want to share amongst instances. ES6 class syntax is simply an easier way to store all members and methods of a constructor function all in one place, while also abstracting prototype and all the confusion it brings.

As an example, we can write the Person constructor function the following way:

class Person {
  constructor(firstName, lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }

  fullName() {
    console.log(`${firstName} ${lastName}`);
  }
}

You can see that it looks very similar to our python example (but you and I both know they're not the same!). Try creating instances of the Person and look at the prototype property yourself! 😉

Hi! I'm Adrian, and I'm a software engineer. I work hard to provide helpful and highly intuitive content for free. If you like what you read, check out my blog or follow me on Twitter. Hope to see you again next time!

What CSS tip do you want to share with others?

Adrian Perea — Wed, 17 Jun 2020 09:55:06 +0000

The world of CSS is very wild. Let's help each other out by sharing things that give it some order!

I'll start!

You can ditch media queries for dynamically changing font-sizes by use of fluid typography. By using min, max, and viewport units, we can dynamically change the font-size and constrain so that they don't explode (or shrink).

Let's see an example. Let's say you want your header to be 2rem on mobile and 4rem on larger displays. Here's how you use fluid typography to accomplish that:

h1 {
    // font-size: min(max({MIN_SIZE}, 4vw), {MAX_SIZE});
    font-size: min(max(2rem, 4vw), 4rem);
}

On most cases, 1rem = 16px, so our minimum font-size is 32px. This means that when the viewport width is less than 800px (0.04 * 800px = 32px), we will always have 32px as our font-size. This is perfect for mobile. When the viewport width is greater than 800px, our font-size will dynamically change along with the viewport, but never exceed 4rem = 64px.

4vw was just used as an example. You can change it to any value that suits your needs.

To see this in action, try changing the viewport width of the pen below. I changed 4vw to 8vw to make the font-size increase faster (font-size acceleration?!):

And that's it! In just one line of code, you can make your font-size responsive!

I hope this simple trick helps you guys out.
Share other awesome tips down below! 🎉

DEV Community: Adrian Perea

Better Python String Formatting Using f-strings

What the f-strings

Rounding Off Digits

Aligning Items

String formatting is not fun

How to Iterate Through Multiple Python Lists at Once

Getting the zipped elements as a list

Unzipping a zip object

Zipping unequal list lengths

Further Reading

Better Python for Loops Using enumerate

Learn Docker by Dockerizing a Flask Application

Reinvent the Wheel, then Display It Like a Trophy

Caring for our Craft

Reinvent the Wheel

A Gentle Introduction to Genetic Algorithms

The Infinite Monkey Theorem

The Power of Genetic Algorithms

Initial Population

Fitness Function

Selection

Crossover

Mutation

Stop Condition

Solving the Infinite Monkey Theorem

Conclusion

What is __name__ in Python?

How does it work?

A simple example

Importing our greeter function

Conclusion

7 Simple Ways to Increase Your Productivity

1. Avoid Mental Mapping when Trying to Understand Code

2. Practice Whiteboard Programming

3. Write Learning Tests for Third Party Libraries

4. Leverage Creative Momentum

5. But also take breaks. Use the Pomodoro Technique

6. Manual Time Tracking

7. Automatic Time Tracking

Bonus!

Quick! Share your awesome coding tunes!

Watch AI Evolve to Play Flappy Bird

Of Classes and Constructor Functions: How JavaScript is Different from Other OOP Languages

Traditional OOP Languages

JavaScript

What about ES6 "classes"

What CSS tip do you want to share with others?

What is name in Python?