DEV Community: Tatyana Celovsky

Tell Your Story with GitHub Issues

Tatyana Celovsky — Wed, 24 Aug 2022 16:25:00 +0000

You may have heard of GitHub Issues, a built-in tracking tool that is available with every GitHub repository, but have you considered how helpful GitHub Issues may be when working on personal projects? Before starting a new project, you likely have at least a vague idea of what you want it to look like and what features you want to implement. It’s also likely that you do not have a particularly detailed step-by-step plan. This can sometimes result in frustration - you may have to start over a few times when implementing a new feature, or rearrange your project structure several times, just because a clear plan was not in place from the beginning. Sounds familiar? GitHub Issues can help solve these problems.

GitHub Issues is a tracking tool that is built-in with all GitHub repositories. Do not assume that the word “issue” here has a negative connotation, issues can be a good thing and GitHub Issues can be used to track and document every feature you want to implement in your project. Information included in each Issue can be as detailed or as high-level as you prefer. For example, one of your Issues can be “A user should be able to toggle between a list and a detailed view.” That may sounds simple enough, but GitHub Issues allows you to add as much or as little information as you’d like, so you may choose to specify exactly how you’d like the toggle button to look, what color the selected text should be, and any other details you’d like to include.

GitHub Issues is a great way to keep track of what features have been implements and what is still outstanding. For example, you can create a new branch for every Issue on your list, work on that feature, merge it into the main branch, and then close out the Issue. If you put down your project for a bit and then get back to it later, you’ll be able to quickly get up to speed on what features have been implemented and what else is still outstanding.

Lastly, GitHub Issues is a great way to tell the story of your project. You can plan out your Issues such that each one corresponds to a feature you want to implement and each new one builds on the previous Issues. The very first Issue you open in your project can be something very basic, such as “The name of the website should appear at the top of the page.” While the last Issue can signify the end of the project, for example, “The website should look professional and welcoming.” All the Issues in between these two will tell the story of how your project grew and progressed to the “professional and welcoming” final look.

GitHub Issues is an excellent way to keep track of your plans and can help “tell the story” of your project. GitHub Issues offers a lot of great features, such as the ability to create a new branch for every Issue, automatically close out Issues when the branch is merged, assign and re-assign Issues, search and filter Issues, etc. GitHub has an excellent guide that will help you get familiar with all the features and I hope you consider using GitHub Issues for your next project.

Let's Talk About Big-O - Space Complexity

Tatyana Celovsky — Thu, 06 Jan 2022 10:00:00 +0000

Photo by Sharon McCutcheon on Unsplash

Big-O notation isn’t something that we worry too much about while learning to code. After all, our primary goal is to learn how to code. It’s no secret that in programming there can be multiple ways to correctly do something, for example, in Javascript there are multiple ways to write functions (think arrow functions vs regular functions), and once we’ve mastered the basics, it’s time to focus on optimization. This is where Big-O notation will enter your vocabulary and you’ll want to understand what it actually is. This article is a brief introduction to the Big-O notation.

What is Big-O?

Big-O (pronounced “big-oh”) is a theoretical measure of the execution of an algorithm; it tells us how much time or memory is needed to execute a function when given the input of size n. In this case, n represents the number of items that will be analyzed by the given function and algorithm is the function itself.

Big-O notation is the language used to talk about how much time the algorithm takes to run (time complexity) or how much memory is used to run it (space complexity). In this article we are going to focus primarily on the space complexity. See here for the discussion on time complexity.

What is Space Complexity?

Space complexity of an algorithm refers to the amount of memory space required to solve the algorithm with respect to the size of the input. It is the memory required by an algorithm until it executes completely.

Similar to time complexity, space complexity is expressed in Big-O notation.

Big-O notation can express the best, worst or average-case scenario of an algorithm’s growth. However, as software engineers, we are primarily concerned with the worst-case scenario. We want to know the largest possible amount of memory space that will be required to run an algorithm with an input of size n.

The amount of memory space required to execute an algorithm is affected by all the variables, constants, inputs, data structures, etc., that are utilized in an algorithm. Please note that space complexity can be further affected by variables such as compiler, programming language and even the machine running the algorithm, but Big-O does not take these into account.

O(1) or Constant Complexity

Any variables declared within a function or passed into a function will always take up the same amount of memory space, even if they are later re-assigned. That’s because memory space for any given variable is allocated at the time it is initialized, so any change in the value of that variable does not change the amount of memory space allocated to it. This means that space complexity of constants and variables is O(1) or constant space complexity.

O(n) or Linear Complexity

Any arrays that are either passed to the function or built up within a function will require memory space to be allocated to each element in that array. This means that space complexity of an array is O(n) or linear space complexity, where n is the number of elements of the array.

Calculating Big-O

Remember that Big-O notation gives the worst-case scenario of an algorithm’s growth rate relative to the size of the input and does not take into account variables such as processors or language used to write the function. Similarly, Big-O is not concerned with any constants that may be a part of an algorithm as these make very little difference in the overall space complexity approximation.

O(1) or Constant Complexity

Take a look at the below code example:

Here we have three variables passed to the function, one variable initialized and then re-assigned within the function. Memory space is allocated at the time of initialization of our variable and the amount of memory space needed to later re-assign a value to it does not change. Therefore, space complexity of this example is O(1) or constant complexity.

O(n) or Linear Complexity

Take a look at the below code example:

Here we have an array passed to the function, one variable is initialized, then we loop through the passed array and re-assign the value of our variable. Memory space is allocated for each item of the array, space complexity of this is O(n), where n is the number of elements in the array. Memory space needed for initialization and later re-assignment of a variable is O(1), or constant space, as discussed above.

