DEV Community: AaronDski

Useful VSCode Extensions

AaronDski — Fri, 24 Sep 2021 15:40:17 +0000

VSCode (Visual Studio Code) is one of many code editors. A few of them are Atom, Sublime, and Brackets. All of these text editors have their pros and cons, advantages and shortcomings. Needless to say, they are all similar in the fact that they were created to make writing code easier for the coder. The languages, libraries and frameworks that I use regularly are JavaScript, React, Ruby, and Ruby on Rails.

Here are some of my favorite extensions and why.

1) Bracket Pair Colorizer. It does what the name suggests: this extension makes reading and debugging easier. You can see that it will also add a colored line to the pair of brackets or parentheses.

Although I have not set this up on my own VSCode, you are also able to customize when the brackets change color.

Even the standard configuration is a great setup and has been very helpful at reducing syntax errors.

2) Rainbow End is along the same vein and colors your ends in Ruby (it works with other languages as well). It has been very easy to identify when I am missing an end or if I have to many ends. Here are some examples of Ruby methods with Rainbow End enabled:

3) Draw.io Integration. If you work on your own projects, I'm sure that you have at least heard of Draw.io. It is a user-friendly web app for making diagrams. The integration extension is not officially from Draw.io, but this particular extension is very useful as it allows you to have any and all of your relevant diagrams in your project file, which ends up being a big time saver. I have not tested the full capabilities of this extension yet, but I'm sure that there are plenty of features that I would like.

The only drawback that I have run into is, when I have a large diagram up on one side of my VSCode and the code that I am editing on the other side, I will sometimes have to scroll through the diagram because I can't see the full diagram or have it on a separate screen.

These next few extensions come with a caveat, as they can instill some bad habits. So use with caution.

4) Endwise is nice because it will automatically add end when you are writing methods in Ruby. It is also pretty intuitive at knowing when an end is needed or not. This gif is not a great example but you can get an idea of how it works:

The downside this is that you can become reliant on the extension to add all of your ends, and then you have a propensity to completely forget common syntax of the coding language.

5) Tabnine is another "double edged sword" extension. This is an autocomplete, or AI-assisted code completion, AI-powered code completion, AI copilot, AI code snippets... whatever you want to call it is up to you, but it can definitely help to save time. I like to use longer names for my function names, so the autocomplete is great for saving key strokes. I'm not the greatest at spelling so the spellcheck is also nice. It does have some quirks as well, especially when it tries to be too helpful by giving you suggestions that you don't need or want. Like this I only want the method of show and it thinks I would like show_exceptions, which hinders me from being able to just hit enter and go to the next line, as I would normally do. There is a shortcut to bypass this suggestion from Tabnine: you can hit "command + enter" for Mac or "control + enter" for PC, and it will move you to the next line.

All these extensions have been very helpful for me in my projects. I am sure that there are a number of other extensions out there I have yet to discover and may find even more useful, but for now, these are some my favorites. I hope that these can be helpful to you as well.

Postscript: A good indicator to determine if an extension is noteworthy or relevant is by looking at how many downloads it has and if there have been recent updates/responses to questions by its originator.

Comment below about your favorite extensions.

GitHub Workflow, Merge and Rebase

AaronDski — Fri, 10 Sep 2021 19:16:34 +0000

If you are just getting into coding and are working on projects, ether solo or in a group, you probably use GitHub, a platform to house your projects. Or you use it at your job and are always doing adds and commits, waiting for you superior to approve the merge. If you already know how all of that works, then you most likely won't need to read this post. I am writing this as more of a quick reference guide for us newbies... and there is a lot of additional good documentation from GitHub and lots of extra resources on the web.

There are 2 major ways to update a main/master branch in GitHub: the first is the good old git merge, and the second is git rebase. Both of these commands accomplish the same thing: they update the main/master branch with your newly written code.

This is coming from the view point that you are working on a branch that is not the main. Make sure you have the most up-to-date version of the main repository by running git pull. To make your own branch, you can run

git branch 
#this will display all of the branches in the current repo
git branch example_branch
#this will make a branch off the main if you are currently on the main branch

Now we need to get into the new branch we just made. We can do this with

git checkout example_branch

So you have been working on a feature for the main code file; let's talk about when you are ready to have your code reviewed and potentially merged into the main branch. First we check the status to make sure we only edited the files we were supposed to.

git status

Then we add all of our changes to the staging area to be committed by running one of the following commands:

