# Scope

## Scope can be thought of as the area of code in which a variable is visible

#### Please note that the following post is under the assumption that you are not using strict mode. If you aren't sure what that means, don't worry about it for now. Just understand that this is how scope works naturally in JavaScript without strict mode turned on.

#### I also challenge you to run these code examples for yourself as you read through.

Let's look at the following function:

```
function addTwenty(num) {
  var add = 20;
  return num + add;
}
console.log(add);
```

If we ran this code we would end up with a ```ReferenceError```. This is because ```add``` is bound by the scope of the function, and we are trying to access it outside of it's scope. In other words ```add``` is not visible outside of it's scope.

Let's look at another example:

```
console.log(num);
let num = 5;
```

This works as you'd intuitively expect. Since the variable ```num``` has yet to be defined you end up with a ```ReferenceError``` from trying to access a variable that does not yet exist in memory.

However this does not work the same. Declarations made using ```let``` and ```const``` are evaluated at runtime but ```var``` declarations are not, so we end up with ```undefined``` here instead of a ```ReferenceError```:

```
console.log(num);
var num = 5;
```

The fact that the interpreter knows about the existence of these variables before they are declared is due to something known as hoisting.

# Hoisting

## Variable declarations are ***figuratively*** hoisted to the top of it's scope.

What does this mean? It means that due to the way the JavaScript interpreter works, you can imagine that variable declarations are moved to the top of it's scope, and then are ***set*** at the point that you defined them; either at or before runtime depending on if you are using ```var``` or ```let/const```. Sounds kind of confusing, but it's really quite simple. Let's looks at an example.

I want you to notice that this example gives us ```undefined```:

```
console.log(char);
var char = 'a';
```

but this example gives us a ```ReferenceError```:

```
console.log(char);
let char = 'a';
```

Both variables are hoisted, however the difference is that variables defined with ```const``` and ```let``` are evaluated at runtime. Don't believe me that ```let``` declarations are hoisted? Let's prove it really quick for the sake of completion:

```
let char = 'a';
if(true) {
  console.log(char);
  let char = 'b';
}
```

Even though ```char``` is defined in the Global scope, and the local version of ```char``` is declared after our ```console.log()```, we still get a ```ReferenceError```. This means that our local ```let``` declaration is being hoisted and the ```console.log()``` is aware of it, but due to the way the JavaScript interpreter works, we are simply unable to access it at this point. The time in which a ```let``` or ```const``` declaration is not yet available at runtime is known as the ***Temporal Dead Zone***. This can be confusing but it will be helpful to understand in certain debugging scenarios.

Now let's move on.

A variable's declaration is hoisted, but the definition is not. So essentially the following two examples will produce the same outcome:

```
console.log(char);
var char = 'a';
```

and

```
var char;
console.log(char);
char = 'a';
```

One last thing on hoisting for now.

Function declarations are also hoisted to the top of it's current scope, but differently than variables. The function definition is also hoisted with it. 

For example:

```
console.log(squareNumber(4));
function squareNumber(num) {
  return num **2;
}
```

This function will work fine because the interpreter loads the function and it's definition into memory before running through and executing the code.

# Global Scope

## There are different types of scope in JavaScript to be aware of.

Let's start with the Global scope. There are a few different ways to utilize the Global scope in JavaScript.

Let's look at the most simple way:

```
var globalVar = 'I am global!';

function concatString(str) {
  return str + ' ' + globalVar;
}
console.log(concatString('I am hungry!'));
```

We call this Global scope because every other scope within this module has access to ```globalVar```. Notice that the function ``` concatString ``` has access to the ```globalVar```.

Let's take a look at another method of accessing the global scope. Instead of returning the string in concatString, let's set it as a property on the window object. Let's then see if we can access it inside of the logString function:

```
var globalVar = 'I am global!';

function concatString(str) {
  window.concat = str + ' ' + globalVar;
}
function logString() {
  console.log(window.concat);
}

// First we'll call concat string..
concatString('I am hungry!');

// Then let's call logString()
logString();
```

As you can see, variables in the global scope can be accessed by both of these functions.

It is often best practice to avoid setting variables in the Global scope if possible. This is because we often want to avoid other parts of our code accessing and changing values that are used elsewhere in the code. That can lead to some unexpected behavior. Something to keep in mind.

# Block Scope

## let and const are block scoped

What this means is that variables declared using ```const``` and ```let``` are bound to the block they are defined within, but ```var``` is not. Let's take a look at some examples to get a good understanding of what this implies.

Let's look at this ```if``` block. Clearly ```true``` is equal to ```true```, so the code inside of the block will run:

```
if(true){
  var x = 2;
}
console.log(x); // logs 2
```

All of the code within the curly braces are inside of a ***code block*** which has it's own scope. Since ```var``` is not block scoped, it is not bound by the block's scope, and is visible within the ```console.log()```. But let's look at the following variation:


```
if(true){
  let x = 2;
}
console.log(x); // ReferenceError
```

Since ```let``` is block scoped, it is bound by the block's scope and is not visible to the ```console.log()```. Since that's the case, we get a ```ReferenceError``` when attempting to access it. The same would happen here with ```const```.

I want to show you an interesting example using the same example, but let's flip ```true``` to ```false``` and see what happens with hoisting.


```
if(false){
  var x = 2;
}
console.log(x); // logs undefined
```

Since ```var``` is not block-scoped and binding declarations are also hoisted mixed with the fact that ```var``` declarations are evaluated prior to runtime: we get ```undefined``` here. 

The above code can be re-written to look like this:

```
var x;
if(false){
  x = 2;
}
console.log(x); // logs undefined
```

Scope in JavaScript

Though it may often be thought of as science-fiction, a future with super-intelligent machines seems certain and could pose a serious threat to our species. Artificial intelligence is everywhere today. It’s in phones, watches, and even in our cars. Artificial Intelligence is software that has been programmed to analyze and act without direct instructions. A.I. is very powerful, because if a human brain could be emulated, it would be able to solve human problems at a very fast rate. The fast rate comes from engineering faster processing speeds over time. Moore’s Law was an observation by Gordon Moore in 1965 at Intel. According to Moore’s observations, “the number of transistors per square inch on integrated circuits had doubled every year since their invention” (“Moore’s Law”). What this means is A.I.’s ability to think and solve problems will get faster exponentially every year if this trend keeps up like it has for the past fifty years. 

A.I. is  being developed so quickly, that it may reach a dangerous point before safe regulations can be built around it. Artificial intelligence will pose a serious threat to humanity in the form of either destruction or integration, if there are not very strict and carefully thought out regulations in place. This is because of what is known as the Intelligence Explosion. The explanation requires the understanding that recursive self-improvement is the state of a machine where the machine is able to improve upon its own ability to improve upon itself. That sounds pretty out there, but recursion is used everywhere in programming languages. It’s a pattern that computers heavily rely on. The intelligence explosion hypothesis states that if machines were capable of recursive self-improvement, it would lead to the technological singularity, or the insanely uncontrollable rapid growth of Artificial Intelligent systems. So what’s there to worry about? All we have to do is have a big red stop button, right? Well actually it’s not nearly that simple, as I will explain later. For now, just understand that many animals are much stronger than us physically, but it is our intelligence that gives us our ability to be the most dominant species on the planet. Even though it may not be a conscious human intention, humans have caused many species to go extinct. Machines are already much stronger than us, but are nowhere near as intelligent. If machines capable of effortlessly lifting thousands of pounds are granted intelligence much higher than our own, is the possible destruction of our species due to super-intelligent machines truly far-fetched?