Total space complexity of the above example is O(n+1), but remember that Big-O is not concerned with any constants, so we drop the 1 and are left with space complexity of O(n) or linear complexity.

Space/Time Complexity Tradeoffs

How do we know when our algorithm is efficient? It seems the answer is simple: our algorithm is efficient when it is fast and takes up the least amount of memory possible. Unfortunately, in reality things are not so simple. Often times increasing speed will lead to increased memory consumption or vice-versa. Therefore, we should not aim for the best time and space efficiency, but rather find middle ground that will satisfy our requirements.

Conclusion

Having a good understanding of Big-O notation provides a more well-rounded context when designing algorithms. This article is only an introduction and if you’d like to read more on this topic, I would recommend Big-O Cheat Sheet and What is Big O Notation Explained: Space and Time Complexity

Resources

O(1) Example gist

O(n) Example gist

Let’s Talk About Big-O - Time Complexity

Big-O Cheat Sheet

What is Big O Notation Explained: Space and Time Complexity

Algorithm Series - Insertion Sort

Tatyana Celovsky — Wed, 17 Nov 2021 16:00:00 +0000

Photo by Dee @ Copper and Wild on Unsplash

This is a quick tutorial on the Insertion Sort algorithm and its implementation in Javascript.

What is Insertion Sort Algorithm

Insertion Sort is a sorting algorithm that places the element in its appropriate place based on the sorting order. A good example of Insertion Sort is sorting cards held in your hands during a card game.

Let’s take a look at Insertion Sort when trying to sort the elements of an array in an ascending order:

Assume that the first element of the array is property sorted;
Store the second element of the array in a key;
Compare key to the first element - if key is smaller that the first element, then key is placed in front of the first element;
Store the next unsorted element of the array in a key;
Compare key to the sorted element and place it in the appropriate place with respect to the sorted elements based on whether key is smaller or greater than each of the sorted elements;
Continue with steps 4 and 5 until all elements of the array are sorted.

The array is sorted when all the unsorted elements are placed in their correct positions.

Insertion Sort Code in Javascript

Let’s take a look at the code for the Insertion Sort algorithm described above (ascending order):

Insertion Sort and Big-O

Insertion Sort compares the adjacent elements, hence, the number of comparisons is:

(n-1) + (n-2) + (n-3) +…..+ 1 = n(n-1)/2

This nearly equals to n2, therefore Big-O is O(n²) or quadratic time. We can also deduce this from observing the code: insertion sort requires two loops, therefore Big-O is expected to be O(n²).

Conclusion

Insertion Sort inserts each element of the array in its appropriate place based on whether the array is being sorted in ascending or descending order. It is a simple way to sort a list when complexity does not matter and the list that needs sorting is short.

Resources

Insertion Sort Algorithm gist

Let’s Talk About Big-O

Algorithm Series - Selection Sort

Tatyana Celovsky — Wed, 27 Oct 2021 08:50:00 +0000

Photo by Jess Bailey on Unsplash

This is a quick tutorial on the selection sort algorithm and its implementation in Javascript.

What is Selection Sort Algorithm

Selection sort is a sorting algorithm that divides the input list into two parts: a sorted sublist that is built up from left to right and a sublist of the remaining unsorted values. The sorted sublist is placed at the front (to the left of) the unsorted sublist. Initially, the sorted sublist is empty and the unsorted sublist consists of the entire input list. The algorithm selects the smallest (or largest, depending on the ask) element in the unsorted sublist, places that element at the beginning of the unsorted sublist and moves the sublist boundary one element to the right (because there is now one element present in the sorted sublist, while the unsorted sublist became smaller by one element).

Let’s take a look at selection sort when trying to sort the elements of an array in an ascending order:

Set the first element of the array as minimum;
Compare minimum with the second element, if the second element is smaller than minimum, assign the second element as minimum , otherwise, do nothing;
Compare minimum with the following element, if that element is smaller than minimum, then assign minimum to that element, otherwise do nothing;
Continue step 3 above until the last element has been reached;
Move minimum to the front of the array and move the sublist boundary one element to the right (because there is now one element present in the sorted sublist, while the unsorted sublist became smaller by one element);
Continue with steps 3 - 5, until all elements are in their sorted positions.

The array is sorted when all the unsorted elements are placed in their correct positions.

Selection Sort Code in Javascript

Let’s take a look at the code for the selection sort algorithm described above (ascending order):

The above code sorts the array in ascending order. To sort an array in descending order, replace the “greater than” sign in the if statement with a “less than” sign.

Selection Sort and Big-O

Selection Sort compares the adjacent elements, hence, the number of comparisons is:

(n-1) + (n-2) + (n-3) +…..+ 1 = n(n-1)/2

This nearly equals to n2, therefore Big-O is O(n²) or quadratic time. We can also deduce this from observing the code: selection sort requires two loops, therefore Big-O is expected to be O(n²).

Conclusion

Selection sort finds the lowest value of the array and moves that value to the beginning of the array, it then proceeds to look for the next lowest value and moves that in front of the unsorted elements. This continues until all values of the array have been sorted; it is a simple way to sort a list when complexity does not matter and the list that needs sorting is short.

Resources

Selection Sort Algorithm gist

Let’s Talk About Big-O

Algorithm Series - Bubble Sort

Tatyana Celovsky — Tue, 26 Oct 2021 16:50:00 +0000

Photo by Pieter on Unsplash

This is a quick tutorial on the bubble sort algorithm and its implementation in Javascript.

What is Bubble Sort Algorithm

Bubble sort is a sorting algorithm that compares two adjacent elements and swaps them if they are not in the intended order (ascending vs descending).

Let’s take a look at bubble sort when trying to sort the elements of an array in an ascending order:

