DEV Community: eric

How I would prepare for AWS Solutions Architect Associate again

eric — Tue, 28 Nov 2023 07:44:01 +0000

So you've decided to get AWS certified, great! Whether you're improving your cloud skills or learning cloud for the first time, this guide is meant to help you in your journey to getting AWS certified.

First, Take a breath-first approach by getting familiar with all the core services and know what they do on a surface level. For example, VPC(virtual private cloud) is your virtual cloud environment on AWS, EC2 - cloud compute, S3 - cloud storage and so on...
A good resource I found for this is Daniel Galati's video on AWS core services.

Now that you're familiar with an overview of AWS, take a practice test to gauge your understanding. During the test, you will come across new AWS services and acronyms that will be unfamiliar. The point of this step is not for you to pass,(fantastic if you do) but for you to get a sense of the material that the test will encompass. The practice tests I recommend are from Tutorial Dojo and Stephane Maarek's practice tests on Udemy. From my experience, both sources are harder than the actual exam where the Udemy practice test was more in line with the format of the real exam. Your first practice test should help you get your feet wet with the vast landscape of AWS services.

After your first practice test, go more in-depth on the core AWS services. An AWS service will usually have subcategories that you need to know. For example, gateway storage types: file storage, volume storage, and tape storage. Another example, VPC endpoints: gateway vs interface, their differences and when to use either. I would suggest focusing on security, performance, troubleshooting, and integration between AWS services. If you have the time, you should always be putting the theory of what you learned into practice with a free AWS account; provisioning services, and seeing how they run in real-time while maintaining best practices would be extremely helpful for first-hand knowledge.

After you have gained more in-depth knowledge of each core AWS service, it is time to take another practice test (or two). This time, you need to identify knowledge gaps that you are still missing. Resolving such knowledge gaps before the actual exam is key. Resources I recommend to achieve this include AWS docs, YouTube, bard/chatGPT, Google, and asking questions on AWS discords and slack communities.

Next, you should be ready for the official AWS skillbuilder practice exam. Unfortunately, the official practice exam requires a monthly subscription to the AWS skillbuilder. However, you can leverage their 7-day free trial period to enroll in the official practice exam and cancel your subscription before the free trial period expires. I would recommend scheduling your proctored exam a week or two ahead to get your desired time block.

⭐ exam pro tips:

Take a few seconds to quickly scan the answer set before reading each question. keep in mind the answers you scanned because you will pick up on relevant keywords and descriptions associated with the answer set while reading the question, making selection easier when going back to the answer set.
You can usually eliminate 2 answers right away after reading the question, giving you a higher probability of choosing the correct answer.
Use the exam marker function to mark questions that you don't know how to answer or questions that take longer to read and process. Skip those questions and come back after you have answered all other exam questions. An example of this could be multi-selection answers.

These are the steps I would take to prepare for the AWS Solutions Architect Associate if I had to start over. Hope this guide was helpful, Best of Luck! 🚀

JavaScript Callbacks, Promises, and Async/Await

eric — Sun, 19 Nov 2023 05:20:44 +0000

Asynchronous programming is a crucial part of JavaScript, especially in modern web development. These methods of asynchronous execution help manage concurrency by allowing asynchronous code to be written in a synchronous style.

Such features in JavaScript makes it easier to handle operations such as network requests and file transfers. JavaScript supports three different approaches for handling asynchronous operations: callbacks, promises, and async/await. In this blog post, we'll dive into each of these approaches, their advantages and disadvantages, and when to use them.

Callbacks

A callback is a function passed as an argument to another function, which is then executed when the task is complete. Callbacks are the most basic way to handle asynchronous programming in JavaScript. In this example, let's imagine getting a sudden craving for your favorite ice cream and you must go order it immediately.

function orderIceCream(flavor, toppings, callback) {
  console.log(`Ordering ${flavor} ice cream with ${toppings}`);
  setTimeout(() => {
    const orderNumber = Math.floor(Math.random() * 1000);
    callback(`Your order number ${orderNumber} is ready!`);
  }, 2000);
}

