Because it is commonly asked in tech interviews, one can say.

The reason that many tech companies test their candidate's knowledge of big O notation is to check if the candidate can write efficient code and is aware of what kinds of code are expensive to run, both in terms of actual money and resources, such as computer memory or processing time.

It is important to write code that runs without errors and outputs the expected result, but there is a third component in it, which is efficiency.

A company that hosts its services on cloud servers, such as AWS or Google Cloud, can save millions just by replacing an inefficient code with an efficient one. With optimization, it is possible to do the same work on a much cheaper server or spend less computing time. This is just an example where just by changing a piece of code it is possible to save millions of dollars, so no wonder it is essential for companies to search for programmers that can write efficient code.

Even if you are writing just simple scripts, a skill that empowers you to look at a piece of code and lets you know which parts of it are critical to performance will empower you to always make the best decisions to build a fast program that can serve millions of users or process huge loads of data in no time.

So let's learn about big O notation!

What is Big O Notation?

Big O notation is always pessimistic. Suppose I have a list that contains thousands of names:

# I have a long list of names
names = ['Ed', 'Karl', 'Sam', 'Ana', thousands of names, 'Boris']

Imagine that I have a program that searches for a name in the names list. One way for a computer to search a list is by checking one item at a time. If the name to be found is "Sam", as humans we can just look at the above list and find it, but with computers, the process goes like this:

• First item at index 0 is Ed. Is Ed equal to Sam? No

• Second item at index 1 is Karl. Is Karl equal to Sam? No

• Third item at index 2 is Sam. Is Sam equal to Sam? Yes

• Sam was found at index 2

The same process happens in the following Python code:

# For each name in names list
for name in names:
  # If name is equal to 'Sam'
  if name == 'Sam':
    # Returns True
    return True
# If 'Sam' was not found in the list, return False
return False

The best-case scenario is finding "Ed". Ed is the first item on the list, so it will be found very fast, regardless of the list size. But as programmers, we always need to think in terms of the worst-case scenario, because they are the ones responsible for problems.

The worst-case scenario is a name that is not on the list. A computer will have to check all names in this huge list, one by one, only to tell us that the name is not on the list.

Big O notation is interested only in the worst-case scenario. In simple terms, it gives a grade to the performance of a task in the worst-case possible.

The process I described here to find a name on a list can be defined as an algorithm. Do not let its fancy name deceive you.

An algorithm is just a list of steps that are needed to solve a problem. You can think of these real-world examples that are equivalent to an algorithm:

• Directions from home to a bakery: From your home, turn right, walk 500 meters, turn left, cross a bridge, and walk 50 meters. You will reach the bakery.

• A recipe for fried egg: Take a frying pan and put one tablespoon of oil on it. Place it on medium heat. Break one egg in the frying pan. Cook until the egg yolk becomes solid. You have a fried egg!

From now on, instead of saying a task, a program or code, I will use "algorithm".

When does efficiency matter?

If my algorithm is dealing with a small input, like a list with 10 items, it will not benefit from optimization, as any algorithm will complete the task in some milliseconds, with no notable difference between the top and worst performers. An algorithm that orders a list of numbers with only 10 items will not benefit much from optimization, as it will be done in a very short time, regardless of its performance.

Most users would be satisfied with a process that takes less than a second to complete, but as the size of the list increases, performance can suffer to a point that even a human can feel.

Below you can find a comparison between an okay algorithm and a bad one. It shows how many operations are needed as we increase the size of a list.

You will see later what O(n) and O(n²) mean.

When the size of the list is small, the number of operations in the worst case remains small. But when the size begins to increase from 1.000 onwards, the discrepancies between an okay algorithm and a bad algorithm become very evident.

Some algorithms can take months or thousands of years to complete a task if an inefficient algorithm is used because they have to deal with huge amounts of data, think about big data or machine learning. Or it will not have practical applicability if a result cannot be found in a very short time, think about calculating a route in Google Maps or giving product recommendations at Amazon. Google would not have a viable product if returning a route from point A to point B would take 15 minutes.

The types of efficiency, from best to worst

Constant Time: The Gold Standard

Representation: O(1)

This is the most efficient algorithm. An algorithm that has a constant time takes the same amount of time to get the task done, regardless of the size of the input. By input, here I mean the length of the list. Normally as the length increases, the time required to do a certain task increases, but not when we are dealing with a constant time algorithm.

I will list some operations that are done in constant time:

names[-1] # Gets the last item of a list
# Returns Boris

names[-1] = 'Clara' # Sets the last item as Clara

names.append('Marcus') # Appends 'Marcus' to the end of the list

names.pop() # Removes the last item from the list

All these operations take the same time, regardless if a list has one name or thousands of names. Also, there is no difference between best-case and worst-case here.

This may look strange because I have said previously that a computer must look for all items on a list when searching for a value. But when the index of the item is known or we know that we are dealing with the last item, there is no need to hop from item to item. When using append() or pop() we don't have to go through the items on the list because we only want to change the end of the list and we know where the last item is located.

If we create a graph with the time needed for the algorithm to complete versus the volume of data, the result will be this:

The time remains the same, regardless of the input size. The number of operations of O(1) is 1, meaning only a single operation is needed to finsih the algorithm.

Logarithmic: Divide and conquer

Representation: O(log n), where n is the size of the list

Remember that we were searching for a name on a list? If the list was sorted alphabetically, it would be possible to search more efficiently. Suppose I am searching for the name "Hagar", which begins with "H":

# We have sorted the list alphabetically
sorted_names = ['Ana', 'Boris', 'Ed', 'Karl', 'Sam', thousands of sorted names, 'Zara']
# size of the list: 10.000

# Get to the middle of the list, divide the list in two
# Is the letter H in the left list or in the right list?
divided_names = ['Ana', ..., 'Marcus'] + ['May', ..., 'Zara']
# size of left list: 5.000
# size of right list: 5.000

# As H is between A and M, we can safely discard the right list, reducing the problem in half!
sorted_names = ['Ana', ..., 'Marcus']
# size of the list: 5.000

# We again get the middle of the list and divide it in two, repeating the process
divided_names = ['Ana', ..., 'Fred'] + ['Frodo', ..., 'Marcus']
# size of left list: 2.500
# size of right list: 2.500

# H should be on the right list, we again reduced the problem in half!
sorted_names = ['Frodo', ..., 'Marcus']
# size of the list: 2.500

# Continues until there is one name left in the list

The worst-case situation would be not finding a name on the list.

As you can see, by dividing the list size by half, we are also dividing the size of the problem by half. This is much more efficient than checking all the items one by one.

This makes sense if we think of real-life examples. The contacts list on our phones is organized by name and as a result, we can quickly find the contact name we want. Searching for a contact in the contacts list is a very common task, so the programmers of the phone book app already sorted the contact list alphabetically for us. It would be much harder to find a contact if the contacts were sorted by the date they were added or if they were shown in a random order.

If we apply this principle to code, if we know that a list will be searched many times, we can optimize the time needed to do these searches by sorting the list beforehand. Sorting is a costly process in terms of time, but this cost is only paid once, so it is worthwhile in cases where we know that we are going to do multiple searches.

The graph of a logarithmic algorithm will be:

It starts to increase, but as the input size gets larger, the execution time begins to flatten. It gets more efficient as the input size gets larger.

O(log n) means that the number of operations needed in the worst case is log n. For example, log(4) is 2, which is just half, but log(100) is 6.644 and log(1000) is 9.966. You can see that the number of operations remains small even with a list with a huge size.

Linear: The predictable algorithm

Representation O(n), where n is the size of the list

The process I described when trying the find a name on a list is classified as a linear algorithm. It checks for every item on a list in its worst case, so the time needed to do this depends on the size of the list.

The code below is equivalent to the example I refer to above:

# For each name in names list
for name in names:
  # If name is equal to 'Sam'
  if name == 'Sam':
    # Returns True
    return True
# If 'Sam' was not found in the list, return False
return False

Sometimes a single line of code has the same complexity as the code above:

if 'Sam' in names:
    return True
return False

The part 'Sam' in names has a time complexity of O(n), despite being a single line. The underlining process is the same: it still has to go through all items in the list if the name is not on the list.

When analyzing a piece of code, always think about the principles of how a computer completes the task. To look for the name Sam in the names list, it still has to search one name at a time, despite being a one-liner and inside an if condition.

The graph below shows what a linear algorithm looks like:

As the size of the list increases, the time needed follows together.

Danger Zone: Things could start to get slow from here

Quadratic:

Representation: O(n²)

Imagine that I want to check if there is a duplicate name in the list of names.

# I have a long list of names
names = ['Ed', 'Karl', 'Sam', 'Ana', thousands of names, 'Boris']