First iteration (compare and swap):
- Starting from the first index, compare the first and second elements;
- If the first element is greater than the second element, they are swapped;
- Compare the second and third elements;
- If the second element is greater than the third element, they are swapped;
- Continue the above process until the last element of the array is reached.
Remaining iterations:

Continue the same process for the remaining iterations, such that after each iteration, the largest element among the unsorted elements is placed at the end. In each iteration, the comparison takes place up to the last unsorted element.

The array is sorted when all the unsorted elements are placed in their correct positions.

Bubble Sort Code in Javascript

Let’s take a look at the code for the bubble sort algorithm described above (ascending order):

The above code sorts the array in ascending order. To sort an array in descending order, replace the “greater than” sign in the if statement with a “less than” sign.

Optimizing Bubble Sort Algorithm

In the code example above, all the comparisons between the array elements are made even if the array is already sorted - this increases the execution time. To solve this, we can introduce an extra variable called swapped. This variable can keep track of whether a swap occurs. If no swaps have occurred, then we know that the elements are already sorted and there is no need to perform further iterations. This will reduce the execution time and help optimize the bubble sort algorithm.

The above code will keep track of whether a swap was made in an iteration. If no swap was made, then we know that the array is sorted and we can stop the bubble sort.

Bubble Sort and Big-O

Bubble Sort compares the adjacent elements, hence, the number of comparisons is:

(n-1) + (n-2) + (n-3) +…..+ 1 = n(n-1)/2

This nearly equals to n2, therefore Big-O is O(n²) or quadratic time. We can also deduce this from observing the code: bubble sort requires two loops, therefore Big-O is expected to be O(n²).

Conclusion

Bubble sort compares adjacent items in a list and swaps them if they are not in the right order. It is a simple way to sort a list when complexity does not matter and short and simple code is preferred.

Resources

Bubble Sort Algorithm gist

Optimized Bubble Sort Algorithm gist

Let’s Talk About Big-O

Let's Talk About Big-O - Time Complexity

Tatyana Celovsky — Wed, 14 Jul 2021 10:00:00 +0000

Photo by Insung Yoon on Unsplash

What is Big-O?

Big-O notation can express the best, worst or average-case running time of an algorithm. However, as software engineers, we are primarily concerned with the worst-case scenario. We want to know the largest possible number of steps or operations that could happen for an input of size n. The time required to complete all steps or operations of a given function is proportional to the number of “basic operations” in that function. Here are some examples of basic operations:

one arithmetic operation (e.g., +, -, *).
one assignment (e.g. x := 0)
one test (e.g., x = 0)
one read (of a primitive type: integer, float, character, boolean)
one write (of a primitive type: integer, float, character, boolean)

Note that for the purposes of Big-O notation, the time it takes to run an algorithm does not equate to seconds or milliseconds. Instead, we think of time as the number of steps or operations that are needed to complete a problem of size n. This is because Big-O does not take into account variables such as processors or language used to write the function. Rather, Big-O notation helps us track how quickly the runtime of the function grows relative to the size of the input.

O(1) or Constant Time

Some algorithms perform the same number of operations every time they are called. For example, the basic operations described above require the same or constant amount of time to complete. Consider how easy it is to find your spot in a book if you’ve left a bookmark. Regardless of the size of the book it will always take you exactly one step.

O(1) simply means that it takes a constant time to run an algorithm, regardless of the size of the input.

In programming, a lot of operations are constant; here are some examples:

basic operations
accessing an array via the index
accessing a hash via the key
returning a value from a function

O(n) or Linear Time

Consider an example where we have to insert an element into an array. We would have to move the current element and all subsequent elements one place to the right in order to make space for the new element. The worst case scenario would be if we had to insert an element at the beginning of an array, because in that case all of the elements of the array must be moved. Therefore, in the worst case, the time for insertion is directly proportional to the number of elements in the array. We say that the worst-case time for the insertion operation is linear in the number of elements in the array. For a linear-time algorithm, if the problem size doubles, the number of operations also doubles. Therefore, O(n) means that the run time increases at the same pace as the input.

In Javascript, methods like forEach, map, and reduce run through the entire collection of data, from start to finish. They are good examples of linear-time operations.

O(n²) or Quadratic Time

Quadratic time means that the calculation runs in the time equivalent to the squared size of the input data. Here are some examples of the more basic sorting algorithms that have a worst-case run time of O(n²):

Note that in general, seeing two nested loops is a good indicator that the function has a run time of O(n²). Three nested loops would indicate a run time of O(n³).

O(log n) or Logarithmic Time

An example of a phone book is often used to describe logarithmic time. Let’s say you are looking for your friend’s phone number in a phone book. You know that your friend’s name starts with a letter “M”. You will likely open the phone book around the middle and see whether the names there begin with any letter that precedes “M” or any letters that follows “M”. Based on that, you will open the phone book closer towards the front or further towards the back and will, again, see if you’ve gotten close to the letter “M. You will continue performing these steps, and continue to decrease the size of the population by two, until you’ve located your friend’s name. Note that you will perform the same steps regardless of how large the phone book is (first open in the middle, then move towards the front or the back, thus decreasing the population, depending on how close you are to the desired value).

O(log n) means that the running time grows in proportion to the logarithm of the input size, meaning that the run time barely increases as you exponentially increase the input. Logarithm is the inverse function to exponentiation, it’s the power to which a number must be raised in order to get some other number. For example, the base ten logarithm of 100 is 2, because ten raised to the power of two is 100: log 100 = 2.

Calculating Big-O

Remember that Big-O notation helps us track how quickly the runtime of the function grows relative to the size of the input and does not take into account variables such as processors or language used to write the function. Similarly, Big-O is not concerned with any constants or operations that run in constant time that may be a part of an algorithm. Such operations make very little difference in the overall run time approximation.