orderIceCream('mint chocolate chip', ['hot fudge', 'caramel'], (message) => {
  console.log(message);
}); 
// Ordering mint chocolate chip ice cream with hot fudge,caramel
// Your order number # is ready!

The example above takes three arguments: the flavor of ice cream, an array of toppings, and a callback function. The function logs the order details to the console and then simulates a 2-second delay using setTimeout. After the delay, we get a nice message telling us that our order is ready.

But what if you needed to order ice cream for a group of friends? What would the callback functions look like?

orderIceCream(<flavor>, [<topping>, <topping>], (message) => {
  console.log(message);
  orderIceCream(<flavor>, [<topping>, <topping>], (message) => {
    console.log(message);
    orderIceCream(<flavor>, [<topping>, <topping>], (message) => {
      console.log(message);
      orderIceCream(<flavor>, [<topping>, <topping>], (message) => {
        console.log(message);
        // ...and so on, with more nested callbacks
      });
    });
  });
});

Congratulations, you've created callback hell! This style of callback function - while still functional - is hard to read and even harder to maintain. 😭

Promises

To escape callback hell we can write the same function to order ice cream in a JavaScript promise. Promises provide a cleaner and more readable way to handle asynchronous operations than callbacks. A promise is an object that represents the result of an asynchronous operation. It has three states: pending, fulfilled, and rejected. Let's order our ice cream with a JavaScript promise:

function orderIceCream(flavor, toppings) {
  return new Promise((resolve, reject) => {
    console.log(`Ordering ${flavor} ice cream with ${toppings}`);
    setTimeout(() => {
      const iceCream = ['vanilla', 'chocolate', 'strawberry'];
      const orderNumber = Math.floor(Math.random() * 1000);
      if (iceCream.includes(flavor)) {
        resolve(`Your order number ${orderNumber} is ready!`);
      } else {
        reject(`Sorry ${flavor} is not available, please reorder.`);
      }
    }, 2000);
  });
}

orderIceCream('vanilla', ['chocolate chips', 'peanuts'])
// Ordering vanilla ice cream with chocolate chips,peanuts
  .then((order1) => {
    console.log(order1);
// Your order number # is ready!
    return orderIceCream('chocolate', 'caramel');
  })
// Ordering chocolate ice cream with caramel
  .then((order2) => {
    console.log(order2);
// Your order number # is ready!
    return orderIceCream('strawberry', 'whip cream');
  })
// Ordering strawberry ice cream with whip cream
  .then((order3) => {
    console.log(order3);
// Your order number # is ready!
    return orderIceCream('mint chocolate chip', 'sprinkles');
  })
// Ordering mint chocolate chip ice cream with sprinkles
  .catch((error) => {
    console.error(error);
  });
// Sorry mint chocolate chip is not available, please reorder.

In this example, the orderIceCream function returns a Promise object that will either resolve with a message indicating that the requested ice cream flavor is available or reject with an error message if the flavor is not available. The Promise is created using the Promise constructor, which takes a function as its argument. This function takes two parameters, resolve and reject, which are used to indicate whether the Promise should resolve or reject.

In the function, the setTimeout method is used to simulate an asynchronous operation that takes 2 seconds to complete. If the requested flavor is available, the Promise is resolved with a message that includes the flavor. Otherwise, the Promise is rejected with an error message. If the Promise is resolved, The then method is used to chain the Promises and handle the responses sequentially. If the Promise is rejected, the catch method will be called with the error, which is true for our last promise chain because they were out of mint chocolate chip 😢

Async/Await

What if there was a better way to write and chain promises and have the function execute in the background? Async/await is here to save the day 👐🏻, providing an even cleaner and more readable way to handle asynchronous operations than promises. Let's try ordering our ice cream with this new format:

function orderIceCream(flavor, toppings) {
  return new Promise((resolve, reject) => {
    console.log(`Ordering ${flavor} ice cream with ${toppings}`);
    setTimeout(() => {
      const iceCream = ["vanilla", "chocolate", "strawberry"];
      const orderNumber = Math.floor(Math.random() * 1000);
      if (iceCream.includes(flavor)) {
        resolve(`Your order number ${orderNumber} is ready!`);
      } else {
        reject(`Sorry ${flavor} is not available, please reorder.`);
      }
    }, 2000);
  });
}