Emulating the human brain sounds outlandish until you realize there are organizations dedicated to making this happen. One example is The Blue Brain Project. The Blue Brain Project is a Swiss organization, led by scientists, to emulate the brains of rodents and eventually the human brain itself (“In Brief”). In 2008, Anders Samberg and Nick Bostrom released an incredibly detailed research paper on whole brain emulation or WHE. It’s one hundred thirty pages long and becomes quite technical, but the gist is that there is a solid roadmap for the development of machines capable of WHE (Sandberg and Bostrom). Whole brain emulation is real, it is being developed, and it is clear that we are on track to being able to emulate human brains that are capable of thinking much faster than real human brains. In Sandberg and Bostrom’s paper, they lay out a clear path from scanning human brains all the way to the finished product. This absolutely can not be ignored, and if that isn’t reason enough to consider forms of regulations, let’s look into the technological singularity hypothesis.

Recursive self improvement appears to be widely accepted as the variable that will lead into what is known as the technology singularity. The technology singularity is a hypothesis stating that Artificial Intelligence could greatly overwhelm organic intelligence leading to the overtaking of the human species. Some scientists believe this will occur somewhere around the year 2050 (Shanahan par 2). Overtaken doesn’t necessarily have to mean that we get wiped out, it could also imply that we integrate with the machines in some way. This could be through artificial cognitive enhancement, or even through the process of emulating a person’s brain and placing it inside of a human body. Carter and Nielsen state in the conclusion of their article titled, “Using Artificial Intelligence to Augment Human Intelligence”, that, “It would not be a Singularity in machines. Rather, it would be a Singularity in humanity’s range of thought” (Carter and Nielsen).These concepts can invoke some pretty intense realizations that can cause any normal person to ignore out of disbelief, but let’s look at the current progress of A.I. and determine whether or not it appears to be leading towards singularity.

A robot is running for mayor in Tama City, Japan (O’Leary). Will the robot win? Almost certainly not, but my point here is that this publicity stunt is gathering attention. In my opinion, when something gathers attention it tends to manifest as greater interest by people with influence including investors. I didn’t believe that A.I. was close to actually getting involved with politics, but it appears to already be happening in Japan regardless of how silly it is. A more concerning example of artificial intelligence making its way into the limelight is Apple’s newest phone, the iPhone X. The iPhone X is rocking their new A11 bionic chip (Novet). The chip is designed specifically to handle neural networks, which is a form of artificial intelligence. Specifically, neural networks are designed to process information similarly to the neurons in a brain. Apple executive Phil Schiller stated, “The dual-core A11 bionic neural engine chip can perform 600 billion operations per second” (Novet par 2). Anyone with an iPhone X in their pocket has a very powerful neural network in their pocket. So it’s already in our devices, but does that really imply that we are going to integrate A.I. into our bodies? There are organizations who are exploring this possibility right now. One example is by a machine learning research company called Distill. Through their research, they appear to believe that augmenting human intelligence with artificial intelligence is very possible (Carter and Nielsen). Eric Leuthardt, Professor of Neurological Surgery, Neuroscience, Biomedical Engineering, and Mechanical Engineering & Materials Science Director at the Center For Innovation In Neuroscience and Technology stated in an article written for Psychology Today that, “we absolutely should be augmenting human intelligence” (Leuthardt par 5). He’s not the only one though. A quick Google search will show you that there are an enormous amount of people endorsing the idea of augmenting human intelligence. So this means that it is possible, and it is recommended by experts, but would people reject such operations? This requires a poll, but it is highly doubtful that everyone would reject the opportunity to increase their own capabilities through augmentation. It seems unlikely that if people were told they could double their IQ and completely relieve stress and anxiety, that they would decline.