O(n) or Linear Time

Take a look at the below code example:

Here we have two separate loops that are iterating through the length of an array (linear time). Each loop logs an item in the collection (constant time). As mentioned above, we are not concerned with operation that run in constant time. Therefore, we only have to take the two loops into account and add them to calculate the Big-O. This gives us O(2n), but number 2 is a constant, so we drop it and are left with the Big-O of O(n).

O(n²) or Quadratic Time

Now take a look at the code example below, it’s very similar to what we just saw, but here we nested our loops:

In this example of nested loops we are logging numbers[i] five times. To calculate Big-O here we have to multiply O(n) * O(n), because the execution of our log is dependent on iterating through the entirety of the second loop before we can increment i and move to the next index in our first loop. Thus, the Big-O in this case is O(n²).

The top portion of this function is the same as our previous example, we know its Big-O is O(n²). Then we may want to add O(n) related to the reduce function, which is linear. We get O(n² + n). However, Big-O is not concerned with non-dominant terms and because quadratic time is worse than linear time, we drop the second n. The final Big-O of the above function is O(n²).

O(log n) or Logarithmic Time

Take a look at this code example:

Here we are trying to locate number 128 in a given (already sorted) array. In the first iteration of our while loop, we split our data (the array) in half and call that point a pivot. We then check to see if the value in the array at pivot equals 128. If it does, we return a statement to say where the number was located. If it’s less than 128, then we change the value of our startIndex to the value of pivot plus one. That’s because if the value of pivot is less than 128, then we know that all of the numbers preceding pivot will also be lower than 128 (remember, the array has been sorted). If the value of pivot is greater than 128, then we change the value of our startIndex to the value of pivot minus one. This way we are able to halve our data.

We continue executing the above steps until we’ve found the number we are looking for or returned false to indicate that the number does not exist in the given array. With each pass we divide our data by two. Whenever you see this pattern of dividing the population or data by two, know that you are looking at Big-O of O(log n).

Conclusion

Resources

O(n) Example gist

O(n²) Example gist

O(n²) Example 2 gist

O(log n) Example gist

Big-O Cheat Sheet

What is Big O Notation Explained: Space and Time Complexity

Bubble Sort Algorithm

Insertion Sort Algorithm

Selection Sort Algorithm

Why Am I Here?

Tatyana Celovsky — Tue, 22 Jun 2021 17:00:00 +0000

“Why do you want to be a software engineer?” is not an easy question to answer. There are many reasons and they are different for each person. I wanted to share my reasons, consider this my Personal Statement!

I loved playing Battleship as a kid, but not the paper and pencil kind that dates back to World War I. I loved playing Battleship on a programmable calculator that my dad got me when I was seven. This little gadget could take in programs and produce results based on the information I provided to it. It came with an instructions booklet that contained a dozen programs and each had to be fed into the calculator, line by line, before any game could be played.

My favorite part of the process was spending 45 minutes to an hour programming a game before I could play it. If I made a mistake, I had to start over. Surprisingly, that made the process more interesting. I knew that I had to pay attention as the calculator could only perform the commands that I supplied. Therefore, the commands had to be logical, concise and, most importantly, accurate. I had no idea at the time that this was my first introduction to software development.

Fast forward about 20 years. I first heard of MOOCs (Massive Open Online Courses) when MIT and Harvard announced the creation of edX in 2012, a new open online course platform. The power of MOOCs is hard to deny, they bring education to the masses at low or no charge. By this time I was well underway in my career as a tax professional, working with interesting clients and solving issues related to optimal investment structuring and tax mitigation strategies. The news of edX creation planted a thought in my mind: there was a possibility to learn coding without going back to school and getting another degree. That was tempting.

I chose taxation as my career because it offers an opportunity to problem-solve within the given parameters of tax law. The law could definitely be dry, but the results are very real and tangible, primarily focused around increased returns on investment and reduced cash outflow (think paying less taxes). Attention to detail is important, as one word can often make a big difference.

I enjoyed working in my profession for the last 13 years. I spent the first seven years working at a large firm serving a diverse group of clients. I went from being an intern to leading my own teams that varied in size from two to twelve people. I ultimately decided to leave this firm and joined a smaller investment company that was growing its internal tax team. There I was able to focus on the needs of one company and really dive in and provide comprehensive tax advice that spanned multiple areas. I’ve been at this company for six years now.

I’ve learned a lot over the years working in a professional environment. I’ve developed relationships both inside and outside my organization and learned to utilize my network when I need some advice. I’ve learned to both be a productive member of a team and an effective leader. My current position requires frequent contact with company leadership, which can be daunting, but also exciting. I am close to the decision making process and am able to provide more tailored advice considering the interests of both the company and the shareholders.

All the while coding was in the back of my mind and every so often I looked at the classes available on platforms like edX and Coursera. This periodic search led me to the discovery of coding bootcamps that seemed to be popping up everywhere a few years ago. A restless mind is hard to tame and, upon some self reflection, I realized that I will not rest easy until I learn at least one programming language. That is how I ended up joining a self-paced software engineering program at the Flatiron School.

I wanted to ease into coding and a self-paced program provided enough structure and flexibility to do just that. The program wasn’t easy, but every time my code did exactly what it was supposed to do was terribly exciting! I was taken back to those days when, as a kid, I would spend hours playing with my programmable calculator. When the time for my final project came, I wanted to build something for myself.

One of my other passions is astrophysics and space exploration and with the number of private rocket companies increasing around the world, I found it difficult to keep up with all the rocket launches. So I decided to create a web app that would list out the upcoming rocket launches around the world. I wanted to have a database (PostgreSQL) that would store all the launches on the backend (built with Rails API) and I wanted my frontend (a React app) to send a fetch request to the backend API. It’s still a little wild to me that there was a time when I didn’t know what any of these words meant.

