Last week, I wrote a bit about scope. Taking scope to the next level, brings us to the concept of closures.

Javascript MDN documentation describes a closure as: A closure is the combination of a function and the lexical environment within which that function was declared.

Lets dig into that a bit deeper. Generally, whenever a function is invoked, a new scope is created for that call. The local variable declared inside the function belong to that scope — they can only be accessed from that function. However, a closure is a function which has access to the variable from another function’s scope. This is accomplished by creating a function inside a function. Of course, the outer function does not have access to the inner scope.

In other words, a closure gives you access to an outer function’s scope from an inner function. In JavaScript, closures are created every time a function is created, at function creation time. To use a closure, define a function inside another function and expose it. To expose a function, return it or pass it to another function.

A simple example:

const message = 'The sky is blue.';
function sayMessage(){
  alert(message); // Here we have access to message,
  // even though it's declared outside this function!
}

We’d say that message is “closed over” by sayMessage().

Another example:

function makeName(name) {
var greeting = “Hello, “ + name + “!”;
var sayName = function() {
var welcome = greeting + “ Welcome!”;
console.log(greeting);
};
return sayName;
}

var sayMyName = makeName(“Ruby”);
sayMyName(); // Hello, Ruby. Welcome!

resources: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Closures, https://medium.com/javascript-scene/master-the-javascript-interview-what-is-a-closure-b2f0d2152b36, https://www.codingame.com/playgrounds/6516/closures-in-javascript-for-beginners,https://www.interviewcake.com/concept/java/js-closure

One of the most confusing concepts in coding, especially in my Javascript experience, is scope. A scope in JavaScript defines what variables you have access to; where declared variables and methods are available within our code. There are two kinds of scope — global scope and local scope. Scoping rules vary from language to language. JavaScript has two scopes — global and local.

Global Scope

Any variable declared outside of a function belongs to the global scope, and is therefore accessible from anywhere in your code. If a variable is declared outside all functions or curly braces ({}), it is said to be defined in the global scope. Variables inside the Global scope can be accessed and changed in any other scope.

var name = 'Joe';

console.log(name); // logs 'Joe'

function logName() {
    console.log(name); // 'name' is accessible here and everywhere else in the code
}

logName(); // logs 'Joe'

Once you’ve declared a global variable, you can use that variable anywhere in your code, even in functions. Although you can declare variables in the global scope, it is much better, not to. This is because there is a chance of naming two or more variables the same. If you declared your variables with const or let, you would receive an error whenever a duplicate name happens. If you declare your variables with var, your second variable overwrites the first one after it is declared. This also undesirable as you make your code hard to debug. Therefore, you should always declare local and not global variables.

Local Scope

Variables that are usable only in a specific part of your code are considered to be in a local scope. These variables are also called local variables. In JavaScript, there are two kinds of local scope: function scope and block scope.

1. Function Scope

When we declare a new function and then write our code in the body of the function, we are no longer in the global scope. The function creates a new execution context with its own scope. Inside the function body, we can reference variables and functions declared within in the function’s scope. However, from outside the function, we can’t reference anything declared inside of it. Variables having the same name can be used in different functions. This is because those variables are bound to their respective functions, each having different scopes, and are not accessible in other functions.

var test = "I'm global";

function testScope() {
  var test = "I'm local";

  console.log (test);     
}

testScope();           // output: I'm local

console.log(test);     // output: I'm global

2. Block Scope