git add .
git add -A
git add 'file name'

Now your code is ready for a commit. This is where we are able to leave a detailed message about what we did with our code. Here are some commit commands:

git commit -m "message"
git commit -am "message"
#This command will add your changes and commit them in one go

Then once you have your code committed, you can push your code to the origin branch with

git push

Finally it is ready to be reviewed and sent back for editing, or it can be merged into the main. If there is no more code for you to add, when your branch and the main branch are merged, you have the option to delete your branch. If you will need to use it again soon, then you can just leave it be.

To merge to 2 branches, we will want to go into the main/master branch, then run git pull, just in case there have been any changes (it will let you know if you are up to date, or it will automatically load the changes). Our commands can look like this:

#currently not on main branch

git checkout main
#now we are on the main branch

git pull
# just to double check for any changes

git merge example_branch   
#now the branch has been merged into main

Hopefully there are no merge conflicts, and if not, you are done! That is the easy way to do a merge and its called a "fast forward merge."

If you do get some merge conflicts you will need to resolve those conflicts before you can move on.

A merge is pretty self explanatory, you are combining the contents of 2 items into 1. There are a few ways that a merge can happen, 1) you can do it strait in your terminal, 2) you can use the GitHub webpage, 3) Github also has an app for OSX that works pretty well.

When there are commits on the main branch that are added after you made your branch, it will prompt what is called a "merge commit," once the merge is initiated. You can leave a message and move on to write more code.

A merge commit will have a lot of "~" symbols and you need to leave a message to move forward in the commit, it would look like so:

~
~
~
~
~
~
~
~

You can hit the escape key, then type : w q which will save the commit and get you through the merge commit. Then you should double check with git log to make sure all the commit history looks correct to you.

"Rebase" is a git command that will get us a similar result of adding our code to the main branch, but it works very differently. Rather than having branches come together into the main, you are basically adding your 'example_branch' onto the end of the master branch. To do this you follow all of the same steps above, but when it comes time to merge, you will instead run

#you will want to be in your "example_branch" when you run this command

git rebase main/master

The links below are some good resources that I found, and they go into greater detail of whats going on behind the scenes.

Resources
GITHUB PULL REQUEST, Branching, Merging & Team Workflow
Git Rebase Vs. Merge
Git Cheat Sheet

ActiveRecord Associations intro into 'has_many'

AaronDski — Fri, 27 Aug 2021 14:59:10 +0000

When learning about ActiveRecord in our coding bootcamp, they talked about the major benefits that ActiveRecord provides when working in Ruby and SQL. So I wanted to delve more into what is happening behind the scenes, and I discovered there is a lot that ActiveRecord is doing back there. So let's talk about one that we all use: has_many.

Has_many is one of the 6 types of associations (or "macro methods") that ActiveRecord offers.
A has_many association is similar to has_one, but indicates a one-to-many connection with another model. You'll often find this association on the "other side" of a belongs_to association. This association indicates that each instance of the model has zero or more instances of another model. With the has_many association you will always want to make sure that whatever the model has_many of, is plural. For example, in an application containing a child and their toys, the child model could be declared like this:

class Child < ApplicationRecord
  has_many :toys
end

A has_many :through association is often used to set up a many-to-many connection with another model. This association indicates that the declaring model can be matched with zero or more instances of another model by proceeding through a third model. Also with the has_many :through association, you will still want to make sure that whatever the model has_many of is plural. For example, consider a game has reviews and users that can write reviews. The relevant many-to-many association declarations could look like this:

class Game < ApplicationRecord
  has_many :reviews
  has_many :users, through: :reviews
end

class Review < ApplicationRecord
  belongs_to :game
  belongs_to :user
end

class User < ApplicationRecord
  has_many :reviews
  has_many :games, through: :reviews
end

Okay, now that we have that basic setup of what the has_many table association can look like, lets get into what is auto-generated for you. Look at the list below:

others                            
others=(other,other,...)          
other_ids                         
other_ids=(id,id,...)             
others<<                          
others.push                       
others.concat                     
others.build(attributes={})       
others.create(attributes={})      
others.create!(attributes={})     
others.size                       
others.length                     
others.count                      
others.sum(*args)                 
others.empty?                     
others.clear                      
others.delete(other,other,...)    
others.delete_all                 
others.destroy(other,other,...)   
others.destroy_all                
others.find(*args)                
others.exists?                    
others.distinct                   
others.reset                      
others.reload