I prepared for my final review as well as I could. I went over all my notes and practiced talking about my code. The review was going fine until it was time for live coding. My reviewer asked that I add a search field and build some basic search functionality for my web app. It felt like this was the only topic I did not prepare for.

I think this is when my experience in tax kicked in. Don’t laugh, let me explain. Tax law is complex and there are a lot of exceptions to every rule. Nobody can be expected to know every detail, but tax professionals are expected to be able to talk about various options based on their knowledge and prior experience. Even if later you have to add to or revise your advice, you are still expected to talk about possibilities off the top of your head. So that’s what I did.

Although I’ve never built search functionality before, I started by talking about my data and how I would iterate over it. I talked about comparing my data to the input received from the search field. I planned to save the matches to a new array and put it in my state (this was a React app) to make sure that I can display them on the screen when the state is updated. By the time I was done it was clear that I talked through the entire process and the final act of building the functionality no longer felt daunting.

I passed my final review and graduated. I added that search field to my web app and pushed it to GitHub. I found that I was no longer able to go back to being a tax accountant.

As I look to the future, I am both nervous and excited. A career change is never easy, but I know that I want to be a software engineer. I also know that my prior experience is not a burden, but rather an advantage. I am able to think on my feet, to separate the important issues from the less relevant ones, and to focus on delivering an accurate work product. I’ve worked on many teams over the years and learned the importance of collaboration. I am excited to learn new things and am ready to work hard. I can’t wait for this new adventure!

Launch Calendar

Tatyana Celovsky — Wed, 05 May 2021 19:46:00 +0000

This post is an overview of how I built a webpage that lists upcoming rocket launches around the world with details on the date, time, rocket and mission for each.

For my Flatiron School final project I wanted to build something that I would find interesting and fun to work on. I also knew that I did not want to tackle a super complex project as I wanted to make sure that I worked within certain time constraints. After all, the purpose of this project was to help me graduate and to show off the skills I have acquired during my studies. After some reflection I decided that what I would find most exciting right now was building a webpage that would show a list of upcoming rocket launches around the world.

MVP

There were many features I wanted my webpage to have, but in order to make sure that I actually finish this project, I decided on the following Minimum Viable Product (“MVP”) goals:

Home page with a welcome message
A page with a list of upcoming rocket launches
For each launch list the following:
- Date of launch
- Time of launch
- Rocket type
- Mission description
Routes:
- Home page
- Index view with a list of launches
- Show view for each launch
- Do not intend to have a separate page for each launch
- About page

At least initially, I also decided on the following stretch goals:

Calendar functionality for each launch:
- Decide how to handle time parcing and conversion
- Decide what to do about launches where date or time are not yet known
Information about different rockets:
- A view page for each rocket type with specs and history
Twitter bot that will tweet out about upcoming launches
Link to webpages where launches can be viewed live (depending on availability)

Tech Stack

I knew that I wanted to build my own Rails API to handle the backend logic. The requirements for the frontend were to use React, Redux, HTML and CSS. Here is what I ended up doing:

Backend:
- Rails API
- Whenever gem used to schedule a custom Rake task (website scraping)
Frontend:
- React
- Redux
- HTML
- Bootstrap with some custom CSS
- Luxon gem used to convert date and time in the appropriate format needed for the Add To Calendar button

I made a decision to use Whenever and Luxon gems while I was already working on my project and incorporated them into the existing code base.

The Building Phase

I find that actually starting the project is the most difficult part. As I was agonizing over the details before ever writing a single line of code, I decided that writing down a step by step plan may help me get started. Below is the basic plan I wrote to get my project done.

Create GitHub Repository

Create a new repository in GitHub with .gitignore, README.md and LICENSE files.
Clone the newly created repository to your computer using git clone command followed by the SSH link to the GitHub repository.

Add .drawio Diagram

Create a new .drawio file using touch .drawio command.
In the .drawio file create a diagram representing relationships between the backend models using Entity Relation shapes:
- Include title of each model.
- Include characteristings of each model.
- Include relationships between models.

Backend Setup

Create Rails API structure by using rails new command followed by name of the Rails API:
- Add --api flag after the name to ensure that Rails only includes the necessary folders and capabilities for the API.
- Add --database=postgresql flag to create the Rails API with Postgres database, instead of the default SQLite3.

For this project, I entered the following in my terminal: rails new backend --api --database=postgresql.

Note. rails new command will generate a new Rails repository that will include .git folder. In order to ensure that both the frontend and backend can be stored in the same repository on GitHub (in two separate folders), you’ll have to delete this .git file as it will prevent you from pushing your new backend repository to GitHub:

cd into the new Rails repository just created.
In your terminal enter rm -r .git
cd back to the top folder of your project
Ensure that the items listed in the .gitignore file at the root of your project are prefaced with the name of your backend repository. For me this meant adding ‘backend’ at the front of each item listed in the .gitignore file.

Backend Setup (Continued)

cd into the new backend directory just created.
Navigate to the gemfile and add gem ‘nokogiri’. Nokigiri gem will help us with scraping and parsing.
Uncomment gem ‘rack-cors’ - his will allow Cross Origin Resource Sharing (CORS) in the API. CORS is a security feature that prevents API calls from unknown origins.
Add gem ‘active_model_serializers’ to the gemfile. Serialization is the process of converting data into a format that can be transmitted across a computer network and reconstructed later. Backend and frontend of this project will make requests to each other across the interwebs.
Run bundle install.
Inside config/initializers/cors.rb file uncomment the following code:

Rails.application.config.middleware.insert_before 0, Rack::Cors do
  allow do
    origins '*'

    resource '*',
      headers: :any,
      methods: [:get, :post, :put, :patch, :delete, :options, :head]
  end
end

Inside the allow block, origins ‘*’ means that requests from all origins are allowed. This can be changed to only allow requests from the address of the frontend repo - localhost:3000 for example.

Note. You may wish to create a custom Rake task to expedite the process of dropping, creating, migrating and seeding the database by using a single command. To do so, navigate to the lib directory and create a new file with .rake extension (I named my file dcms.rake). Inside thew newsly created file add the following code:

namespace :db do
task :dcms do
desc 'Drop, Create, Migrate and Seed the Database'
Rake::Task["db:drop"].invoke
Rake::Task["db:create"].invoke
Rake::Task["db:migrate"].invoke
Rake::Task["db:seed"].invoke
puts 'Database dropped, created, migrated and seeded.'
end
end

The above code will invoke each of the Rake tasks in sequence (drop, create, migrate, seed) when running command rake db:dcms and will put out “Database dropped, created, migrated and seeded.” message when the task has been completed.

Frontend Setup

From the main directory of your app, run npm init react-app command followed by the desired name for the frontend diretory.

For this project, I entered the following in my terminal: npm init react-app frontend.

cd into the new frontend directory just created.
Create src folder, this is where most of the frontend logic will live.
cd into the src folder and create folders for your components, containers, reducers, actions, styles.

I find that once I have the basic set up of the backend and the front, the coding comes easier. Don’t forget to consistently test your code as you go. I would recommend navigating to the backend directory and running rails s command in your terminal to start the Rails server. Then I would open up a new terminal window and navigate to the frontend directory, run npm start in the terminal to start the server. Having both servers runnig helps me test my code as I go. It’s also really exciting to see your project grow and develop during this process!

I hope you find the above overview helpful and feel free to check out my code!

Overview of Active Record Associations

Tatyana Celovsky — Thu, 27 Aug 2020 13:20:18 +0000

This is an overview of Active Record Associations, after reading this post, you will be able to:

Understand the types of Active Record associations.
Declare associations between Active Record models.
Use the methods added to your models by creating associations.

An association is a connection between two Active Record models that is used add features to your code. Rails supports six types of associations:

belongs_to
has_one
has_many
has_many :through
has_one :through
has_and_belongs_to_many

By declaring one of these associations, you instruct Rails to maintain information between the instances of your models. The following is an overview of each Rails association.

`belongs_to`

A belongs_to association sets up a one-to-one connection with another model, meaning that each instance of the declaring model “belongs to” one instance of the other model. For example, if your application includes authors and blog posts, and each post can be assigned to exactly one author, you’d declare the blog post model this way:

class Post < ApplicationRecord
  belongs_to :author
end

Note: belongs_to associations must use the singular term (i.e. author). Using the pluralized form (i.e. authors) in the above example would cause an error because Rails automatically infers the class name from the association name. If the association name is wrongly pluralized, then the inferred class will be wrongly pluralized too.

The corresponding migration would look like this:

class CreatePosts < ActiveRecord::Migration
  def change
    create_table :authors do |t|
      t.string :name
      t.timestamps
    end

    create_table :posts do |t|
      t.belongs_to :author
      t.datetime :published_at
      t.timestamps
    end
  end
end

After declaring the belongs_to association, the declaring class automatically gains 6 methods related to the association:

association
association=(associate)
build_association(attributes = {})
create_association(attributes = {})
create_association!(attributes = {})
reload_association

In the above methods, association is replaced with the symbol passed as the first argument to belongs_to. In our example where posts belong to authors, each instance of the post model will have these methods available:

author

author=

build_author

create_author

create_author!

reload_author

These additional methods make your code cleaner and easier. For example, you could add a new author while writing a post:

new_author = @post.build_author(name: "Your Name")
new_author.save

Note: If you use the `build option, you’ll have to persist your new author with #save while the create_` option will persist to the database for you._

`has_one`

A has_one association also sets up a one-to-one connection with another model, but unlike belongs_to association, has_one association indicates that each instance of a model contains only one instance of another model. For example, each customer would have only one account and you would declare the customer model as follows:

class Customer < ApplicationRecord
  has_one :account
end

The corresponding migration would look like this:

class CreateCustomers < ActiveRecord::Migration
  def change
    create_table :customers do |t|
      t.string :name
      t.timestamps
    end

    create_table :accounts do |t|
      t.belongs_to :customer
      t.sting :account_number
      t.timestamps
    end
  end
end

After declaring has_one association, the declaring class automatically gains 6 methods related to the association:

association
association=(associate)
build_association(attributes = {})
create_association(attributes = {})
create_association!(attributes = {})
reload_association

As previously mentioned, in the above methods, association is replaced with the symbol passed as the first argument to has_one. In our example of customers and accounts, each instance of the customer model will have these methods available:

account

account=

build_account

create_account

create_account!

reload_account

`has_many`

A has_many association indicates a one-to-many connection with another model and is found in models corresponding to a belongs_to association. has_many association indicates that each instance of the model has multiple instances of another model. Going back to the example of authors and blog posts, the author model would be declared as follows:

class Author < ApplicationRecord
  has_many :posts
end

Note: The name of the other model (i.e. posts) is pluralized when declaring a has_many association.

The corresponding migration would look like this:

class CreateAuthors < ActiveRecord::Migration
  def change
    create_table :authors do |t|
      t.string :name
      t.timestamps
    end

    create_table :posts do |t|
      t.belongs_to :author
      t.datetime :published_at
      t.timestamps
    end
  end
end

After declaring has_many association, the declaring class automatically gains 17 methods related to the association:

collection
collection<<(object, ...)
collection.delete(object, ...)
collection.destroy(object, ...)
collection=(objects)
collection_singular_ids
collection_singular_ids=(ids)
collection.clear
collection.empty?
collection.size
collection.find(...)
collection.where(...)
collection.exists?(...)
collection.build(attributes = {}, ...)
collection.create(attributes = {})
collection.create!(attributes = {})
collection.reload

In the above methods, collection is replaced with the symbol passed as the first argument to has_many, and collection_singular is replaced with the singularized version of that symbol. In our example of authors and posts, each instance of the author model will have these methods:

posts

posts<<(object, ...)

posts.delete(object, ...)

posts.destroy(object, ...)

posts=(objects)

post_ids

post_ids=(ids)

posts.clear

posts.empty?

posts.size

posts.find(...)

posts.where(...)

posts.exists?(...)

posts.build(attributes = {}, ...)

posts.create(attributes = {})

posts.create!(attributes = {})

posts.reload

`has_many :through`

A has_many :through association sets up a many-to-many connection with another model, indicating that the declaring model can be matched with multiple instances of another model through a third model. For example, in the case of a workout studio where students sign up for classes with various instructors, association declarations would look like this:

class Instructor < ApplicationRecord
  has_many :workout_classes
  has_many :students, through: :workout_classes
end

class Workout_class < ApplicationRecord
  belongs_to :instructor
  belongs_to :student
end

class Student < ApplicationRecord
  has_many :workout_classes
  has_many :instructors, through: :workout_classes
end

Note how workout_class class serves as a connector between instructor class and student class in the above example. This is that third model that helps to set up a many-to-many connection between students and instructors.

The corresponding migration would look like this:

class CreateWorkoutClasses < ActiveRecord::Migration
  def change
    create_table :instructors do |t|
      t.string :name
      t.timestamps
    end

    create_table :students do |t|
      t.string :name
      t.timestamps
    end

    create_table :workout_classes do |t|
      t.belongs_to :instructor
      t.belongs_to :student
      t.timestamps
    end
  end
end

has_many :through association is very useful for setting up shortcuts through nested has_many associations. Continuing with the workout studio example, a workout studio has many instructors and an instructor has many workout classes. It’s possible to get a list of all workout classes offered at the given studio:

class Workout_studio < ApplicationRecord
  has_many :instructors
  has_many :workout_classes, through: :instructors
end

class Instructor < ApplicationRecord
  belongs_to :workout_studio
  has_many :workout_classes
end

class Workout_class < ApplicationRecord
  belongs_to :instructor
end

With through: :instructors in the above example, Rails will now understand:

@workout_studio.workout_classes

`has_one :through`

A has_one :through association is used to set up a one-to-one connection with another model, such that the declaring model can be matched with only one instance of another model by proceeding through a third model. In the case of a customer and account example, each customer has only one account, and each account is associated with only one account history. The customer model would look like this:

class Customer < ApplicationRecord
  has_one :account
  has_one :account_history, through: :account
end

class Account < ApplicationRecord
  belongs_to :customer
  has_one :account_history
end

class AccountHistory < ApplicationRecord
  belongs_to :account
end

The corresponding migration would look like this:

class CreateAccountHistories < ActiveRecord::Migration
  def change
    create_table :customers do |t|
      t.string :name
      t.timestamps
    end

    create_table :accounts do |t|
      t.belongs_to :customer
      t.string :account_number
      t.timestamps
    end

    create_table :account_histories do |t|
      t.belongs_to :account
      t.integer :credit_rating
      t.timestamps
    end
  end
end

`has_and_belongs_to_many`

A has_and_belongs_to_many association creates a direct many-to-many connection with another model. In this case, no third or intervening model is needed. If your application includes assemblies and parts, with each assembly having many parts and each part appearing in many assemblies. The association declarations would look like this:

class Assembly < ApplicationRecord
  has_and_belongs_to_many :parts
end

class Part < ApplicationRecord
  has_and_belongs_to_many :assemblies
end

The corresponding migration would look like this:

class CreateAssembliesAndParts < ActiveRecord::Migration
  def change
    create_table :assemblies do |t|
      t.string :name
      t.timestamps
    end

    create_table :parts do |t|
      t.string :part_number
      t.timestamps
    end

    create_table :assemblies_parts, id: false do |t|
      t.belongs_to :assembly
      t.belongs_to :part
    end
  end
end

Note the assemblies_parts join table in the above example that allows the has_and_belongs_to_many relationship to work.

After declaring a has_and_belongs_to_many association, the declaring class automatically gains 17 methods related to the association:

collection
collection<<(object, ...)
collection.delete(object, ...)
collection.destroy(object, ...)
collection=(objects)
collection_singular_ids
collection_singular_ids=(ids)
collection.clear
collection.empty?
collection.size
collection.find(...)
collection.where(...)
collection.exists?(...)
collection.build(attributes = {})
collection.create(attributes = {})
collection.create!(attributes = {})
collection.reload

In the above methods, collection is replaced with the symbol passed as the first argument to has_and_belongs_to_many, and collection_singular is replaced with the singularized version of that symbol. In our example of assemblies and parts, each instance of the part model will have these methods:

assemblies

assemblies<<(object, ...)

assemblies.delete(object, ...)

assemblies.destroy(object, ...)

assemblies=(objects)

assembly_ids

assembly_ids=(ids)

assemblies.clear

assemblies.empty?

assemblies.size

assemblies.find(...)

assemblies.where(...)

assemblies.exists?(...)

assemblies.build(attributes = {}, ...)

assemblies.create(attributes = {})

assemblies.create!(attributes = {})

assemblies.reload