The next issue that desperately needs to be addressed as soon as possible is the idea that Artificial Intelligence capable of recursive self-improvement would become open-source. Open source software code is software code that is available to the general public to copy and often edit to their liking. The issue here is quite clear. If A.I. capable of recursive self-improvement were leaked and made public, then anyone with any intention could create super intelligent machines. This is a very real danger, as websites such as GitHub thrive off of massive open source communities all over the planet. In fact, A.I. technology has already made its way into the open source world. A bot was released recently that begun swapping celebrity faces with pornographic models by itself. Assistant editor of Motherboard Vice was referenced in an article stating that, “these deep fakes were made possible by adapting an open source machine learning library called TensorFlow” (Oberhaus par 4). This doesn’t present any real danger, but if this happens with matured A.I. technology it could end poorly. In order to ensure this doesn’t happen, there needs to be some form of regulation to prevent it from happening. This gets pretty complex. For instance: who would be held responsible if an A.I. managed to cause damage to property, hurt people, or overtake human intelligence in some way? The developers? The CEO? This question is unanswered, and is a perfect example of what needs to be discussed today. Especially if the technology singularity is expected to happen faster than humans can even perceive. Perhaps companies should be forced to keep their technology proprietary, and be prohibited from making it open source. The downside to this, is that government regulations on business slows progress. At this point we shouldn’t be arguing if the singularity is possible, but instead we should be coming up with solutions to prevent it.

Worse than all of the above are software bugs. Every piece of software is susceptible to bugs. I’ve been a software developer for several years now, and I must say that I do not believe it is possible to have complex bug-less software. A software bug is a problem with the software that the developers did not recognize before releasing it. The typical process for software release will be to release a beta test, where the testers will report as many bugs as possible. After the developers fix as many bugs as possible, they will release the first version to the public, where they will certainly receive many more bug reports. It is an ongoing process of fixing bugs forever. The Dutch scientist Edsger Dijkstra said, “If debugging is the process of removing bugs, then programming must be the process of putting them in” (Ganesh par 6). So with all of that said, A.I. will be susceptible to unexpected glitches. The real fear is a military A.I. weapon glitching and causing damage to innocent people. This sort of thing needs to be acknowledged early and addressed.

So why don’t we just put a big red stop button on the machine, and if it were to act up, we could just shut it down? This is the biggest argument I hear, often when someone is discussing reasons why the singularity seems far fetched to them. Rob Miles, a PhD student at the University of Nottingham stated it well when he said “In almost any situation, being given a new utility function is going to rate very low on your current utility function” (Miles). What he is saying here is that if an A.I. is programmed specifically to learn, understand, and act on a certain focus, the A.I. will find any change to its current function to be going against its current function. If the A.I. is programmed to complete its function, then it could act in a way that prevents you from changing its function. This would happen most likely through deception. To relate this to the point, if there is a red button that will shut the A.I. down, then that big red button is a threat to its current utility function because it could potentially prevent it from completing its task if it were shut down. If there is even a slight possibility that the A.I. could be attempting to deceive its owner, then the A.I. should be deemed dangerous.

The other big argument I often hear against my point is that A.I. wouldn’t be inherently evil. This argument is really silly, because they are relating Artificial Intelligence to human intelligence. Humans have a set of morals that machines absolutely do not have. These are morals that we have developed through thousands of years of natural selection. Intelligence that is programmed into a machine will be without human morals. An A.I. could theoretically be programmed to hold morals, however, they would still be artificial. The morals would still be coming from mathematical functions that are instructing the machine to behave in a particular way. Whether or not this is how our brains operate is a completely different discussion, however, what needs to be taken from my point is that machines will not have morals that are developed through experience and emotion, but rather they will feel as they are programmed to feel. Any development of morals after that will be outside of our hands.
Artificial Intelligence is not currently at the point to where it can pass the Turing Test, however, it is on the fast track to that destination. The Turing Test is passed if an A.I. can effectively convince a human that it is a living being. It is easy to look at where A.I. is today and say that it’s too far away to care right now, but with advancements in machine learning and neural networks, the progress in this area is beginning to exponentially advance at a much higher base rate. Regulations have a stigma to them, and it is completely justifiable to be skeptical when handing the government more power, however when we are dealing with something as powerful as super-intelligent machines, we need to be sure we are taking the future generations’ safety into account. The benefits of A.I. are numerous, but the algorithms must be specific to the goals at hand, and must also be kept private. Super-intelligent machines should never be used as weapons. Only humans are capable of understanding what is right and wrong in the realm of human ethics and morality, so if machines must be used as weapons, they should be controlled fully by human minds. The future of artificial intelligence is still unknown, but now is the time to start thinking about how to ensure it is safe.