# For each name in names list
for index1, name1 in enumerate(names):
  # Loop through the list again
  for index2, name2 in enumerate(names):
    # Only make a comparison when indexes are different
    if index1 != index2:
      # If names are equal, print message with the duplicate name
      if name1 == name2:
        print(f'A duplicate name was found: {name1}')

Here enumerate() allows me to keep track of indexes of the list without needing to use range() and len() allowing me to write a simpler and cleaner code.

This algorithm starts almost the same as a linear algorithm, with a for loop, but it has an important difference. There is another for loop inside the first loop! It means that: For each name in the list, we have to loop through all names in the list!

The worst-case scenario would be any run because this time the algorithm continues to run until the end of the list even if a duplicate was found. Even I can feel the amount of work that the poor computer would need to perform!

The graph looks like an inverted logarithmic graph: As the input size gets larger, the execution time increases drastically.

Exponential

Representation O(2ˆn)

I have a list with a single name and I want to generate all the possible combinations. There would be two possible combinations:

• One with the name "Ed"

• One empty list, without the name "Ed"

name = ['Ed']

ed_present = ['Ed']
ed_absent = []

# Let's combine all possibilities

scenario1 = ['Ed']
scenario2 = []

Now, what if I wanted all combinations from a list with two names?

The process would be the same, for each name, the name can be included or excluded:

names = ['Ed', 'John']

# Ed can be present or absent
ed_present = ['Ed']
ed_absent = []

# John can be present or absent
john_present = ['John']
john_absent = []

# Let's combine all possibilities
scenario1 = ['Ed', 'John'] #combining ed_present + john_present
scenario2 = ['Ed'] #combining ed_present + john_absent
scenario3 = ['John'] #combining ed_absent + john_present
scenario4 = [] #combining ed_absent + john_absent

We can see a pattern here, we can multiply the resulting 2 possibilities of Ed with the 2 possibilities of John so we get 4.

names = ['Ed', 'John', 'Maria']

# Ed can be present or absent
ed_present = ['Ed']
ed_absent = []

# John can be present or absent
john_present = ['John']
john_absent = []

# Maria can be present or absent
maria_present = ['Maria']
maria_absent = []

With 3 elements, the total combinations would be 2 x 2 x 2, which would result in 8.

To calculate the necessary steps to go through all combinations, we can calculate 2 to the power of the length of the list, or 2 ˆ <list_length>, as we saw in the previous examples:

• With a list of length 1: 2 ^ 1 = 2

• With a list of length 2: 2 ^ 2 = 4

• With a list of length 3: 2 ^ 3 = 8

This can get ugly very fast, as with a length of 20 you will be returning 1,048,576 combinations and with a length of 63, it will return a whooping 9,223,372,036,854,775,808 combinations.

As you can see, the rate of growth of an algorithm with exponential complexity is very steep and it is very slow.

Conclusions

Although some algorithms are better than others, some problems are not possible to be solved with a good algorithm and we need to stick with a bad algorithm, as it is our only option. If we need to search for an item on a list, there is no way we can achieve this in a constant time or O(1).

As we saw, there are creative ways to increase efficiency, by transforming a linear algorithm O(n) to a logarithmic O(log n) by sorting the list before searching and then dividing the problem in half. In this case, it will be worth it if you plan to do multiple searches on the list, as there is a cost for sorting the list.

In this article, I gave examples related only to lists, but any input is applicable here. It could be integers, dictionaries, and so on, but I chose lists because most of my readers would be more comfortable with them.

When trying to determine the complexity of an algorithm you wrote, keep the big picture. Keep an eye out for loops as they are the main cause of increases in complexity. However spotting a loop can be a challenge, as it can be disguised as something else:

# This line below appears to be simple, but has a complexity of O(n)
if 'Kenya' in names:
  print('Found Kenya')

In the example above, it appears that this is only an if cause, which can be safely ignored, but if you think about it, it needs to iterate a list to find the name "Kenya". It does the same as :

# This loop has a complexity of O(n)
for name in names:
  if name == 'Kenya':
    print('Found Kenya')

Final Considerations

When writing an algorithm for the first time, you should not aim for performance. Instead, aim for an algorithm that does the job correctly. Then, if the need arises, you should start optimizing it to go faster. Remember: Premature optimization is the root of all evil

Hope you liked this article! If you have questions or comments, please write them in the comments section :)

Web pages do not persist data by default. If you reload the page while writing a long text, the text is gone forever. This lack of persistence could be very annoying in situations like:

• Setting the page to dark mode, but having it revert to light mode on return.

• Spending time choosing products for a shopping cart, only to find it empty when you return.

• Writing a lengthy blog post, being logged off, and losing all progress when the post is submitted

Using localStorage enables your apps to save information without the need for a backend server. This means no need for storage infrastructure and no costs for you since the data is being stored on your user's computer instead of a server you manage.

It also can be used for static pages to have data persistence. Imagine you built a simple ToDo app that is hosted on Github Pages. It is fast to load and can be hosted for free, but it is useless because when the user leaves the page, all his tasks are gone. localStorage can solve this issue by saving the tasks in the user's machine.

Here's how to use localStorage

• setItem saves data to the user's browser

• getItem retrieves the saved data from the user's browser

• removeItem removes the saved data from the user's browser

Example 1: Dark mode

Suppose I have a webpage that has a dark mode option. I would want the webpage to remember the user's preference. Notice that when retrieving data from localStorage, getItem() always returns the data as a string, so you need to convert it to the actual data type that you originally saved using JSON.parse() to avoid using true as a string in a comparison, which could lead to errors in the app:

// Store the user's preference
localStorage.setItem('darkMode', true)

// Retrieve the user's preference from localStorage 
// getItem() always returns a string
const darkModeData = localStorage.getItem('darkMode') // returns a string: 'true' 

// Convert string to a Boolean value
const darkMode = JSON.parse(darkModeData) // returns a bollean: true

Example 2: A static page

In the second example, I have a To-Do app and I want to save my list of tasks to do. I can save the array in localStorage, but when saving complex data structures like objects and arrays, I need to convert them to a string using JSON.stringify():

const tasks = [
    'Go to gym',
    'Prepare dinner',
    'Go to supermarket',
]

// Array tasks gets converted to a string
arrayAsString = JSON.stringify(tasks)

// Store the array as a value of the key tasks
localStorage.setItem('tasks', arrayAsString)

Why do I need JSON.stringify()?

You could be thinking that localStorage.setItem() saves the value as a string anyways, so why the need to convert the value to a string beforehand using JSON.stringify() ?

That is because behind the curtains localStorage.setItem() uses toString() which gives some unexpected results compared to JSON.stringfy():

/* With booleans, integers and float the result is the same */
const boolExample = true

boolExample.toString() 
// Returns 'true'

JSON.stringify(true) 
// Returns 'true'

/* When using objects, the results are very different */

const product = {
  name: 'ice cream',
  price: 1.20,
  quantity: 2
}

product.toString()
// Returns '[object Object]'

JSON.stringify(product) 
// Returns '{"name":"ice cream","price":1.2,"quantity":2}'

/* With arrays, there are unexpected differences */

const users = ['Paul', 'Maria', 'Ken']

users.toString()
// Returns 'Paul,Maria,Ken'

JSON.stringify(users)
// Returns '["Paul","Maria","Ken"]'

In summary, JSON.stringify converts objects and arrays into strings in a way that it is possible to easily convert them back to their original forms. On the other hand, toString() removes their original data structure, making it difficult or impossible to convert back to their original form.

Example 3: A shopping cart

const cartItems = [
    {
        product: 'ice cream',
        flavour: 'vanilla',
        quantity: 1    
    },
    {
        product: 'hamburger',
        toppings: ['picles', 'cheese'],
        quantity: 2
    }
]

// Same as before, convert the array of object into a string
arrayAsString = JSON.stringify(shoppingCart)

// Store the array of objects converted to string
localStorage.setItem('cartItems', arrayAsString)

// Deletes the cart
localStorage.removeItem('cartItems')

Conclusion

localStorage is a great way to store data without the need to set and maintain databases. You are transferring the responsibility of storing data from your servers to your users, so you can power up your static websites or can expand your page's capabilities without touching your database servers.

The data stored at localStorage will not expire and will remain as long as the user does not clean the browser's cache. Depending on the browser, it can store up to 5MB of data or an unlimited amount.

You should never use localStorage for storing sensitive data, such as passwords, login sessions or credit card information, because the data stored in localStorage is not encrypted and can be accessed by a malicious hacker or even someone who has access to the browser can just use the browser's developer tools and see what is stored there.

Happy coding!

Stack Overflow is a great resource, but it requires to search through the answers to find the best solution or to visit multiple related questions to find the answer to a specific problem. Its moderation rules are very strict, so open-ended questions are banned, and questions that are considered similar to already existing ones are quickly closed. It is intended to use a simple and direct input => output style forum, where a users inputs a question and the community answers the question and the most up-voted answer becomes the standard answer for the question.