These auto-generated methods can and will save us a ton of time when querying any database.

Here is another cool thing that has_many can do: since associations are built from Relation objects, you can add conditions to the query, like so:

class Blog < ActiveRecord::Base
  has_many :published_posts, -> { where(published: true) }, class_name: 'Post'
end

You can also read up on more of the capabilities that 'Association Methods' have, Here.

Furthermore, if you would like to learn more about the other five associations, here is a link with detailed documentation on those association types and their use cases ActiveRecord.

In conclusion, has_many is a very helpful method that saves us a lot of time. I personally have made many methods not knowing that has_many already provided said method. So it's a good thing to to be curious about whats happening or what the method is doing for you. post in the comments below about a time when a 'Macro' method saved you time.

Intro Into Private Methods

AaronDski — Fri, 13 Aug 2021 14:16:12 +0000

The goal of this post is to shed some light on the topic of "Private Methods." This is a very basic overview on said topic, but I hope my findings will be enlightening, at least to some extent, for whomever views them. Ruby Classes
Ruby Methods

If you are reading this, then hopefully you already know what Classes and Methods are in Ruby. If not, I recommend reading up on those topics before moving forward.

Public Vs Private

Private methods are really only to be used in the Class in which they reside. A good way for me to know when I would need private methods is this: if I have a set of methods that do a specific task, and I don't want to alter that set or make it available outside the confines of this particular Class, then I would make it private. I still have access to the info that those methods give me, but now anyone who reads my code would know that this distinct set of codes are designed to work together to perform a specific function.
I like to think that private methods are more "limited access" rather than "private" or "restricted," which just force you to follow proper channels, in order to get the information that the method provides.

Private is not a keyword in Ruby itself, but is actually a method that is already defined by the Ruby language. Private methods are only accessible by other methods from the same class, methods inherited from the parent class, and methods included from a module.

A classic Ruby method will start out as a public method (easily accessible) by default and can be made private very easily with these 3 different syntaxes, all of which accomplish the same result.

By adding `private` in your code, Ruby will read this and know to make all of the methods below `private`

By using the `private` method (“wrapper” syntax)

By using the `private` method with explicit arguments

Another variant of the syntax of private methods is when we can explicitly pass method names as arguments.

You can make a also `private` method `public` again with this syntax

Here's a metaphor that might help to better understand private methods:
Imagine you go to your local coffee shop (think of this coffee shop as a Ruby Class). The seat you choose, what you order, and waiting in line to place that order are all "public methods." Then your order is placed and the barista starts making your latte. From this point, you can think of the making of your latte as a "private method." You told the barista what you want, and now it's up to the barista, and you don't get a say in how the order is completed, it is simply made for you.

Let's say you want to just access choose_milk. It won't let you, and you will get a "NoMethodError," which would look a bit like this in IRB:

You can still get the information that choose_milk provides, but you cannot break it up into just that one piece.

See, you just need to go through the make_drink method and then the information that choose_milk provides is there.

There you have it! This is what I have learned about private methods, over the first week of coding in Ruby. I hope that you found something useful in this article. Thank you for reading.

Decoding The Brain

AaronDski — Thu, 22 Jul 2021 05:24:55 +0000

Disclaimer I am not a Medical Professional. This information is my own deduction on how the brain functions, when we learn something new. Links to my sources are below.

Learning a new language can be more difficult than some people might realize. Or is it? There are a number of reasons, excuses and justifications that we all can use to avoid learning a new language... to say that, "it's just too hard." I, for one, am guilty of this unhealthy mindset. Is this the way things are always going to be?, I thought, Is there no way of escaping the fact that there are just some things I won't be great at (or even mediocre, by some standards)? I needed to know, and so I did some research.

It turns out, when you try to learn something new--like skills, sports, languages, coding, etc--there are many things happening simultaneously in your brain. I'm going to point out a few that stuck out to me.

Neurons

Neurons--you have around 85 billion of them. A neuron cell acts as a messenger, sending information in the form of nerve impulses (like electrical signals) to other neurons. This is how our brains access memories, operate our motor functions, and direct our speech, etc. So what does that mean when we are learning something new? Well, for everything that we already know, there are set pathways for our neurons to follow, but for things we haven't previously learned, a pathway has not yet been created.