When deciding whether to use has_many :through or has_and_belongs_to_many, consider whether you need to have the independent relationship model. If you don’t need to do anything with the relationship model (for example, have validations, callbacks or other attributes), it may be simpler to set up a has_and_belongs_to_many relationship and the corresponding join table. Otherwise, use has_many :through.

Active Record associations are versatile and powerful tools. As mentioned above, declaring associations adds many useful methods to your models that will help keep your code succinct. A much more detailed guide to associations can be found in the in the Rails Associations Guide and Rails API docs.

All the Ruby Modules

Tatyana Celovsky — Tue, 06 Aug 2019 12:27:23 +0000

The goal of this post is to provide a brief introduction to Ruby modules and to show the distinction between Ruby modules and Ruby classes.

Ruby modules are quite similar to Ruby classes, with the main difference being that modules, unlike classes, don’t have instances. We start our definition of a module with a module keyword:

module MyModule
 def say_hello
  puts “Hello, World!”
 end 
end

This module can then get included in a class, giving instances of the class the ability to call the instance methods defined in the module:

class MyClass
 include MyModule
end

c = MyClass.new
c.say_hello

Note the second line of the above code snipped, this is how MyModule module gets included in MyClass class. The result of the above will be “Hello, World!” output because module MyModule was included in class MyClass, which resulted in MyClass class getting access to the instance methods within MyModule module.

It is important to note the difference between inheriting from a class and including a module. Ruby classes can inherit from only one class at a time, but multiple Ruby modules can be included in any single class. Note the difference below between class inheritance (first line) vs. model inclusion (second and third lines):

class MyClass < MySuperClass
 include MyModule1
 include MyModule2
end

Additionally, multiple Ruby classes can include the same module, thus, modules provide the ability to share the same instance methods between multiple Ruby classes. This ability comes in handy when you are writing a program where multiple classes share behaviors.

It is generally best practice to use a noun for your class name, while using an adjective for your module name. This general guidance is not followed in the above examples, mainly for ease of understanding and presentation.

Considering that multiple modules can be included in any single class, it is not impossible that we can encounter two different methods with the same definition. What’s an Object to do in a case like that? When a message, for example a method definition, is passed to an Object, the Object will look for that method in the following order:

Object’s class
Modules included in Object’s class, in reverse order of inclusion
The class’s superclass
Modules included into the superclass, in reverse order of inclusion

The very first method that the Object encounters that matches the message passed to the Object will be executed. This means that if method my_method is defined within the Object’s class, that method will be executed, even if there is another method my_method defined in a module included in the Object’s class. If the same method is defined twice in the same class, then the second definition (the one defined later) will take precedence. Same rule applies to modules. Keep in mind that modules included in Object’s class are searched in reverse order of inclusion, thus the model that is included later will be searched first. Fun fact, including the same module twice to influence the order in which modules are searched does not actually do anything. This means that including MyModule1 in line 4 below will not force Object to search it first. Object will still search MyModule2 first and then move on to MyModule1.

class MyClass < MySuperClass
 include MyModule1
 include MyModule2
 include MyModule1
end

How should one decide when to include a module vs. inherit a class? There is no one rule for this, but it may be helpful to keep the following in mind:

Modules don’t have instances. Thus, it is generally better to set up classes for entities or things and then use modules to encapsulate the behavior of these entities or things. This is also why class names generally tend to be nouns, while module names tend to be adjectives.
A class can inherit from only one superclass, but multiple modules can be included in a class. If your class will have several characteristics, it may be better to put those in separate modules, since your class would not be able to inherit from multiple superclasses.

Objects have Class

Tatyana Celovsky — Mon, 19 Feb 2018 22:48:54 +0000

It was mostly smooth sailing for me in my coding adventure until I hit the subject of Object Oriented Programming (“OOP”) in Ruby (so I really didn’t go very far before this first road block). I read the text of the lessons until all these getters, setters, classes and objects were all jumbled up in my head and life did not make sense anymore.

I just had to take a little break from the lessons for a few days and, instead, read some other resources online. I have to admit, at first none of them made sense either, but writing some concepts down in my own words really helped and I started to see a glimmer of light at the end of the OOP tunnel.

So what I figured out is that a Class is really just a blueprint for creating a base version of a Thing. All of the attributes of the Thing can be found within its Class and we can add more attributes by defining new methods within our Class. This means that every new Thing is “born” with a set of predefined, standard attributes. I think this is pretty neat because all you have to do is decide what you want your Things to look like and how they should behave and then every new Thing will act exactly as you expect it to. A standard name for a Thing is an Object; so all of the attributes of an Object are stored within its Class.

I was very happy once I understood that Classes are just blueprints and that really everything in Ruby is an Object. Then came instance variables. These are nifty little things; I’m a big fan of instance variables. A local variable defined within one method cannot be accessed by another method. You get around this by prefacing the variable name with @ symbol. That’s it! You’ve got yourself an instance variable that can be accessed by all methods within you Class.

Setter and getter methods were most difficult for me to understand. I just could not comprehend why you would need two methods to get a Thing to do something. This video lecture helped big time! I had to understand that I am really defining two completely different methods, one would be a name method, for example, and another would be name= (name equals) method. The name method is the getter or reader method, it simply returns information stored in the instance variable. The name= method is the setter or writer method, this is the method that can change information stored in the instance variable. Once I understood the difference between getter and setter methods things became a lot clearer!

It may have taken a while, but I finally had a decent grasp on Object Oriented Programming. It was time to apply my newfound skills and rewrite my Tic Tac Toe using OOP. Boy did that take a while! I guess applying concepts is harder than learning them, but I am done with with Tic Tac Toe now, at least until AI Tic Tac Toe. I’ll let you know how that one goes!