##### Works Cited

Carter, Shan, and Michael Nielsen. “Using Artificial Intelligence to Augment Human
Intelligence.” Distill, 21 Dec. 2017, distill.pub/2017/aia/.

Ganesh, S. “Joy of Programming: Why Is a Software Glitch Called a 'Bug'?” Open Source For
You, 29 June 2016, opensourceforu.com/2012/03/joy-of-programming-why-software-glitch-called-bug/.

“In Brief.” About Blue Brain EPFL, 1 Nov. 2017, bluebrain.epfl.ch/page-56882-en.html.

Leuthardt, Eric. “A Case for Neural Augmentation.” Psychology Today, Sussex Publishers,
www.psychologytoday.com/us/blog/mind-blender/201710/case-neural-augmentation.

“Moore's Law.” Encyclopædia Britannica, Encyclopædia Britannica, Inc., 29 Nov. 2017, 
www.britannica.com/technology/Moores-law.

“Moore's Law 40th Anniversary”, www.intel.com/pressroom/kits/events/moores_law_40th/.

Novet, Jordan. “Apple Packed an AI Chip into the IPhone X.” CNBC, CNBC, 12 Sept. 2017,
www.cnbc.com/2017/09/12/apple-unveils-a11-bionic-neural-engine-ai-chip-in-iphone-x.html.

Oberhaus, Daniel. “Top Researchers Write 100-Page Report Warning About AI Threat to
Humanity.” Motherboard, 21 Feb. 2018, motherboard.vice.com/en_us/article/a34nm4/ai-report-oxford-malicious-weapons.

O'Leary, Abigail, and Anna Verdon. “Robot to Run for Mayor in Japan Promising 'Fairness and
Balance' for All.” Mirror, 18 Apr. 2018, www.mirror.co.uk/tech/robot-run-mayor-japan-world-12377782.

Sandberg, Anders and Nick Bostrom. Whole Brain Emulation: A Roadmap, FHI. The Future of
Humanity Institute, 2008. http://www.fhi.ox.ac.uk/reports/2008-3.pdf.

Shanahan, Murray, et al. “The Technological Singularity.” The MIT Press, The MIT Press,
mitpress.mit.edu/books/technological-singularity.

Artificial Intelligence is here today, and we need to ensure it remains safe.

Why Regulations On Artificial Intelligence Should Be Discussed Today

Dear Ajit Pai,