This is the case when we don't know something: we "draw a blank" or just simply can't find the answer. In the event when we can come up with an educated guess or solution to something haven't learned, it is because our brains are trying to find a pattern or some common ground with something else we already know--a relative pathway for the information to move through. Say when you can't find a pathway, what does you brain do? It makes a new pathway, of course! You can think about making pathways like blazing a trail in a forest. Now we have a new pathway for the info to work with, but it's not that strong of a connection, (not a well-groomed, obvious trail). How do we make this connection stronger? Easy: use that pathway more. This is why repetition works so well to make things stick in your brain. Ever seen a cow trail? Same basic concept.

BLC (Bilingual Language Control)

There has been a joint study on BLC done by Marco Calabria, Albert Costa, David W. Green, and Jubin Abutalebie.

This BLC ability is now established as the architecture of what our brain is assessing when it decides what language to use. This complex system involves cortical and subcortical (different areas of the brain) structures, each responsible for particular cognitive processes, such as goal maintenance, conflict monitoring, interference suppression, and selective response inhibition. Our brain will separate the 2 languages, so that they don't interfere with each other. Switching between languages is very hard at first, but the more you do it the less taxing it becomes. It is incredible to think that, without our instruction or even awareness, our brain is able to switch to a completely different way of thinking, in a matter of nano seconds.

I would surmise that this is applicable not only to spoken languages but to coding as well. Why not? They are "languages," after all.

Dopamine

Dopamine is released in the brain when we do something that we enjoy; it's the chemical that makes us feel good. Simple enough. But what if we need to learn something that we don't really enjoy, or that we don't even remotely like? Well it certainly makes it harder to listen to someone teaching on the topic. What if you had to learn that thing you had no interest in, but there was a large sum of money waiting for you once you had mastered the topic? Would you be more interested then? I know I would be.
There is a very simple tactic we can use to motivate ourselves: set small objectives that can be achieved daily, which help to move you toward your desired destination. By doing this, we are not only establishing self-discipline, but we are creating miniature, daily "wins" by achieving goals, which makes us feel good (Dopamine), and produces motivation in us... and we may even then start to enjoy the topic or task at hand. (Disclaimer: there will always be subjects/projects that are not enjoyable).

Dopamine is not only a great way to find things that we enjoy, but it is also a very helpful tool in the learning process. When there is more dopamine involved in your studying, your brain will find ways to reference those memories or thoughts, thus reinforcing what you just learned. So if you are on a topic that you don't particularly like, find a "carrot" to dangle in front of you. You will be amazed at what the brain is capable of, when it has a reason to learn.

Healthy Habits

A.) Work well with others.
Collaboration and collaborative learning have been a part of our human nature for as long as we know. We are inherently social beings and social learners. When collaborative learning techniques are used to support instruction, students tend to be more engaged, retain information better, and have better outcomes than those who prefer to be "solo learners."

B.) Don't be stagnant.
Be constantly learning new things, even if they are small things. When you learn, you are increasing/maintaining good and healthy neuroplasticity. In a way, our brains are like Play-Doh. If you don't use your Play-Doh, it gets hard and dried out. Our brains don't literally dry out, but you get the point. Use it frequently, or your brain will begin to lose functionality.

C.) Rest.
Good sleep is one of the (if not the) greatest ways for your brain to replenish, re-energize, and heal. A tired brain can't accomplish much.
Additionally, taking breaks is more beneficial than you might realize. Spacing out your study time with small breaks (15-20 minute beaks every 2-or-so hours of studying) is very helpful in not getting "burnt out," because your brain is able to "take a breather between legs of the race" (as it were).
My hypothesis is that it gives the brain time to strengthen and consolidate the connections between your neurons, and sort through necessary information.

This greater understanding of how your brain functions and the use of supportive learning strategies and can now allow you to help your brain to better learn!

Side note: Stay hydrated! Maintain a consistent intake of water... trust me! Your brain will thank you.

References

BLC
(https://repositori.upf.edu/bitstream/handle/10230/44011/calabria_nyas_neur.pdf?sequence=1&isAllowed=y)

Group Learning
(https://www.cs.cmu.edu/~bmclaren/pubs/Wiley-ColaborativeLearningWhitePaper-2014.pdf)

Healthy Practices
(https://www.powerofpositivity.com/researchers-explain-learn-something-new/)
(https://kids.frontiersin.org/articles/10.3389/frym.2020.00054)

Learning Styles
(https://bau.edu/News/types-of-learning-styles/)