ChatGPT was released in 2022 and caused a great uproar, as it is an AI that can produce answers in many domains of knowledge, in a very human and smart way. It is not perfect, but it is expected to do huge leaps of evolution since it is constantly learning from its 100 millions of users and the ever growing data on the Internet. You can test it for free on its official page.

The launch to the general public of such polished AI for free created huge shockwaves across the tech industry and caused Google to panic, as ChatGPT was integrated into Microsoft's search engine Bing, creating a much more intelligent and human like search experience, threatening Google's search business, which is the main source of revenue for the tech giant.

Examples of use

ChatGPT can answer in a detailed way almost all kinds of programming questions:

Me: I have an array of objects in Javascript in which each object has a boolean value. How do I filter objects based on this value?

ChatGPT: To filter an array of objects in JavaScript based on a boolean property, you can use the filter() method along with a conditional statement that checks the value of the property. Here's an example:

const myArray = [
  { id: 1, value: true },
  { id: 2, value: false },
  { id: 3, value: true },
  { id: 4, value: false }
];

const trueValues = myArray.filter(object => object.value === true);
const falseValues = myArray.filter(object => object.value === false);

console.log(trueValues);
console.log(falseValues);

In this example, we have an array of objects with an id property and a value property that contains a boolean value. We want to filter the objects that have a value of true and the objects that have a value of false.

We use the filter() method twice, once to filter the objects that have a value of true, and once to filter the objects that have a value of false.

In each call to filter(), we pass a callback function that takes an object as its parameter. The callback function checks the value property of the object using a conditional statement, and returns true if the value matches the condition, and false otherwise.

The filter() method returns a new array that contains the objects that match the condition. We store the two resulting arrays in separate variables and log them to the console.

You can refer to its previous answer to ask new questions:

Me: Is it possible to filter the value in a single loop?

ChatGPT: Yes, it is possible to filter an array of objects based on a boolean property using a single loop. Here's an example:

const myArray = [
  { id: 1, value: true },
  { id: 2, value: false },
  { id: 3, value: true },
  { id: 4, value: false }
];

const trueValues = [];
const falseValues = [];

for (let i = 0; i < myArray.length; i++) {
  const object = myArray[i];
  if (object.value === true) {
    trueValues.push(object);
  } else {
    falseValues.push(object);
  }
}

console.log(trueValues);
console.log(falseValues);

In this example, we initialize two empty arrays, trueValues and falseValues, to store the objects that match the condition.

We then use a for loop to iterate over the array of objects. For each object, we check the value property using a conditional statement, and push the object to the corresponding array based on its value.

The for loop allows us to filter the array in a single pass, without having to call the filter() method twice. We store the resulting arrays in separate variables and log them to the console.

It is well aware of the context in which the questions are asked and it is not just a database of answers of StackOverflow:

Me: Which solution is the most efficient?

ChatGPT: In terms of performance, the two solutions have different tradeoffs, and the most efficient approach will depend on the specific use case.

Using the filter() method is a more concise and expressive way to filter an array of objects based on a property. It can make the code easier to read and maintain, especially for more complex filtering conditions.

However, the for loop approach can be more efficient in terms of performance, especially for large arrays. This is because it only iterates over the array once, whereas the filter() method creates a new array and iterates over it.

Additionally, using the for loop approach allows you to immediately store the objects in separate arrays, which can be more efficient than creating a new array for each filtering condition using the filter() method.

Overall, if performance is a critical concern and the array is very large, using a for loop to filter the array in a single pass is likely to be the most efficient approach. If the array is small or performance is not a critical concern, using the filter() method can provide a more concise and expressive solution.

It is possible to paste a particular piece of code and ask it if there is an error. Or ask an open-ended question like:

Me: Could you create HTML and CSS code for an app that allows animal shelters to show which animals are available for adoption and show their photo, age, characteristics and current location?

ChatGPT: Sure, here is an example HTML and CSS code for an app that allows animal shelters to show which animals are available for adoption, with their photo, age, characteristics, and current location:

HTML Code:

<!DOCTYPE html>
<html>
<head>
    <title>Animal Adoption App</title>
    <link rel="stylesheet" type="text/css" href="style.css">
</head>
<body>
    <header>
        <h1>Animal Adoption</h1>
    </header>

    <main>
        <section class="animal-list">
            <h2>Available Animals</h2>
            <ul>
                <li>
                    <img src="https://via.placeholder.com/150" alt="Cat">
                    <h3>Fluffy</h3>
                    <p>Age: 2 years</p>
                    <p>Characteristics: Playful, friendly</p>
                    <p>Current location: Cat House 1</p>
                    <button class="adopt-btn">Adopt Me!</button>
                </li>
                <li>
                    <img src="https://via.placeholder.com/150" alt="Dog">
                    <h3>Buddy</h3>
                    <p>Age: 3 years</p>
                    <p>Characteristics: Energetic, loyal</p>
                    <p>Current location: Dog House 2</p>
                    <button class="adopt-btn">Adopt Me!</button>
                </li>
                <li>
                    <img src="https://via.placeholder.com/150" alt="Rabbit">
                    <h3>Bugsy</h3>
                    <p>Age: 1 year</p>
                    <p>Characteristics: Cute, cuddly</p>
                    <p>Current location: Rabbit House 1</p>
                    <button class="adopt-btn">Adopt Me!</button>
                </li>
            </ul>
        </section>
    </main>

    <footer>
        <p>&copy; 2023 Animal Adoption App. All rights reserved.</p>
    </footer>
</body>
</html>

CSS Code:

body {
    font-family: Arial, sans-serif;
    margin: 0;
    padding: 0;
}

header {
    background-color: #008CBA;
    color: #fff;
    text-align: center;
    padding: 10px;
}

h1 {
    margin: 0;
    font-size: 36px;
}

main {
    padding: 20px;
}

.animal-list {
    margin-top: 20px;
}

.animal-list h2 {
    font-size: 24px;
    margin-bottom: 10px;
}

.animal-list ul {
    list-style: none;
    margin: 0;
    padding: 0;
    display: grid;
    grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
    grid-gap: 20px;
}

.animal-list li {
    display: flex;
    flex-direction: column;
    justify-content: space-between;
    align-items: center;
    border: 1px solid #ccc;
    padding: 10px;
}

.animal-list img {
    max-width: 100%;
}

.adopt-btn {
    background-color: #f44336;
    color: #fff;
    border: none;
    padding: 5px 10px;
    border-radius: 5px;
    cursor: pointer;
}

This code creates a simple app with one section, "Available Animals". The section displays a list of available animals with their photo, name, age, characteristics, current location, and an "Adopt Me!" button. The animals are displayed in a grid format with a responsive design.

I did not ask for the page to be mobile-friendly, but Chat GPT did it anyways by using CSS Grid. If you are curious to see how it looks, check it out on CodePen here. It does not look impressive at first sight, but you can certainly give ChatGPT some directions on how to improve it!

Problems

I noticed that if I asked ChatGPT for a solution and on top of it, added an constraint that it is not possible to fullfill, it can occasionaly produce wrong answers because it is too focused in trying to produce a valid answer:

Me: How can I write a function that converts a float into an integer?

ChatGPT: You can use the Math.floor function to convert a float to an integer. This function will round down to the nearest integer.

Here's an example function:

function floatToInt(floatNum) {
  return Math.floor(floatNum);
}

You can call this function and pass in your float as an argument. The function will return the integer equivalent of the float.

Me: Can your write another option that does not lose precision?

ChatGPT: Sure! You can also convert a float to an integer without losing precision by using the Math.trunc method. Math.trunc simply removes the decimal portion of a number without performing any rounding.

Here's an example function:

function floatToInt(floatNum) {
  return Math.trunc(floatNum);
}

You can call this function and pass in your float as an argument. The function will return the integer equivalent of the float without losing precision.

Math.trunc does not make any rounding, but still loses precision, as it simply cuts the decimal parts of a float, but ChatGPT does not see a problem in it.

Curiously, it admits the error when confronted:

Me: In the last response, using Math.trunc still loses precision, as it simply cuts the decimal

ChatGPT: You're right, I apologize for my mistake. When truncating a float to an integer, it will always lose the decimal portion of the number, and hence lose precision. The Math.trunc function only removes the decimal portion without performing any rounding, but this still results in the loss of the decimal information.

If you need to preserve the decimal information, you can convert the float to a string and then use the parseInt function to extract the integer part of the number.

Here's an example function:

function floatToInt(floatNum) {
  const floatString = floatNum.toString();
  const integerString = floatString.split('.')[0];
  return parseInt(integerString, 10);
}

In this example, we first convert the float to a string using the toString method. Then we split the string on the decimal point and keep only the integer part of the number. Finally, we use the parseInt function to convert the integer string back to an integer.