async function orderIceCreamAsync() {
  try {
    const order1 = await orderIceCream("vanilla", [
      "chocolate chips",
      "peanuts",
    ]);
    console.log(order1);
    const order2 = await orderIceCream("chocolate", "caramel");
    console.log(order2);
    const order3 = await orderIceCream("strawberry", "whip cream");
    console.log(order3);
    const order4 = await orderIceCream("mint chocolate chip", "sprinkles");
    console.log(order4);
  } catch (error) {
    console.error(error);
  }
}

orderIceCreamAsync();

Wow, who knew syntactic sugar could make all the difference! 😍 From this example, the orderIceCreamAsyncfunction uses await to pause execution at each asynchronous operation and wait for it to complete before moving on to the next operation. The function returns a Promise that resolves with the final message when the ice cream is available, or rejects with an error message if the ice cream is not available. We get the same results without all the mess, such a great JavaScript feature!

Conclusion
In conclusion, JavaScript provides three approaches to handle asynchronous programming: callbacks, promises, and async/await. Callbacks are an antiquated and basic way to handle asynchronous operations, and can lead to callback hell. Promises provide a cleaner and more readable way to handle asynchronous operations, and they allow you to chain multiple Promises in sequence. Async/await simplifies the process of allowing developers to write asynchronous code that looks and behaves like synchronous code. This makes it easier to read and understand the code, and also makes it easier to handle errors and exceptions.

TLDR: use async/await

Hoisting Your Javascript Code: How to initialize your code 🧱

eric — Sun, 19 Nov 2023 05:16:49 +0000

Hoisting in JavaScript may seem like an intimidating concept at first, however, it is fairly simple to understand when explained. According to MDN (Mozilla Development Network), hoisting "refers to the process whereby the interpreter appears to move the declaration of functions, variables or classes to the top of their scope, prior to execution of the code". Here is my own definition of hoisting: enabling variable and function types to be accessible in your script before they are explicitly defined.

Since JavaScript is a non-blocking, single-threaded programming language that is executed from top to bottom, the order is relevant in which the code is written. In this article, we will explore how hoisting is applied to different types of variables, functions, and how it relates to the temporal dead zone.

Before we dive into hoisting variables and functions, we first need to understand the concept of the scope chain. To begin, the outermost scope is called the "global" scope. Variables and functions defined in the global scope can be called and accessed anywhere in your script. Next, we have the "functional" scope or the "lexical" scope as some may call it. Variables created within the function scope are only accessible within the function itself, and cannot be accessed by other functions outside of its scope. Lastly, we have the "block" scope, this scope refers to variables or functions created within conditional and looped statements (ie. if, for... etc) and can only be accessed within the code block.

Now that we understand the scope chain, let's examine how different types of variables (var, let, const) are affected by hoisting. The variable "var" is hoisted to the top of the scope chain. For example, if you were to define a "var" variable after a function that references said variable, it would return a value of "undefined". Although "var" is hoisted, the nature of "var" is a common source for errors in JavaScript. Therefore, modern JavaScript rarely uses "var", instead, we use "let" and "const" to define our variables. Variables declared with "let" and "const" are NOT hoisted, the difference being that "let" is mutable and "const" is immutable.

Hoisting also applies to JavaScript functions. A function declaration is hoisted to the top of the scope chain, and an arrow function or function expressions are NOT hoisted when defined with "let" or "const". It is necessary for function declarations to be hoisted before it is defined because various programming techniques, such as mutual recursion, require this behavior in order to be executed successfully. However, the best practices in JavaScript are to define a function or variable before calling it later in the code, even if it's a declarative function.

As stated, variables and function expressions declared with "let" or "const" are not hoisted in the scope chain. Instead, they are affected by the temporal dead zone or TDZ where their values become inaccessible from the beginning of the scope chain to where the variables are defined. For example, if we try to access the variables with a temporal dead zone blocking its value, we will receive an error stating the variables must first be initialized before they can be accessed. The temporal dead zone exists so that errors can be avoided and caught more easily.