You state that you are [“in favor of a free and open Internet”](https://www.pbs.org/newshour/show/fcc-chair-ajit-pai-explains-wants-scrap-net-neutrality) for American citizens, however, your recent announcement on voting to repeal the FCC’s Open Internet Order directly contradicts any such statement of supporting a free and open Internet. Protecting Internet neutrality is absolutely vital for the American Internet to continue to grow organically. You state that the Title II regulations do more harm than good for the American people in regards to Internet access, and that without these regulations, the evolution of the Internet would then be in the hands of [“engineers and entrepreneurs”](https://www.politico.com/story/2017/11/22/ajit-pai-fcc-defends-net-neutrality-repeal-25816), however, I argue that it would be giving the power to large corporations who will attempt to use this power only for profit. I would like to address several of the points that you made in an interview with PBS released on April 27, 2017.

The first argument that you made was your concern that companies would become disincentivized to build out Internet access to low-income, rural parts of the country that do not yet have access. While it may be true that investments in infrastructure have gone down since the these regulations have been put into place, it has not been long enough to determine if this decline would continue. It makes sense that large companies such as Comcast would take a hit at first, before eventually adapting to these regulations. It is important to note here, that it is the companies who should adapt to supply the demands of the consumers, and not the other way around. If there is a demand for Internet access in low-income parts of the country, it is up to these companies to innovate new ways to reach out to poor and rural areas to supply Internet access. Facebook is a known company who is constantly innovating [new ways](https://info.internet.org/en/) to connect different parts of the world that would otherwise not have Internet access. Why is it that ISPs and cable companies should be given the easy way out, at the expense of the user experience of American citizens? The only answer could be immediate profit. Our economy thrives on the idea that, in order to survive in business, you must be able to supply the demands of the consumers. By attempting to remove the Open Internet Order rules, you are showing that you have no true interest in innovation, rather, you are interested in seeing these companies profit immediately. Why is that?

You state that you are in favor of a [“light-touch regulatory framework”](https://www.pbs.org/newshour/show/fcc-chair-ajit-pai-explains-wants-scrap-net-neutrality), that allows the Internet market to grow without influence, other than the occasional slap on the wrist if necessary. I argue that without regulations on ISPs, the Internet will grow far less organically than otherwise. It is common sense to assume that large Internet service companies are interested in profit. Why else would they be in business? The current regulations that are in place prevent these companies from throttling Internet access or favoring different forms of Internet traffic. If these companies were allowed, they would favor their own services over other companies. For instance, let’s say “ISP A” has a movie streaming service that competes directly with Netflix. “ISP A” would love to provide faster Internet traffic for their own video streaming service and throttle the traffic to and from Netflix’s servers in order to persuade users to enjoy the faster and more reliable “ISP A” video service. Under Net Neutrality rules, “ISP A” is unable to do this because it distorts the neutral platform that the video streaming service flows through. It directly gives “ISP A” an unfair advantage over Netflix. In what way does this sort of behavior promote organic market growth? It sounds much more like a monopoly, doesn’t it? You argue that the FCC [does not see evidence of this in the Marketplace](https://www.pbs.org/newshour/show/fcc-chair-ajit-pai-explains-wants-scrap-net-neutrality). Allow me to present some examples of this happening in the past. In 2004-2005 Madison River Communications, a telecommunications company and ISP, was caught [blocking VoIP (Voice Over IP) communications](https://www.cnet.com/news/telco-agrees-to-stop-blocking-voip-calls/), forcing their customers to use Madison River’s telecommunication services. In 2007, Comcast was [tampering with BitTorrent traffic](https://bits.blogs.nytimes.com/2007/10/22/comcast-were-delaying-not-blocking-bittorrent-traffic/) in order to free up resources for their other customers. In 2012, AT&T was blocking FaceTime calls unless customers signed up for a more expensive package (Kang, Washington Post). In 2002, [Comcast was blocking VPN (Virtual Private Network) access](http://www.practicallynetworked.com/news/comcast.htm) unless customers signed up for a more expensive package. We can learn from history that these companies will undoubtedly discriminate against forms of Internet traffic for profit if they are allowed.

The final point that I would like to address from your interview with PBS, Mr. Pai, is that you mention you’ve spoken to consumers from all over the country, and they have expressed more of an interest in being able to have more options for ISPs, and cheaper Internet prices over interests in Net Neutrality. The issue that I see with this argument, is that there are studies that show that consumers do not often directly know what they want or what is best for them, and that ignorance can play a huge role in the opinions people express. If consumers knew what they wanted, it would be very easy to start a successful business. You’d simply ask people what they wanted and then offer it as a product or service. That is simply not the reality. Mark Healy released an article for The Globe And Mail showing research that he was a part of, that shows that consumers typically are [unable to accurately predict their future intentions](https://www.theglobeandmail.com/report-on-business/small-business/sb-marketing/the-three-problems-with-customer-surveys/article600084/). Tack that on to the potential ignorance of what their Internet service would be like without Title II regulations, and you have an argument with absolutely no foundation. How can you truly take into account the feedback of consumers of your own choosing, but ignore the educated people who try to reach out to you against your actions? You are cherry picking statements from the people in order to suit your interests.

The concern of your decisions is not only external. Jessica Rosenworcel, Commissioner of the FCC, constantly speaks out about how this is a poor decision on your end, and is constantly trying to get the American people to protest. Rosenworcel [tweets to the public about this almost every day](https://twitter.com/JRosenworcel). The arguments you provide always seem to make sense at first, until you are asked if ISPs will begin discriminating against forms of broadband traffic, at which point your arguments fall to pieces. It is clear that ISPs want to profit from a lack of Net Neutrality regulations, because it gives them access to “Easy Street”. ISPs should be forced to innovate and engineer new ways to provide better, faster, and more secure Internet access to a broader spectrum of people without consumers having to lose privileges. The Darwinian nature of competition between ISPs is why we have had such a thriving technology revolution here in America. History clearly shows that Title II and the Open Internet Order are necessary to maintain the neutral platform that secures organic growth among the Internet market.

In this direct letter to Ajit Pai of the FCC, I challenge three of his arguments one at a time.

A Letter To The FCC Chairman

## Sometimes it can be tempting to write a bunch of one-liners, and begin abstracting all of your code into functions that allow you to write less code in the future..

However, what would your future self think when they see this code? What if you don't remember what functionality you're abstracting with your cryptic-looking fancy design pattern? Good documentation could remediate that, but what if new developers come into this codebase? Other people think differently, and it can be difficult for people to wrap their heads around your very specific way of thinking.

# In the end I believe code understandability is the key to maintaining a code base for long periods of time.

This is because it leads to less burn-out, and it is much easier for on-boarding newbies onto the codebase. As a developer matures into their career, they tend to realize that it's not all about them. Writing good code is about writing code that is good for everyone who is involved, or who could be involved in the future. Including the end user :)

A Clean and Understandable Codebase Is An Enjoyable Codebase

Memoir #3 - Code Understandability

## Burn-out can occur when you're super excited about a new project. 

The excitement of working on something you enjoy can seduce you into working past your mental threshold. Doing this enough days in a row simply leads to lack of mental clarity, which leads down a road of decline and eventually burn-out. Take a break and reset. Better yet: take breaks right as you're approaching the threshold throughout the day.

If you reach burn-out, take a more serious break. Take a few sick days and binge watch some Netflix. Take walks and let your mind clear. Remember what it's like to be human.

Then get back to it, ***but be responsible***.

Sometimes Less Is More With Heavy Cognitive Tasks

Memoir #2 - Burning Out

## It's impossible to anticipate `exactly` what your software code is going to look like after finishing a new feature. 

That is.. unless you're one of the greatest software engineers in the world. In which case, this memoir should mean nothing to you. But for the rest of us mere mortals, we need to accept that fact. And with that fact in the back of our heads: **we can design our software incrementally in such a way that if the code of "feature 1" is spaghetti, it will not affect the code quality of "feature 2"**. This prevents us from compounding messy code throughout the entire code base. It also allows us the ability (if desired) to revisit features to improve code quality.

Regardless, it is important to take time to think and attempt to anticipate the design of your code before you begin writing. Afterwards, reflect and think about what you could have done to obtain the code quality that you originally anticipated. This cycle will make you a better programmer.

The first of a series of documented thoughts and lessons learned as a professional software engineer

Programming Casually

Follow Me Here

Featured Video

Posts

> Scope in JavaScript

> Why Regulations On Artificial Intelligence Should Be Discussed Today

> A Letter To The FCC Chairman

> Memoir #3 - Code Understandability

> Memoir #2 - Burning Out

> Memoir #1 - Anticipation Of Clean Code