You can call this function and pass in your float as an argument. The function will return the integer equivalent of the float, with the decimal portion discarded, but without losing precision.

But its answer still presents a contradiction, as its solution is still discarding the decimal information while saying that it is preserving it.

Disadvantages

• It can produce completely wrong answers, so the user must have some level of knowledge to be able to filter down the wrong ones

• Can create a bad habit of just copying and pasting its answers, instead of understanding the why's

Advantages

• Free of charge

• Can be a very helpful assistant for developers, from begginers to experienced ones

• The experience is very close to having a human mentor

• Can understand most programming languages, libraries or frameworks

Final Thoughts

AI is not able to produce a beautiful app or a revolutionary startup just yet, but it can become a valuable tool in a programmer's tool box, just like Google or Stack Overflow. We can surely expect more mind blowing surprises from ChatGPT and its competitors in the coming years. The AI wars have just begun!

Have you tried ChatGPT? Feel free to share your impressions about it.

The Problem

I will be using Python in these examples, but most programming languages would yield similar results.

Let's calculate the total price for 3 burgers which costs $1.1 each:

burger_price = 1.1
amount = 3
total = burger_price * amount
# Expected 3.3, but got 3.3000000000000003 :(

What is happening here? This result would look awful on a shopping cart!

Even a simple addition leads to a strange result:

base_bonus = 0.2
additional_bonus = 0.1
total_bonus = base_bonus + additional_bonus
# Expected 0.3, but got 0.30000000000000004 :(

You might be thinking that the solution is really simple, just cut off after two digits!

total_bonus = 0.1 + 0.2
# 0.30000000000000004
corrected_total_bonus = round(total_bonus, 2)
# 0.3

That might work for something really simple, but if you keep making these floating point calculations and rounding off repeatedly, small rounding errors will accumulate and lead to a large calculation error. This will not be acceptable for an application that needs precision and also, rounding can lead to errors like this:

party_minimum = 5.0
party_result = 4.97
party_result = round(party_result, 1)
# 5.0
if party_result >= party_minimum:
    print('You can seat in the Parlament')
else:
    print('You cannot seat at Parlament anymore')

# You can seat in the Parlament

In German parliamentary elections, a party with less than 5.0% of the vote cannot be seated. The Greens appeared to have a cliff-hanging 5.0%, until it was discovered (after the results had been announced) that they really had only 4.97%. The printout was to two figures, and the actual percentage was rounded to 5.0%.

Disasters already happened due to float precision:

On February 25, 1991, during the Gulf War, a Patriot missile defense system let a Scud get through. It hit a barracks, killing 28 people. The problem was in the differencing of floating point numbers obtained by converting and scaling an integer timing register.

You can even fail a simple automated test and spend hours trying to figure out why:

assert 0.1 + 0.2 == 0.3
# Raises AssertionError!

Why does this happen?

Computers use zeros and ones to represent numbers. A bit can be a zero or a one. Modern computers usually use up to 64 bits to represent information, which means you can have up to 16 digits after the decimal point, which is a lot, but there is still a hard limit on the values that it is possible to represent.

As humans, we can easily understand the concept of 0.1. It is one tenth of something or 10% of something. But computers using zeros and ones will represent 0.1 as:

0.0001100110011...

In which the 0011 part will be repeating infinitely.

But a 64-bit computer will cut the repeating part, so it will have just 16 digits after the decimal point. In this process of cutting to the allowed precision digits, it loses precision. So 0.1 that was fitted into 64-bit data will be just close enough to 0.1.

If we reveal the 20 digits that follow the decimal sign in a float:

decimal_one = 0.1
print(f'{decimal_one:.20f}') # 0.10000000000000000555
decimal_two = 0.2
print(f"{decimal_two:.20f}") # 0.20000000000000001110

We can see that we are indeed getting only the approximate value of a decimal number. And that is why you can see those unexpected results using floats.

Solution 1: Use the Decimal module

Python has a module called Decimal and it behaves like how a human would do Math:

from decimal import Decimal

burger_price = Decimal('1.1')
amount = 3
total = burger_price * amount # Decimal('3.3')
print(total)
# 3.3

Note that it is possible to do Math operations with those Decimal objects:

Decimal('0.1') + Decimal('0.2')
# Decimal('0.3')

When creating Decimal objects, the float value should be passed as a string, otherwise, you would suffer again from precision issues that we wanted to avoid:

Decimal(0.1)  # Decimal('0.1000000000000000055511151231257827021181583404541015625')

Decimal('0.1') # Decimal('0.1')

When creating Decimal objects, it is possible to customize the level of precision, rounding rules, etc.

Solution 2: Use integers

It is possible to use integers to store the values and do the calculations. Only when there is a need to show the results for a human it would be divided by 100:

burger_price = 110
amount = 3
total = burger_price * amount # 330
print(total/100)
# 3.3

This way will keep us in the safe realm of integers.

The downside is when calculating a number with a large number of digits. Float is represented as scientific notation so it is fast doing calculations, but using integers expect slower speeds.

Hope you find this article useful and happy decimal calculations!

In CS50 there are many courses and one of them is Introduction to Artificial Intelligence with Python, or CS50AI, which is indicated for those who managed to finish Introduction to Computer Science (CS50X) or have 1 year of experience in Python and want to have a general understanding of what is Artificial Intelligence (AI). CS50AI gives you a certificate issued by the CS50 institution for free if you manage to complete all the projects, and there is also the possibility of paying for the certificate provided by Edx or acquiring a professional certification, which includes other CS50 courses, but honestly only the CS50 certificate is enough.

What is needed before starting the course?

- [ ] Know advanced math or statistics

- [ ] Have excellent grades in math

- [ ] Be a genius

- [x] Be comfortable with Python so you don't have to learn two things at once

- [x] Be resilient and always be willing to make an effort to learn

- [x] Know English, as the course is entirely in English

In 2021 I managed to finish the course, after completing the CS50X and Introduction to Web Development (CS50W) and I will tell you... it was INTENSE! :cold_sweat: :cold_sweat:

Following the CS50 tradition, CS50AI is difficult for those who have never had contact with the subject of AI, but with effort and dedication, you can finish it. In all courses, they aim to make you "comfortable with discomfort", that is:

Even if you feel helpless and confused when faced with a problem that you don't know how to solve immediately, the idea is that everything is fine and eventually you will be able to arrive at a solution, which is the representation of the day-to-day life of many programmers.

What will I learn in CS50AI?

The CS50AI is divided into 7 modules, which are the main areas in the field of AI:

1. Search: Finding a solution to a problem, such as a navigation program that needs to find the best route from source to destination

2. Knowledge: How to represent information and draw inferences from it

3. Uncertainty: How to handle events that have uncertainty using probability

4. Optimization: Finding not just the right way to solve a problem, but better ways, or the best way, to solve a problem

5. Learning: Improve performance by having access to data and past experience. For example, your email can differentiate spam from past experience.

6. Neural Networks: A structure inspired by the human brain that can efficiently perform tasks

7. Language: Process natural language, which is produced and understood by humans

All modules have a long and dense class, of about 1h30, which must be rewatched whenever there are doubts. Then there is a not-so-easy quiz on the topics covered and finally, one or two projects, which must be coded by the student and sent via Git to the course repository.

Each project is tested to verify that the student's code meets all requirements and is then approved or rejected. It is possible to resend a project as many times as necessary and whenever the project is disapproved, a small note of why it was rejected is also sent.

It's amazing to see how the CS50 team managed to give opportunities for all students, even those who are not paying for the certificate, to be able to code their projects and still receive feedback, even if limited. I noticed that many of the projects are corrected by humans, probably Harvard students, as it is not possible to automate certain assessments and the only way to check the final result is to watch a video recorded by the student, showing how the final solution behaves. I imagine the amount of work this must take and only a giant institution like Harvard can make it available worldwide for free to any student.

What is it like to take the course?

In short, the course is DIFFICULT. It's made for the elite American students, so it is blood, sweat and tears from beginning to end:under::under:

In the second project, the game of tic-tac-toe, I was stuck for a good few weeks, because my version was very slow and I wanted to implement a solution that made the AI to be more efficient and faster when making moves. It didn't help that I got confusing feedback about what was wrong with my code, something like "your AI's movement patterns are inconsistent". After taking a sabbatical from the course, I took a few days to rethink the problem and managed to move forward:grinning:

What is most required to complete the projects is time and dedication to completely understand the content shown in the video, in addition to reading the documentation in modules that introduced tools related to AI and also taking the time to research any errors and bugs that appear along the way.

What did I learn at the end of CS50AI?

What was very rewarding was going from a superficial view of what AI is to a very solid understanding of what an AI problem is, what kind of strategies can I use to solve a problem and what tools are available to help me.