In conclusion, JavaScript hoisting is the process of enabling variables and functions to be accessible before they are declared. The key takeaway here is that function declarations benefit most from hoisting in that it requires this kind of behavior to allow more intricate programming techniques to evolve. Now, whenever you receive an error of "undefined" or "cannot access before initialization," you will know the cause of the error.

An Intro to Recursion with JavaScript

eric — Sun, 19 Nov 2023 04:55:57 +0000

Recursion is a fundamental concept in computer science and programming that allows a function to call itself during its execution. It may seem like a simple concept, but the power of recursion lies in its ability to solve complex problems with elegant and efficient solutions.

The topic of recursion in programming can seem very daunting at first however, once you can follow a simple example, you can begin to see that it's not as bad as it seems. Recursion exists almost everywhere in common data structures. These data structures include trees, graphs, linked lists, heaps, stacks, and queues. In this blog, we will explore an introduction to using recursion in JavaScript and its many awesome benefits.

We're going to first begin by following a classic example of recursion, the mathematical factorial method. For example

!4 is the same as 4 * 3 * 2 * 1

This would be a perfect problem that can be solved by a recursive function. There are important factors to consider when constructing a recursive function, such as writing both the base case and the recursive case. Here are some tips to help you get started.

Base Case

Start by thinking about a condition when the function should stop calling itself and return a value. Then, think about the simplest possible input for the function, this will help to write your base case.

The base case should return a value that allows the function to complete the recursive process.

Test your function against the base case to confirm the desired outcome of your function.

Consider any edge cases and change your base case to handle them accordingly.

Recursive Case

The recursive case should take the larger problem and break it down into smaller sub-problems. It's important to identify the base case first so that you can figure out what the sub-problems will look like.

Determine the relationship between the larger problem and the smaller sub-problems. Once you've identified the sub-problems, you need to determine how they are related to the larger problem. This relationship will help you formulate the recursive case.

Make the recursive call for your recursive case. Every recursive call is the function calling itself within the function itself. Make sure to pass in the solution to the sub-problem that you've identified.

With the tips mentioned above, let's write our recursive factorial function!

function factorial(number) {
    // base case
  if (number === 0 || number === 1) return 1;

    // recursive case
  return number * factorial(number - 1);
}

Tracing the call stack we get something like this:

Great! now that you know the basics of recursion, let's apply it to something a little more useful. Suppose you wanted to flatten a nested object of data that you aggregated to build your app.

const cat = {
  breed: 'Siamese',
  age: 3,
  colors: {
    body: 'cream',
    eyes: 'blue',
  },
  personality: {
    affectionate: true,
    intelligent: true,
    independent: false,
  },
};

Let's take this nested object for example. How would recursion help you in solving the problem? What would be your base case and recursive case? Let's write our recursive function to flatten the object.

function flatten(obj, prefix = '') {
  const result = {};

  for (const [key, value] of Object.entries(obj)) {
    const pre = prefix.length ? prefix + '.' : '';
    // base case
    if (typeof value === 'object' && value !== null && !Array.isArray(value))     {
      // recursive case
      Object.assign(result, flatten(value, pre + key));
    } else {
      result[pre + key] = value;
    }
  }

  return result;
}

const flattenedCat = flatten(cat);
console.log(flattenedCat);

This example was a bit more complex, but the same principles we used to solve the first problem apply to this problem as well. First, the function works by looping over the object, iterating over each key-value pair. We then establish our base case to check and see if the argument is an object; if not, the function adds the key-value pair to the result object. Finally, we can write our recursive case by using object.assign to merge result with our recursive call flattenObject then returning result thus forming a new flattened object.

{
breed: "Siamese"
age: 3
colors.body: "cream"
colors.eyes: "blue"
personality.affectionate: true
personality.independent: false
personality.intelligent: true
}

Now that you know how recursion works by solving a real-world problem, you can teach your non-programming friends about recursion! 🥳

Overall, recursion is a powerful technique that enables elegant solutions to problems that involve repetitive patterns. With patience and practice, you can unlock the full potential of recursion and take your programming skills to new heights. 🚀