Node has been around since 2009 and takes a different approach than other programming languages. It is a JavaScript framework that can be used to make server applications. It runs in a single non-blocking thread. Where different frameworks, such as Java, support multiple concurrent threads, this may seem like a major weakness. However, since Node executes in a non-blocking manner, it can support a large number of concurrent users without having to synchronize objects in memory across threads. Both approaches have their strengths and weaknesses, but this concept is critically important to Node development and seems really strange at first.
In my git repository (more on this later), I have included three really basic node scripts that demonstrate some weird behavior. Example 1 looks like this:
var i = 1; console.log('Initial value ' + i); addOneHunder(); console.log('Value after function called ' + i); function addOneHunder() { i += 100; }
In this humble example, a global variable called i is instantiated (this is a big fancy word meant to intimidate non-programmers, all it means is we are creating a new variable or object). The console displays an initial value for i of 1. A function is called adding 100 to the global variable and the console displays the final value of i as 101. All of this should seem perfectly normal.
Example 2:
var i = 1; console.log('Initial value ' + i); setTimeout(addOneHunder, 2000); console.log('Value after function called ' + i); function addOneHunder() { i += 100; }
Again, a global variable is instantiated with a value of 1. The value is displayed and the setTimeout tells the process to wait for two seconds and then call the addOneHundred function. If you were to run this from your command line, the output would be:
Initial value 1
Value after function called 1
The command window would seem to hang for a few moments and then the command prompt reappears. What the heck just happened??? This demonstrates the non-blocking nature of Node. The first two console statements execute, then the addOneHundred function is called two seconds later, and the process ends because there is nothing else to do. Things are not flowing from top to bottom which seems really strange at first, but it is also powerful.
In my final example, the code looks like this:
var i = 1; console.log('Initial value ' + i); setTimeout(callAddOneHundred, 2000); console.log('Value after function called ' + i); function callAddOneHundred() { addOneHunder(function() { console.log('After waiting two seconds i = ' + i); }) } function addOneHunder(cb) { i = 'magic!'; cb(); }In this simple example, I have added the concept of a callback. Callbacks are usually anonymous functions that are passed as part of the signature. That's right Node/JavaScript allows a function to be passed to a function. The function callAddOneHundred calls addOneHundred and then executes the anonymous function. Additionally, the variable i started out as an integer and then became a String. If this were Java, the compiler would have thrown a fit. However, Node simply shrugs its shoulders.When I describe NodeJs versus Java, imagine you have two different English professors. For a mid-term assignment, you write a ten page essay. You work on it very hard, do your research, make compelling points, and add a little humor. You are very proud of your essay. You give the essay to Professor Java and this professor gives you an F because you accidentally used "there" instead of "their" in the middle of the very last paragraph. Then you give the exact same essay, typo and all, to Professor Node. Professor Node gives you an A and says that she knew what you meant and it did not negate all of the effort over one little mistake. Neither approach is right in programming and some like the strictness that Java enforces.Another little goody to Node is it comes bundled with NPM. NPM is a repository of (mostly) open source code that can be added to your application with almost zero effort. From the command line, simply type:sudo npm (package name) --saveThe project's package.json is updated and the package is installed as a dependency. In my git repo, I do not include the third party packages I used. Instead, the user is expected to run npm install. If any changes are made to the packages, I can either lock the version to what I have tested against or run npm update. Although Java has integrations like Maven, it is not part of standard Java. I have worked at plenty of places that steadfastly refuse to use Maven, making it nearly impossible to bring in third party software. Given the wide variety of excellent free and open source software that is readily available, this approach is quite limiting.Finally, I've been blathering about my git repo. Git is simply a source control tool. It might be overkill for this modest project, but I am trying to demonstrate concepts that would be used by a real agile team. Using git, multiple people can work on the same code simultaneously. Typically, a developer will clone the original repo and then create a feature branch. When the developer is satisfied that they have met the requirements of the feature, they check it into the repo and create a pull request. Usually, another team member will review the pull request. Using github, it is easy to see what modifications have been made between the original branch and the feature branch. If everything looks good, they feature branch is merged. At any point developers can pull code from the repo so that their feature branch does not deviate too far from the main branch. Tools exist to handle the dreaded merge conflict, but these should not happen often.As promised, I took the first part of the epic and broke them into stories below. Each story represents a branch in my git repo and since I'm the sole developer, I merged my own pull requests although this is considered a worst practice.