The course demystified some myths, such as having to know a lot of Math or statistics to create a solution that uses AI, as there are already tools and frameworks that do most of the heavy lifting, such as neural networks already trained for certain tasks. The developer should see the problem from a more macro perspective: finding a problem to be solved, thinking about the best solution, connecting the parts and refining the process to have the best final result. Mathematics and statistics are important for the area, especially for those who do research and develop AI related tools, but it is also possible to use AI as a framework and not get involved with lower layers of abstraction, as when someone uses a web framework or a module that makes the developer's life easier: it is not necessary to understand what is behind it to be able to use and benefit from it.

The course introduces you to tools that are part of the toolkit that is commonly used to work with AI:

• Scikit-learn: Machine Learning tool for data analysis

• TensorFlow: Used to create neural networks capable of classifying images

• NLTK: Tool to analyze human language

I was very proud of several projects that I managed to complete, in particular, three of them:

1. When I created an invincible tic-tac-toe player

2. When I created a crossword puzzle generator that creates a crossword puzzle only using a list of words as input

3. When I created an AI that can play minesweeper

Final thoughts on the CS50AI

I recommend the course to everyone curious about AI, but never had the courage/opportunity/guidance to start studying it. It's an area with tough problems, many still unresolved, so don't expect a smooth, stress-free journey.

On the other hand, solutions that use AI leave non-technical persons and programmers awestruck. It's amazing to see behaviors that human beings deem to be "intelligent" being done by programs and electronic devices:alien::alien:

Only a small portion of the problems and potential areas of AI have been explored, which is an incredible opportunity for those who possess the knowledge, not only about training and building an AI but also identifying situations that could benefit from it! Imagine what could happen if all cameras could analyze images like humans or if computers could understand a person's mood from what they say and write.

Good journey and happy learning!:smiley:

On the other hand, many problems already have been solved by others and we should take advantage of this fact. We use modules, frameworks and higher-level abstractions built by others to make our lives easier, be able to make more with less time and be free to focus on solving our unique problems.

More code, more problems

I have heard and seen many cases where small and medium businesses, when confronted with a problem that can be solved with technology, choose the path of hiring a developer or a software company and embarking on a journey of building the solution themselves, instead of searching for a service provider or a platform that could provide a ready-made solution.

For a business that is not tech-centric, deciding to build the code themselves, usually means a lot of time and wasted money.

In Science, we stand on the shoulders of giants to take one further step ahead. The first step in scientific research is to search for work that already has been done in a particular field of study, so it is possible to improve or extend the existing knowledge.

Especially in startups, we should take a similar approach to one taken by Science, by searching for solutions that already exist, instead of immediately proceeding to build our solution. This allows us to:

Go to market fast.

Instead of waiting for an application to be planned, created, and tested, use a solution that is ready to be used and was proven both by tests and real-world usage.

Avoid common pitfalls that can eat a lot of time and money

Not many understand how hard is to build something, as it is not only a technical challenge. When creating something new, there should be considerations on the market, its users, usability, and costs, just to cite a few. Even if it is a technical product, a developer will feel overwhelmed, as skills like design, entrepreneurial skills, and user interface are necessary to be successful. It is possible that many iterations are necessary before finally reaching the desired result and those take a lot of time.

Change fast

As a new business, the initial assumptions can change dramatically. It is easy to unsubscribe from an online platform, but it is painful to throw away months of developer work, as well as time, and resources that were invested in it. This can lead to a situation where a business continues to invest in a failing strategy because it does not want to lose the resources already invested.

You cannot ask for a refund from your developers if your product is not what is needed by your customers.

Delegating maintenance and improvements to someone else.

Not many entrepreneurs realize that a website, platform or tool will need constant improvements and fixes throughout its lifetime. If developers build an e-commerce website, it will have the requested features, but as time passes, an integration to marketplaces will appear to be necessary to increase revenue and analytics will show that a shorter sign-up process will decrease cart abandonment. None of that was considered when building the first version of the website and that is expected as no one can predict the future. When using a platform, for example, these needs have been already addressed, as they listen to the needs of thousands of customers and already have iterated their product thousands of times.

Common problems, such as selling over the Internet, building a business website or storing files are so common that large platforms already exist to solve problems for millions of users. They usually provide customization so they can serve a large number of use cases and it does not make much sense to build a custom solution unless you have a very specific problem that cannot be addressed by these platforms.

A personal example

When I was building my startup, we needed a platform to connect end customers with service providers, a typical marketplace. So we were confronted with two options:

1. Hire developers to build the platform with everything we thought we needed. It would have taken 5 months to make a functional version and it would eat months of resources that would give more months to our startup to stay afloat.

2. Use a platform as a service. It did not have all the necessary features that we needed, nor would give the best user experience, but it could work. We would pay only the monthly fee to them and could cancel anytime.

I am glad that we chose the second option, as we discovered a few months after that we needed to pivot our business strategy from B2C (business to consumer) to B2B (business to busines), focusing more on serving business than end-consumers, as serving businesses has lower customer acquisition cost, operational costs were far lower and we generated more revenue. We avoided the difficult decision of throwing away time and money directed toward end users, as I could simply cancel our subscription to the platform when the time came and that was as easy as canceling a Spotify plan.

The background

Since 2019 I have been rustling to become a developer and not any developer, but a self-employed one. It is not the easiest nor the shortest path, since I majored in Psychology and never excelled in hard sciences, but I have been enjoying the learning process and overcoming the hurdles. I have been self-studying and this has many advantages, such as:

• Learning at a fast pace: No bullshit, gets directly where I want to go:rocket:

• Becoming more independent and self-motivated: I am the only one responsible for my learning:muscle:

• Learning exactly what I want or taking the time to go deeper into a subject: Makes the act of studying very enjoyable and interesting:smiley:

• Be able to experiment different paths and plan my career:chart_with_upwards_trend:

• Have a deep understanding of a subject instead of just studying to pass a test and forgetting everything months later:books:

• Study for free or very little cost: There are tons of free, high-quality materials for self-study and many high-quality courses that are much better than an actual university class and cost nothing or just a few dollars:moneybag:

But also has many disadvantages:

• Easy to be distracted by life: Creating and maintaining the habit of studying and practicing every day is mandatory for self-study:persevere:

• Difficult to be held accountable for progress: No lectures to attend, no hard deadlines for delivering projects:date:

• Progress is not being validated by peers or teachers:100:

• Impostor Syndrome can creep in, as there is no external validation, like diplomas, grades or certifications:confounded:

I had a hard time achieving flow in 2022 as in my home I was getting constantly interrupted by ringing doorbells, noisy neighbors, dogs barking all the time, hunting mosquitos and sweaty, hot days. This improved when I started to go to public coworking spaces where I could work in a silent environment, without interruptions:relieved:

Why code?

In 2016 I have built a startup called Bike123 with a friend and ex-coworker. It solves the problem of finding a qualified mechanic that can fix your bicycle without the need of bringing it yourself to a bike shop. We did not have any background in tech, but we were very motivated and we had extensive knowledge of the bicycle industry. Turns out that trying to build a scalable startup without a programmer on the team is like running a marathon using only one leg: it is possible but will be hard:running::running::dizzy_face:

I was considering leaving the startup in 2018 when it became clear that it would be very hard to scale it in a way that could financially sustain ourselves and the final decision was made when my mother passed away unexpectedly, leaving a lot of unfinished issues to be solved, but I am still proud that I have helped to build a very lean startup that was validated as a business and it is still in operation to this day.

If you need to fix a bicycle in Brazil, you could consider checking Bike123's website to find a trusted mechanic that will fix your bicycle in no time.

Lesson 0: Failures are necessary for a journey

Looking back on what I did up to this day, the experience of running a startup without tech skills opened my eyes to a career in programming. I felt extremely handicapped and hopeless as most of the necessary improvements that our business needed were associated with technical skills, such as creating an API or eliminating manual work with technology and automation.

After researching more about the tech world, I could already envision building a small tech company that can sell services anywhere in the world, without the need for spending capital to buy goods or store them. If needed, the company could be incredibly lean and have one or very few team members that can leverage technology to get to millions of customers.

That thought lead me to try to start some small online programming courses. I liked the experience and slowly I devoted more and more time to learning about algorithms, JavaScript, Python, and enrolled in CS50, until I was devoting my full-time to learning programming.

Lesson 1: Body and mind are one

Fast forward to 2022 and my body was tired after so many years and months of Coronavirus, sitting down all day and maintaining social distancing. Especially my lumbar was killing me, I could barely sit for a couple of hours without pain. On top of that, I got my first corona infection in January and felt sick for many weeks. My father was just diagnosed with prostate cancer and a decision was needed regarding what treatment to take, so I had very little time to exercise and was not sleeping well at all.