When you declare a variable with const or let within a curly brace ({}), you can access this variable only within that curly brace. Variables declared with var are not block-scoped. The block scope is a subset of a function scope since functions need to be declared with curly braces (unless you're using arrow functions with an implicit return)

if (true) {
    // this 'if' conditional block doesn't create a scope

    // name is in the global scope because of the 'var' keyword
    var name = 'Joe';
    // likes is in the local scope because of the 'let' keyword
    let likes = 'Coding';
    // skills is in the local scope because of the 'const' keyword
    const skills = 'JavaScript and Ruby';
}

console.log(name); // logs 'Joe'
console.log(likes); // Uncaught ReferenceError: likes is not defined
console.log(skills); // Uncaught ReferenceError: skills is not defined

This gives us some background on basic scoping. Stay tuned for future blogs that add more complexity to scoping such as hoisting and closures!

Javascript ES6 introduced the data structure of the Map object. A map is a collection of elements where each element is stored as a Key, value pair. When we iterate over the map object it returns the key,value pair in the same order as inserted. Note- This is a totally different topic from the map() method. The map() method creates a new array with the results of calling a provided function on every element in the calling array.

An Object is similar to a Map in that both let you set keys to values, retrieve those values, delete keys, and detect whether something is stored at a key. However, there are some key differences described here:

1. The keys of an Object are String and Symbol, whereas they can be any value for a Map, including functions, objects, and any primitive.
2. The keys in Map are ordered while keys added to object are not. Thus, when iterating over it, a Map object returns keys in order of insertion.
3. You can get the size of a Map easily with the size property, while the number of properties in an Object must be determined manually.
4. A Map is an iterable and can thus be directly iterated, whereas iterating over an Object requires obtaining its keys in some fashion and iterating over them.

Creating a new map:

You create a new map by calling new Map(). This can be an array or any iterable object whose elements are key/value pairs. The provided key/value pairs are added to the new map using the set() function.

var m = new Map()
m.set('a', 1)
m.set('b', 2)
// {"a" => 1, "b" => 2}

Other key methods and properties for using the data in maps:

m.size : Returns the number of key/value pairs in the Map object. Note: m.length will return 0, must use .size.

Map.set() — It adds the key and value to the Map Object.

Map.has() — It return a boolean value depending on whether the specified key is present or not

Map.get() — It returns the value of the corresponding key

Map.delete() — It delete’s both the key as well as a value from the map.

Map.clear() — Removes all the elements from the Map object

Iterating over a map:

map.forEach(fn)- usage:
var myMap = new Map();
myMap.set(0, 'zero');
myMap.set(1, 'one');

myMap.forEach(function(value, key) {
  console.log(key + ' = ' + value);
});
// Will show 2 logs; first with "0 = zero" and second with "1 = one"

map.for..of - usage:

var myMap = new Map();
myMap.set(0, 'zero');
myMap.set(1, 'one');
for (var [key, value] of myMap) {
  console.log(key + ' = ' + value);
}
// 0 = zero
// 1 = one

for (var key of myMap.keys()) {
  console.log(key);
}
// 0
// 1

for (var value of myMap.values()) {
  console.log(value);
}
// zero
// one

for (var [key, value] of myMap.entries()) {
  console.log(key + ' = ' + value);
}
// 0 = zero
// 1 = one

resources: https://www.geeksforgeeks.org/map-in-javascript/, https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map, https://flaviocopes.com/javascript-data-structures-map/#what-is-a-map, https://hackernoon.com/what-you-should-know-about-es6-maps-dc66af6b9a1e

One of the most intimidating notions along my coding journey are the computer science terms and understanding how they relate to the code I write. One of the things that comes up most often are binary trees. So I thought I would do a little research to find out what they are and how to use them.

By definition: In computer science, a binary tree is a tree data structure in which each node has at most two children, which are referred to as the left child and the right child. Unlike Arrays, Linked Lists, Stack and queues, which are linear data structures, trees are hierarchical data structures. The elements that are directly under an element are called its children. The element directly above something is called its parent. When most people talk about binary trees, they’re more often than not thinking about binary search trees, so I’ll will be covering that.

-A binary search tree is considered balanced if every level of the tree is fully filled with the exception of the last level. On the last level, the tree is filled left to right.

-A Perfect binary search tree is one in which it is both full and complete (all child nodes are on the same level and each node has a left and a right child node).

Binary Search Tree is a node-based binary tree data structure which has the following properties:

• The left subtree of a node contains only nodes with keys lesser than the node’s key.
• The right subtree of a node contains only nodes with keys greater than the node’s key.
• The left and right subtree each must also be a binary search tree.

Why a binary search tree? They allow fast lookup, addition and removal of items, and can be used to implement either dynamic sets of items, or lookup tables that allow finding an item by its key (e.g., finding the phone number of a person by name). Binary search trees keep their keys in sorted order, so that lookup and other operations can use the principle of binary search: when looking for a key in a tree (or a place to insert a new key), they traverse the tree from root to leaf, making comparisons to keys stored in the nodes of the tree and deciding, on the basis of the comparison, to continue searching in the left or right subtrees. On average, this means that each comparison allows the operations to skip about half of the tree, so that each lookup, insertion or deletion takes time proportional to the logarithm of the number of items stored in the tree.

So why do we want to use a binary search tree: inserting, deleting and searching!!!

This is just some basics around binary search trees. In a future blog, I will go into setting one up and using it!

references: https://en.wikipedia.org/wiki/Binary_tree, https://www.geeksforgeeks.org/binary-tree-set-1-introduction/, https://www.geeksforgeeks.org/binary-search-tree-data-structure/, https://github.com/trekhleb/javascript-algorithms/tree/master/src/data-structures/tree/binary-search-tree, https://initjs.org/implement-a-binary-search-tree-in-javascript-952a44ee7c26, https://www.freecodecamp.org/news/data-structures-101-binary-search-tree-398267b6bff0/

As a newly-minted software engineer interviewing for my first tech job, I felt it was important to gather as much information on companies and roles as I could. In speaking to my fellow boot-camp grads, not all of them were aware of the ways to dig into the information, so I thought I would highlight some of my methods.

Company Website- Key source of what the company shows to the world. Look at press releases, mission statements, management information, overview statements. Note any key wording they use to describe their key values- try to bring those into how you describe what you are looking for.

LinkedIn https://www.linkedin.com- this one should be the gold standard for where everyone starts to dig in. You can get overview of the company information, employees, open roles, articles, etc. Look for any connections that you have with the company- maybe a former classmate or colleague works or worked there- reach out for information and contacts. Use that network! If you have the name of your interviewer- make sure to research them as well- find any commonalities to make a connection with them- shared interests, educational intersections, work experience- anything to make you memorable to your interviewer will make you stand out in the crowd!

AngelList https://angel.co/- Great for start up research- you can find out information on funding, investors, key employees, job postings, etc. Set up a profile while you are there to bring attention from the companies to you!

Crunchbase https://www.crunchbase.com/ — similar to AngelList, but even larger with more information categories. Better for the larger start ups and more established tech companies. Provides more information in an more user friendly interface. No job listings. You need to pay a premium for some categories of information, but the free info is fine for a job interview.

Built With https://pro.builtwith.com/ — Allows you to look up a company and see the tech stack they are working with, see if your skills are a match!

Siftery https://siftery.com/ — similar to BuiltWith, focused on the SaaS side

Glassdoor https://www.glassdoor.com/index.htm -another great resource for interviews- they even will have other’s interview experiences. Look up reviews from employees- check for red flags and issues of concern.

Google- again, obvious, but look up recent articles and company news- any recent acquisitions or new product launches- great talking points or question issues to discuss in your interview. Google the industry- any key changes going on, find competitors to research, any regulatory issues that might impact the business?

Twitter- check the twitter feed from the company to see what they are highlighting, but also search the company- see what others might be saying about them

Facebook/Instagram- I don’t find these as helpful as the other sites, as the information here, is usually shared elsewhere, but if you want to leave no stone unturned, check them out too!

As I continue to build my JavaScript algorithm skills, I can across some questions around sorting and what would be best regarding Big O. Sorting is simply arranging given data in ascending or descending order. There are a few key types of sorting, which are differentiated by the time taken to sort the given data, and the memory space required to do so.

1. Bubble Sort
2. Insertion Sort
3. Selection Sort
4. Quick Sort
5. Merge Sort
6. Heap Sort

Each sorting algorithm has tradeoffs. So you have to know what’s important in the problem you’re working on. How large is your input? How many distinct values are in your input? How much space is acceptable? Once you know what’s important, you can pick the sorting algorithm that does it best. Let’s go through them to review how to decide.

Bubble Sort is a simple algorithm which is used to sort a given set of n elements provided in form of an array with n number of elements. Bubble Sort compares each of the elements one by one and sorts them based on their values. If the given array has to be sorted in ascending order, then bubble sort will start by comparing the first element of the array with the second element, if the first element is greater than the second element, it will swap both the elements, and then move on to compare the second and the third element, and so on. If we have total n elements, then we need to repeat this process for n-1 times. Bubble Sort Complexity — Worst case timeO(n²), Best case timeO(n), Average case timeO(n²) and Space is O(1)

Insertion sort works by inserting elements from an unsorted array into a sorted subsection of the array, one item at a time. It works the way we sort playing cards in our hands. It starts from the index 1(not 0), and each index starting from index 1 is like a new card, that you have to place at the right position in the sorted subarray on the left. Insertion Sort Complexity — Worst case timeO(n²), Best case timeO(n), Average case timeO(n²) and Space is O(1)

Selection sort is in theory, the most simplest sorting algorithm. It works by selecting the smallest element from an unsorted array and moving it to the front. This algorithm will first find the smallest element in the array and swap it with the element in the first position, then it will find the second smallest element and swap it with the element in the second position, and it will keep on doing this until the entire array is sorted. Selection sort takes O(n²) time and O(1)space.

Quick Sort is done while dividing the array into subarrays. Quicksort works by recursively dividing the input into two smaller arrays around a pivot item: one half has items smaller than the pivot, the other has larger items. The pivot element can be any element from the array, it can be the first element, the last element or any random element. This algorithm divides the list into three main parts:

1. Elements less than the pivot element
2. Pivot element(Central element)
3. Elements greater than the pivot element

Complexity for Quick Sort — Worst case time: O(n²), Best case time: O(n*log n), Average case time O(n*log n) and Space O(n*log n)

Merge Sort follows the rule of Divide and Conquer to sort a given set of numbers/elements, recursively, hence consuming less time. Merge sort works by splitting the input in half, recursively sorting each half, and then merging the sorted halves back together.

Complexity- overall, merge sort takes O(n*log n) time and O(n) for space

Heap Sort is similar to selection sort — we’re repeatedly choosing the largest item and moving it to the end of our array. But we use a heap to get the largest item more quickly. Heap Sort is one of the best sorting methods being in-place and with no quadratic worst-case running time. Heap sort involves building a Heap data structure from the given array and then utilizing the Heap to sort the array.

Heap sort algorithm is divided into two basic parts:

• Creating a Heap of the unsorted list/array.
• Then a sorted array is created by repeatedly removing the largest/smallest element from the heap, and inserting it into the array. The heap is reconstructed after each removal.

Time Complexity: O(n*log n) and Space Complexity : O(1)

Hopefully this gives you an overall view to give you an idea how you might want to sort your data- I recommend checking out these references for more information…

References: https://www.studytonight.com/data-structures/introduction-to-sorting, https://www.interviewcake.com/sorting-algorithm-cheat-sheet, https://medium.com/@MarcHoag/three-days-ago-i-had-no-idea-what-things-like-big-o-or-sorting-algorithms-were-now-ill-teach-you-124432c00a96, https://medium.com/javascript-scene/time-complexity-big-o-notation-1a4310c3ee4b

As a newly minted software developer and bootcamp grad, a big part of my road to employment is learning and networking. In the tech world, a key intersection of these goals is at conferences. While attending conferences on your own can be intimidating, I decided to attend Codeland, which is put together by CodeNewbie- right in my wheelhouse. This conference is geared to participants relatively new to coding- those learning or in their first roles, so I figured I would fit right in. I was right- it was an inclusive and welcoming environment, and I am so glad I attended!

Codeland Conference

I thought I would share some insights through this blog post on my experience, for those who are thinking of attending a conference and are unsure of what to expect. Hopefully this gives you a boost to leap in and attend one soon!

I learned about this conference by following CodeNewbie on Twitter- they, and many others in the tech Twitter space, were talking about it and it sounded great. Since it was being held here in NYC, I felt it would be a great opportunity for me, as there were no travel costs to consider. So, I bought my ticket (different options of costs, based on when you bought, and if you wanted to attend a workshop). I bought a ticket that included a workshop, as I felt it would be a great learning experience. A few weeks before the conference, a note was sent out to choose your workshop- I recommend choosing right away, as many of them filled up fast. I chose a great workshop called “Building with Accessibility in Mind” which was taught by Luisa Morales, who is a computer science master’s student at Pace University in NYC and an Engineering Fellow at The Mayor’s Office for Economic Opportunity (NYCO). As Accessibility in coding is a keen interest of mine, it was my first choice.

On conference day, I went downtown to NYU Skirball for a long, but inspiring day- we kicked off with breakfast and networking while perusing tables with fun swag, set up by sponsors of the event- including a great coffee bar set up by my bootcamp alma mater- Flatiron School.

We then headed in for the opening speakers including a kickoff Bollywood dance to get our blood flowing. The link above has more about the speakers, but just to say, they were inspiring, and thought provoking. After the opening speakers, we split into two tracks- A and B- as my workshop of choice was track B, I headed next door and up to my workshop. The workshop was great and we had opportunities to pair program and learn different ways to include accessibility in our future projects. We also were given some great resources to follow up with, and I can’t wait to dive deeper into the topic.

After a lunch break with an opportunity to network with new friends, we had a great afternoon of topical speakers, and I again was inspired by wonderful talks on a range of subjects. Then we had a quick snack break, a chance to visit sponsor tables, and then our closing keynote speakers. The day ended with an afterparty put on by GitHub, a generous sponsor of the event.

Some key highlights for me-

1. An opportunity to network and meet fellow new coders who are in the same place that I am in- knowing you are not alone makes a huge difference
2. Inspired by some great speakers who are using code to address natural disasters, build communication tools to resolve human divides, and help cope with disease.
3. Remembering to laugh at myself- we all trip ourselves up at times and are human- humor is a great way to cope!

I hope this inspires you to attend a conference soon- I highly recommend Codeland or any other that fits your needs and budget.

Okay, we all may have giggled the first time we heard the term, or our eyes glazed over at the thought of some complex terminology. In a way, it scared me a bit- it seemed like a something only a PhD data scientist might need to deal with. But in reality, all programmers need to know what it is, and how it affects what we write.

What is Big O- in simple terms, it is the way we describe the efficiency of an algorithm. If you think about it- the more complex your algorithm is, the more time it will take to run, and as we all know- time is money. Additionally, we look at memory-the amount of space your program run takes, is also a resource drain.

By definition, Big O specifically describes the worst-case scenario when running an algorithm, and can be used to describe the execution time required or the space used by an algorithm. Big O Notation uses mathematical functions to describe algorithm’s runtime performance. The function is written within parentheses after a capital letter O.

Some of the types of times you will typically see:

• O(1) — Constant time complexity : This is the fastest O and the “Best case scenario”— O(1) describes an algorithm that will always execute in the same time (or space) regardless of the size of the input data set. An example is console logging the first item in an array of items. You could also see push() or pop() on your array. It is one step in your code, no matter how many items are in your array.

• O(n) — Linear time complexity : This is where a loop would come into play- this example is O(n) as it runs for every value in our input. The operation increases in a linear fashion according to the inputs, where(n) represents the number of inputs ie; the time it will take to run the algorithm will increase proportionately as the size of input n increases. Following from the example above, console logging each item in the array. It will have to go through n times.

Now it gets a big more confusing….

• O(n²) (or quadratic time) — O(n²) is an algorithm where the performance is directly proportional to the square of the size of the input data set. This is common with algorithms that involve nested loops over the data. Deeper nested iterations will result in O(n³), O(n⁴) etc. This is known as quadratic time which means that every time the number of elements increases, we increase the operations quadratically. Every element of the array, would have to be compared to every other element.

even more confusing…

• O(log n) — Logarithmic time complexity — this shows the time it takes to run the algorithm is proportional to the logarithm of the input size n. It narrows down the search by repeatedly halving the dataset until you find the target value. Using binary search — which is a form of logarithmic algorithm, finds the median in the array and compares it to the target value. The algorithm will traverse either upwards or downwards depending on the target value being higher than, lower than or equal to the median.

Attached is a chart comparing the types:

I hope this gives a little bit of clarity of what people are talking about when they mention Big O!!!!

Additionally, when I try to Google setting up a project on GitHub, it inevitably sends me to information on how to host my project on GitHub, but not link it to my existing repository account. So, below, I am going to walk through the basic GitHub linking process, in case you have come across this yourself.

This can be done either by first creating the repository and then setting up the project, or if you have a project you are already working on, secondarily setting up the GitHub link.

Step 1: Create a new repository in GitHub- At the top right hand corner of your GitHub account, click the plus sign (+), and then in the drop down, click the new repository line. it will then take you to this page:

Step 2: Enter your project name into the Repository Name box, and a description if you wish- this is optional. Then click Create repository

Step 3: It will take you to this page- copy the SSH code on the top line using the icon to the right of it. You will use this at a later step

Step 4: Open your terminal and create your project- this this case, I will use create-react-app test-project. Once that runs, cd into the app.

Step 5: Add project to the GitHub

type in- git init

next type in- git add .

then type- git commit -m “first commit”

next- git remote add origin <and then paste in the SSH address you copied in Step 3>

and lastly type in- git push -u origin master

Step 6: Lastly, you can open up your code editor and start working on your project!

As I begin the job search process as a junior developer, I am a bit overwhelmed by all of the expectations of this journey- networking, blogging, Git commits and more. After graduating a challenging bootcamp, isn’t the ability to code apps enough?

The interview process for developer roles, even at the most junior levels, is grueling. Understandable that a company wants the best coders for their open roles, but in order to meet their expectations, the aspiring employees must be prepared for the challenges of the process.

Usually, the process has multiple stages- a behavioral/cultural interview, a coding challenge and an in-person technical interview that might include pair programming or whiteboarding. Depending on the company or role, each of these stages might include multiple interviews with different people.

Today’s blog is focused on the coding challenges that are algorithm based, and some great tools to practice those skills. These challenges are designed to test your analytical, coding, technical and communication skills. Sometimes these are part of a take home challenge, or might be done in person. Either way, there is usually a time constraint on completion, so even if you can’t complete the challenge, it is strongly suggested to at least pseudo-code out your approach to the problem, even if you can’t complete the code. This allows the reviewer to see those skills, even if it is not complete.

There are a lot of great tools out there to practice- some are free, and some have small fees- here are some that I am using:

1. The ever popular- Cracking the Coding Interview- book by Gayle Laakmann McDowell. This book is the gold standard and has practice questions and solutions as well as sound advice. https://www.amazon.com/Cracking-Coding-Interview-Programming-Questions
2. A great Udemy course-by Stephen Grider: https://www.udemy.com/coding-interview-bootcamp-algorithms-and-data-structure/
3. InterviewCake (https://www.interviewcake.com) a website that sends one problem a week, and provides a very thorough walkthrough of the solution
4. LeetCode (https://leetcode.com)/ CodeWars (https://codewars.com) these sites have problems seen on interviews and are great for practice
5. HackerRank Interview Prep Kit- https://www.hackerrank.com/interview/interview-preparation-kit

Good luck!!!