Those were very stressful months and as a result, I was not able to think right, let alone have new ideas or be creative. Coding was a frequent struggle and I felt that for every new concept that I managed to learn, another one that I have already learned was being forgotten. I was constantly forgetting common words and had a hard time recalling things that I have done.

My body was not well and this reflected in my ability to do intellectual work.

Lesson 2: Diversity brings creativity

In April, I was worried about my dwindling mind and noticed that my weekly routine barely changed. I stayed home most of the days, chatting only with my girlfriend and going out to the same places. To counter this, I started to actively seek new experiences, such as:

• Seeking friends that I haven't seen in a long time

• Going to places in the city that I haven't been to for a long time

• Going to art expositions

• Studying in libraries and going to a coworking to see new faces

• Trying foods and new places for the first time

After some months, I slowly began having new ideas and even started writing again, a habit that I have distanced myself from. This leads me to start this very blog on Hashnode.

And by reconnecting with friends, I got a freelance job! A friend needed help replacing a buggy scheduling tool with better usability for his business. I was glad that I could solve a problem that would make a difference for his business and this experience made me think about what can I do to help small businesses like his.

Lesson 3: Take it as medicine

When (re)starting a new habit outside the comfort zone, inevitably there will be resistance in form of laziness or well-thought excuses. I used to cycle a lot, meaning +150km a week, but with the pandemic, I was using a static roller and was only doing 3 times a day, meaning 30km a week at best. This is more than the average person rides, but it was not enough for me. As a result, I got a couple of kilos and my skills and reflexes on a bicycle greatly decreased.

I wanted to start cycling with my friends, but I have to admit now that I was fearful and insecure, so I made excuses in form of "I think cycling is kinda dangerous" or "I need more free time to dedicate to that".

One day I remembered something my father used to say when I was little and I was refusing to eat greens:

You don't have to enjoy it, take it as a medicine

So I just did it, I took cycling as medicine for countering back pain and my extra kilos. On the first rides, it tasted like a bitter pill. I was fearful, my back hurt, and my body was protesting. At first, it was bad, but then I felt good. Today I am glad that I took the medicine, my lumbar is almost cured and I feel much better about myself and my progress.

This is me, in a hill climbing race, organized by my cycling club. I managed to get a third place!

Lesson 4: One step a day makes you go farther away

In school or university, there is a tendency to work in bursts. Like studying for a test, the test has a deadline, so the students will have a week or some days of intense work, which culminates on the day of the test. After that, most of the students will not touch a book until the next exam.

In the real life, things are not like that. The path to becoming a good programmer does not involve taking tests and studying the bare minimum to pass them. When learning to drive a car, for example, the key is to practice a little every day, feel the feedback from the pedals, noises and vibrations, and not pass exams about how to drive a car.

This year I managed to code almost every day, some days I was very productive, and others were a struggle, but I did it, nonetheless. Just like climbing a high mountain, at first, the progress is negligible, but after some time, you forget about the progress and just enjoy the adventure. You finally reach a clearing and it is possible to see that you have climbed a lot and you see for the first time the path you have taken from above. It is very rewarding, but it only comes after a long effort.

Lesson 5: Build your toolkit and your specialty

As a freelance programmer, it is not productive to try to adjust your skills for every customer's demand. When I started freelancing I tried to grab every opportunity that I assumed that I could deal with my skills. Wrong! This resulted in long hours of research, frustrating problem-solving sessions and stressing out, as the deadline was approaching, but in the end, I was getting very little money for all that effort and I was not satisfied with the final product. This article explains more why you should focus on a niche segment, instead of trying to serve everyone:weary:

If you are a freelancer, think about yourself as a restaurant. Have you ever seen a place where you could sit and ask anything you like? A place where you could order a burger or some sushi or maybe some french food. I doubt it.

That happens because it is uneconomical to do so. Yeah, everything is under the umbrella of "cooking", but the cook has to dedicate himself to some genre of cooking, otherwise:

• his dishes would be terrible as he would not get enough time to get good at making a particular dish

• he would take a long time to make even a simple dish as there is no way to make preparations beforehand

• there will be a lot of wasted ingredients that would not be used and would spoil

So why programming would be any different? Find a niche, build a product using a tech stack you are comfortable and serve a large range of customers without changing too much from your basic product template. That will be the path to making a sustainable business

In 2022, to consolidate my tech stack, I decided to go all in on:

• Python, which I find clean, flexible and enjoyable to work with:snake:

• AWS, which allows me to launch projects at a low cost and in a scalable way:arrow_double_up:

• AWS Chalice, which allows me to glue together my business logic and AWS services, such as authentication and database:stuck_out_tongue_closed_eyes:

• AWS CDK, which allows me to call my complete infrastructure stack with a single command:smile:

Closing thoughts

This year I am becoming more confident in my developer skills, as I have expanded my programmer toolkit and, as a result, can take a variety of jobs. Also, having more experience freelancing, I can avoid common pitfalls, such as creating an application from scratch that has a low probability to be reused.

Another good news is that my father is cured of cancer, having been treated with radiotherapy and hormone therapy and having no lasting side effects at all. If you know someone that has been diagnosed with prostate cancer, be sure to get as much information as possible to be able to help them make the best decision. The Prostate Cancer Research Institute helped us a lot, be sure to check their Youtube channel.

I think I am slowly returning to my pre-pandemic performance and I feel that body, mind and habits are set in a way that 2023 will be a much better year.

This was Dev Retro 2022!

Achievements

• My article about hosting personal projects for free using AWS got featured on Hashnode!

• Passed AWS Cloud Practitioner certification! Check my blog post about the experience

• Built a scrapper that tracks prices on e-commerces, so you can get a nice deal. You can use it too and make pull requests, check it on my GitHub

• Completed Harvard University's course in Python. Check out my review of it

Companies like Amazon, Google and Microsoft spend huge amounts of money buying computers and infrastructure to power their numerous digital services. One day they realized that it is possible to sell some of their unused computer capacity to other companies, so they can earn more while providing an invaluable service to companies that are not tech-centric or do not have pockets so deep but need to offer digital services or rely on them to maintain their operations. Think about Coca-Cola, the BBC TV or the Government.

When a company ditches its in-house servers and moves to cloud-based services, it gets rid of many pains, while getting many advantages over competitors:

• Avoid the hassle of buying and managing expensive servers

• Do not need to hire expensive employees to take care of their servers

• Avoid having expensive servers that most of the time work below 20% of their total capacity

• Avoid having expensive downtimes and poor user experience during peak time due to insufficient server capacity

• Can react to sudden changes in demand. You can add more cloud servers at any time, but you cannot do the same with in-house servers that need to be bought, configured and maintained. Think about peaks in e-commerce during Black Friday sales

• Developers can focus on the business part of the application, avoiding undifferentiated work, like applying updates, checking the health of servers or managing backups

For a startup, cloud services are even more important:

• Do not need to commit huge amounts of cash before starting the business. They can pay for what they use in a gradual manner

• Do not need to guess what will be the demand for their servers

• Can deploy an entire infrastructure very fast, with some mouse clicks or a simple command in a terminal

• One single developer can manage a complex infrastructure

Why have a certification?

Currently, there are more than 300 services on AWS and the number keeps growing. Their combined documentation has thousands of pages so it takes a great deal of time and effort to learn the inner workings. So, while knowledge of cloud services is in high demand, it is difficult to assert the level of knowledge a person has. Certifications can fix this issue, by attesting that a developer has a good understanding of a particular field in the cloud.

For me, having a certification is important because:

• Many job postings have AWS as a requirement and a certification is an important differentiator

• As I am doing freelance work, my customers can rest assured that I know AWS services

• It is a good opportunity to do an in-depth study of the AWS services otherwise, I would not be so keen to go deep into the AWS ecosystem

Why I chose the Cloud Practitioner certification?

There are many certifications to choose from and they are divided into levels, from generalist to specialist:

• Foundational

• Associate

• Professional

• Specialty

Cloud Practitioner certification should be your first certification, as it is situated at the Foundational level and evaluates the general understating of AWS, without going too deep. Other certifications assume that you are specializing in a role, such as:

• SysOps

• Networking

• Data Analytics

• Database

• Machine Learning

• Security

• SAP

How I prepared for the exam

The Cloud Practitioner certification exam asks for a general understanding of AWS and its most important services, so they will not ask for coding a solution or open-ended questions, just multiple-choice questions, but do not be fooled: it is not an easy exam. Some questions are tricky as they thoroughly test if you have a good grip on the topic or just a shallow understanding.

I am not a fan of buying courses and I don't find it necessary at all to pass the certification exam. There is plenty of content on Youtube and AWS Skill Builder. I would recommend reading the Cloud Practitioner exam page, carefully reading the exam guide and studying each of the required topics. There are many things to study and you could feel overwhelmed, but keep in mind that they will always ask for general understanding, not specifics. I studied every day for about 3 weeks and I learned the most when doing hands-on tutorials and trying to get the bigger picture instead of trying to memorize names or parts of the documentation.

AWS Skill Builder is a great tool for learning, unfortunately, it is not easy to use, as most of its valuable free courses are hidden by paid courses. Here are the most helpful ones I completed for my preparations for the Cloud Practitioner certification:

• AWS Cloud Quest: Cloud Practitioner (a nice 3D game for learning AWS)

• Exam Prep: AWS Certified Cloud Practitioner (CLF-C01

• AWS Certified Cloud Practitioner Official Practice Question Set (CLF-C01 - English)

• AWS Cloud Practitioner Essentials

The exam day

I was a little skeptical of the seriousness of the exam, as I opted for the online version. Do they care about my ID or if I am possibly reading the answers in another browser tab? I wondered.

Yes, they care.

I got into my first trouble when I tried to log into the exam page at the scheduled time. Before taking the exam it is necessary to install proprietary software that blocks others browsers during the exam. Although I tested beforehand if my Ubuntu laptop would meet the requirements of the exam, the link for installing the software was not working, despite changing from Firefox to Chrome. I changed to a Macbook and managed to complete the installation of the software.

The second trouble happened when they wanted to check my ID. My bedroom does not have good lighting and the examiner could not read my ID data. After more than 30 minutes of struggle, I got redirected to technical support. Luckily I managed to get more lights into the room and another document and they managed to

Some tips for the exam:

• Be well-rested and have a good night's sleep

• Make sure that the name you used to register on the AWS Certification website matches the name on your ID

• If you chose the online exam option, pick a location and time with no chance for interruptions or background noise

• Be in a well-lit room and use a good-quality webcam

• Have at least two types of identification documents. Make sure both are in good condition and legible when using your webcam

• They will ask for moving your webcam to check if you are the only person in the room or if you have study material on your desk or below it, so organize your desk and room before the exam for the process to go smoothly

The day after

Having passed the certification I received some perks:

• Access to AWS Certified Global Comunity, where other people who managed to get certified can connect

• Access to AWS Subject Matter Expert, where you can help create and validate questions for AWS Certification exams

• Access to AWS Certified Store, where you can buy AWS Certified goods

• A digital base that can be shared on social media

• A 50% discount voucher that can be used in any other exam

Next steps

As I am a web developer, I plan to get to the Associate level, by going after the Developer Associate and the Solutions Architect Associate certifications, as they are a perfect fit for my current role. In the long term, I would go for the Database Specialty certification, but other certifications would go way off course.

I will keep you updated about my progress and happy coding!:smiley:

• Reliability first. I want to sleep well at night and not worry if my applications are down because of an unstable cloud provider

• Use managed services instead of DIY solutions, so I could focus on my code. Instead of being dragged down by a lot of manual labor and spending a huge amount of time doing things like applying updates to my server's OS or doing manual backups of my database, I would rather think about the problem that I am trying to solve and the code that is unique to my application

• Have the lowest cost possible, as I live in Brazil and paying in dollars really hurts my wallet

• Use industry standards. I do not want to invest my time learning about platforms that are only used by hobbyists or a small niche, I would rather learn a single platform that could be used to power either a simple personal project or a large, enterprise-grade solution

• The solution should be able to do back-end tasks: it should be capable of doing authentication, user sign-in/sign-up, a persistent database for storing user data, as well as static page hosting and be able to create APIs with ease.

A little surprise

So I looked over the cloud provider options and all of them offered similar services. AWS has the largest market share, so it was the natural first choice. At the very basic, I needed a place to run my server code and a database. On the server hosting, I could get going for a fully managed solution like AWS Lightsail on containers for $7/month.

On the database side, things did not look great. Even if I start with a single project with very little database use, the cheapest AWS RDS instance would charge about $30/month. Another option would be the managed database provided by AWS Lightsail, resulting in a $15/month cost.

Still, I would have to spend at least $22 per month. Some of the readers from developed countries may find it strange that I making a big fuss over 20 dollars, but here in Brazil, it is expensive, especially when those are only experimental projects with no plans in the short term for revenue. On top of that, it is not even an ideal solution, as most of the time the database server would be sitting doing nothing, meaning wasted dollars. And it is not very scalable either, as spinning another project using the same kind of resources quickly adds more dollars to the monthly cost.

Going serverless

Going back and forth in AWS Pricing Calculator, I discovered that serverless services are mostly free when there is only light usage (thanks to their Free Tier) and, even with some respectable loads, they are very inexpensive, meaning a monthly cost that wouldn't top the $5 or $10 mark. On top of that, those are managed services, meaning I would only focus on code that matters to me, no time wasted managing or monitoring the infrastructure.

Before continuing, I would like to clarify that serverless is not a type of service that does not use servers, but rather a totally managed service, meaning that everything is taken care of by AWS: thinking about how to balance the traffic load between servers or to create a private network between a server and an API is not needed because AWS takes care of the servers, the overall infrastructure, the way it scales up or down, the way it handles traffic and other low-level configurations. In general, It is possible to create resources that would receive zero requests and would stay available for free or they can receive millions or billions of requests and AWS takes care of everything.

What if I use AWS services to replace my current web framework?

At a first glance, AWS services seemed to be a bunch of services that would need to be manually created, configured and connected together, going back and forth on their webpage. But going a bit deeper, it became clear that is not the only way that it is meant to be used.

AWS services can be used as an entire framework, like Django or Flask, and it may even be the next generation of web frameworks, so I would write application code in my favorite programming language and also infrastructure code, describing that I need authentication, API, storage, for example, and a very brief configuration for each of these services. Then I would be able to test the code, store it in version control and deploy all the infrastructure, back-end and front-end code using a single command. If I need to add a new service, it would be just like adding a new feature in my application code: change the code, test it, send it to version control and deploy it.

All of this is possible thanks to AWS CDK. It can generate AWS resources with very little code because it uses sensible defaults, so it is not necessary the describe all the details, like in AWS Cloudformation. CDK generates an AWS Cloudformation template, which is MUCH more verbose and has all the necessary details that are not specified in the original CDK code, then the template is used to deploy the services at AWS. Here is an AWS CDK code that is describing an API that uses a Lambda function to process the requests:

from constructs import Construct
from aws_cdk import (
    Stack,
    aws_lambda as _lambda,
    aws_apigateway as apigw,
)


class CdkWorkshopStack(Stack):

    def __init__(self, scope: Construct, id: str, **kwargs) -> None:
        super().__init__(scope, id, **kwargs)

        # Creates a AWS Lambda resource and points where the Python code is located
        my_lambda = _lambda.Function(
            self, 'HelloHandler',
            runtime=_lambda.Runtime.PYTHON_3_7,
            code=_lambda.Code.from_asset('lambda'),
            handler='hello.handler',
        )

        # Defines the my-lambda instance as endpoint for the API
        apigw.LambdaRestApi(
            self, 'Endpoint',
            handler=my_lambda,
        )

That's it! Deploying this code will result in a simple API being deployed, ready to receive requests. Doing the same thing on the AWS Console page would mean a bunch of clicking, scrolling, configuring all the permissions and doing all the work again for each different AWS region. In this example, all necessary authorizations for the services to interact with each other are automatically created and defaults are applied automatically if the developer does not mention it in the CDK code.

For those that are already familiar with a framework called Flask, a serverless AWS equivalent is available as AWS Chalice and is very similar to Flask in terms of syntax. By using it, it is possible to integrate authentication or a database as one would have done if using Flask, writing a line or two of code. The snippet below creates with a few lines an API with GET and POST routes that create Users and Profiles. Both routes use a database, provided by DynamoDB, and the POST routes use AWS Cognito to provide authentication and sign-in/sign-out flows:

import os
import boto3
from chalice import Chalice, CognitoUserPoolAuthorizer


app = Chalice(app_name='cdkdemo')
dynamodb = boto3.resource('dynamodb')
dynamodb_table = dynamodb.Table(os.environ.get('APP_TABLE_NAME'))

# Creates an Cognito Authorizer for the API
authorizer = CognitoUserPoolAuthorizer(
    'cdk-test-pool',  # Name of authorizer
    [os.environ.get('USER_POOL_ID')] # Gets User Pool ARN
)


@app.route('/users', methods=['POST'], authorizer=authorizer)
def create_user():
    """ Creates or updates a user in DynamoDB Table """
    # Gets json payload in request body
    request = app.current_request.json_body

    # Creates an item
    item = {
        'PK': f'User#{request["username"]}',
        'SK': f'Profile#{request["username"]}',
    }

    # Item is created or updated in database
    dynamodb_table.put_item(Item=item)

    # Return empty dictionary
    return {}


@app.route('/users/{username}', methods=['GET'])
def get_user(username):
    """ Gets a user from DynamoDB Table """
    # Creates a key to search for
    key = {
        'PK': f'User#{username}',
        'SK': 'Profile#{username}',
    }

    # Gets key from db
    item = dynamodb_table.get_item(Key=key)['Item']

    return item

AWS Chalice automatically creates everything that is needed for the application to run in the AWS cloud and can neatly integrate into AWS CDK. Sure, it is possible to achieve the same result using only Lambda functions, but it can make the writing of application code much more convenient.

Code Organization

Some of you could be wondering how to organize the infrastructure and the application code. Both should be part of the same repository and be separated into different folders, like in the example below:

├── infrastructure
│   ├── app.py #AWS infrastructure definitions are here
│   ├── requirements.txt #Requirements used by infrastructure definition
├── runtime
│   ├── app.py #Chalice code is here
│   ├── requirements.txt #Requirements used by Chalice app
└── requirements.txt #Contains pointers to both requirements

Each infrastructure and runtime should have its own tests, but they should share the same virtual environment. To install all dependencies you only use the root folder requirements.txt file, it only contains pointers to the other 2 requirements files.

Summing up

Learning and using AWS services has been a long journey for me. I had a fair share of frustration and despair when I came across unexpected errors and confusing documentation from AWS and it adds a ton of complexities over something like Heroku. Thinking back on what I have experienced so far, I could sum up a few downsides when working with AWS:

Cons

• Learning the inner workings of many AWS services and their relationships have a steep learning curve.

• It has a very different logic compared to traditional, non serverless frameworks that take some time to get used to it

• Vendor lock-in. Using multiple AWS services and investing time to learn them means that it will be harder to move to another cloud provider, also moving data and users that are already stored in AWS to other equivalent services could be very painful. Think about moving from Apple to Android or vice versa

• The costs of serverless can be high if the services are not configured properly and end up consuming more server time than they should or if they receive very high loads

• The AWS documentation, besides being bland, sometimes is outdated or is not very polished. Information about AWS Cognito, for example, is spread between different AWS websites: in documentation, CDK documentation and articles.

But the advantages outweigh the disadvantages:

Pros

• Serverless is a modern way of creating infrastructure with flexibility and low costs

• After overcoming the learning curve, it becomes easy to build or replicate complex infrastructure that has proven itself in production in very little time

• AWS services have seamless integration, especially if using AWS CDK

• Zero cost or little cost, but is able to respond to spikes in demand and manage huge loads

• AWS is used by many companies, has a large community and knowledge of serverless is in high demand

• AWS has plenty of free or paid learning resources like videos, tutorials and articles, created by AWS or other third parties

• Instead of paying a full salary for a DevOps or database specialist, you paid a little monthly fee for AWS that can be reduced or canceled at any time, no hard feelings

That's all for today! If you have some comments or questions, feel free to ask in the comments below.

As a developer, it's a common experience to be bogged down by syntax errors that could be very time consuming. Sometimes it's just a missing comma, a mismatched parenthesis or a simple mistype in a variable name that throws errors that are not always so obvious. Someone would say that such simple mishaps are very easy to debug, but it can be very frustrating if you are tired at the end of the day and end up being stuck for some minutes up to some days trying to catch a syntax error in a line that looks perfectly fine only to find out that the mismatched parenthesis that is causing the error is a few lines above. Being told to be more focused or cautious when writing code does not help, as we are not always in the perfect mood or energy level when coding. It would be perfect if every developer had enjoyed 8 hours of sleep, had some physical workouts before starting to code and have a calm, happy mood, but this does not happen very often in the real world.

Style stuck

Another point of frustration is following style guides that are certainly helpful and make your code cleaner, more readable and more professional, but are quite lengthy and they change depending on the particular language you are using, company that enforces them and even individual preferences step in. As someone who is learning a particular style, it is helpful if someone could point to us what parts of our code need more attention. By correcting our mistakes at the same time we write code, it is possible to gradually learn the new ways on the fly instead of simply reading the style guides, which is certainly uninteresting and unproductive, as most of the effort will be dissolved by our forgetful minds in the long run.

The Solution

I find surprising that I do not hear much about linters, especially when they can save countless of hours of debugging and rewriting code. Imagine writing a pretty complicated essay without the aid of auto-correct in your text editor. Sure, if you are a professional writer or someone who majored in English, you may think these kind of helpers as a nuisance, but for the rest of us, it surely brings some benefits. Linters are pretty much like the text editor's auto-correct, but key one difference is that they are not activated by default in the code editors and one linter only covers a particular language. You cannot use the same linter of writing Python and Javascript, for example. Having a fast feedback that highlights problems on the fly also helps the learning process as you don't have to run the code or rely on tests to receive an error. Also, using linters is the first line of defense for avoiding bugs, a complement of running tests.

My experience with linters in Python

There are many linters that could be used with Python, but two popular ones are flake8 and pylint. They not only pick style errors, but also anti-patterns like:

try:
  # Do something that could throw an error
except:
  # What to do if an error appears

Which could hide errors that are very difficult to debug, as the except will catch any kind of error, not only the error that you were thinking in the first place. This could lead to a situation where your except statement hides an unexpected error and causing strange behavior that does not raise an exception, instead of simply raising the error and prompting you to fix it. The code above can be improved by specifying the error type that you intend to catch and leaving other errors to appear:

try:
  # Do something that could throw an ImportError
except ImportError:
  # What to do if an ImportError is raised, other errors will still be raised

It is like having a mentor for yourself, pointing out what could be improved in your code and training you to be a better developer!

Closing thoughts

Do not despair if a linter throws a lot of problems the first time it is activated. It is not mandatory to solve every single problem, but it is worthwhile to take a look on the most urgent ones. The problems are categorized by importance, so a styling issue will not have the same weight as something that could prevent you code to run, like a module that does not exist, but it is being imported. You could also include linters in your CI process by using them to check your code before pushing new code to a repository. This will further guarantee the you can produce reliable code consistently and effortlessly, by using automated processes.

The difference between CS50X and CS50P

Being an introductory course, what differentiates itself from CS50X is that it is a "introduction to programming" not a "introduction to computer science", so it does not mess with pointers, file structure, memory management, data structures which are common themes in computer science. Instead, it focuses on core functionalities of Python language, like its syntax, loops, functions, data structures, classes and also features that almost always comes with the language like Object Oriented Programming, testing and regular expressions. It is intended for beginner programmers, those are making its first steps in Python or even those who have no prior programming experience at all. It will certainly be a challenge, but a doable one, if one takes its time.

The lectures

In 2022, partly due to restriction imposed by COVID-19, CS50's team decided to take a different approach in regards to the launch of the program. It has turned to a online only course, releasing the lessons in live videos on social media and by doing so, allowed viewers that are not students from Harvard to watch the lectures, ask questions and reply to the lecturer. It is a very innovative approach for a program still rooted in a traditional learning environment. This approach, although inclusive, was not free from shortcomings, as sometimes the student asking questions were inaudible or difficult to understand due to its English pronunciation. Sometimes their audio was choppy or they couldn't be heard at all. As the lectures will be edited before they are available in their final version, I believe most of these problems won't be noticed by future students of this course.

Problem sets

After each lecture, there is a opportunity to practice what was learned by completing a problem set. In the past programs, it consisted of one or two exercises, which were lengthy, required an extensive research and some hard work to pass all the required tests. When I was taking CS50X, despite being advertised as a beginner course, it was really challenging to tackle these exercises, even with the helper lectures and the possibility to ask for directions (not copy and paste answers) in the social media forums. On the other hand, I really learned so much by researching, learning from other sources and acquiring additional skills. But in the end, my feeling is that many students were lost to frustration, because of the steep learning curve. CS50P greatly alleviates this pain by having around five exercises in each problem set, the first requiring the basic concepts presented in the lecture in order to solve it and the others adding a bit more complexity in each step, which makes the learning curve more gentle. The subsequent problem sets uses the concepts from the previous ones, so it further helps to harden the freshly acquired concepts. Instead of the dull "find the prime numbers of X" or "sort this array" types of problem, there are fun problems, like a program that converts Bitcoins to US Dollars or converting regular text to ASCII art. It is quite difficult to design creative and engaging problems, while also making sure that the difficulty and the required skills are adequate to beginners, so thumbs up for the team! For the gran finale there is a final project that is about creating your own program that you can potentially share, so other programmers can solve problems or just have fun, complete with instructions, tests for ensuring reliability and with all requirements listed in a file!

Summing up

If you are new to Python, take the course. Even if you are in an intermediate level, you may learn some new things and have a great time practicing your skills. Don't rush for the certificate, trying to complete everything at the shortest time possible, instead take your time, do your research and try to learn as much as possible from the problems and the modules that are presented during the course. I am sure that it will be the foundational knowledge for any future developer that wants to solve problems with the Python language.