diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..960e94a
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,88 @@
+---
+# Mapbox.Variant C/C+ style
+Language:        Cpp
+AccessModifierOffset: -2
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlinesLeft: false
+AlignOperands:   true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: true
+AllowShortLoopsOnASingleLine: true
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: true
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterClass:      true
+  AfterControlStatement: true
+  AfterEnum:       true
+  AfterFunction:   true
+  AfterNamespace:  false
+  AfterObjCDeclaration: true
+  AfterStruct:     true
+  AfterUnion:      true
+  BeforeCatch:     true
+  BeforeElse:      true
+  IndentBraces:    false
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Custom
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+ColumnLimit:     0
+CommentPragmas:  '^ IWYU pragma:'
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
+IncludeCategories:
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority:        2
+  - Regex:           '^(<|"(gtest|isl|json)/)'
+    Priority:        3
+  - Regex:           '.*'
+    Priority:        1
+IndentCaseLabels: false
+IndentWidth:     4
+IndentWrappedFunctionNames: false
+KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Left
+ReflowComments:  true
+SortIncludes:    true
+SpaceAfterCStyleCast: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard:        Cpp11
+TabWidth:        4
+UseTab:          Never
\ No newline at end of file
diff --git a/.travis.yml b/.travis.yml
index b02778f..c1831e2 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -19,17 +19,21 @@ install:
   - which clang++
   - make ${BUILDTYPE}
 
-# run tests
-# We use before_script rather than script to ensure fast failure (the script section continues even after an error)
-# https://docs.travis-ci.com/user/customizing-the-build#Breaking-the-Build
+# *Here we run tests*
+# We prefer running tests in the 'before_script' section rather than 'script' to ensure fast failure.
+# Be aware that if you use the 'script' section it will continue running all commands in the section even if one line fails.
+# This is documented at https://docs.travis-ci.com/user/customizing-the-build#Breaking-the-Build
+# We don't want this behavior because otherwise we might risk publishing builds when the tests did not pass.
+# For this reason, we disable the 'script' section below, since we prefer using 'before_script'.
 before_script:
   - npm test
   # after successful tests, publish binaries if specified in commit message
   - ./scripts/publish.sh --toolset=${TOOLSET:-} --debug=$([ "${BUILDTYPE}" == 'debug' ] && echo "true" || echo "false")
 
-# override script default (npm test) to do nothing (we test in before_script)
-script:
-  - true
+# We set 'script' here to an empty array to prevent this section from automatically running 'npm test'
+# The reason we do this is mentioned above in the comment about the 'before_script' stage.
+# For reference, the default travis behavior which we override comes from https://github.com/travis-ci/travis-build/blob/e5a45cbf49e0d9e27398e76e5f25dd7706feb6aa/lib/travis/build/script/node_js.rb#L62-L69.
+script: []
 
 # the matrix allows you to specify different operating systems and environments to 
 # run your tests and build binaries
@@ -113,3 +117,13 @@ matrix:
         - curl -S -f https://codecov.io/bash -o codecov
         - chmod +x codecov
         - ./codecov -x "llvm-cov gcov" -Z
+    # Clang format build
+    - os: linux
+      language: generic
+      env: BUILDTYPE=debug
+      node_js: 4
+      # Overrides `install` to avoid initializing clang toolchain
+      install: 
+        - ./scripts/format.sh
+      # Overrides `script`, no need to run tests
+      before_script:
\ No newline at end of file
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..148cb32
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,4 @@
+# Developer
+
+We use [`clang-format`](https://clang.llvm.org/docs/ClangFormat.html) version [4.0.0](https://github.com/mapbox/mason/tree/master/scripts/clang-format) to consistently format the code base. The format is automatically checked via a Travis CI build as well. Run the following script locally to ensure formatting is ready to merge:
+`./scripts/format.sh`
\ No newline at end of file
diff --git a/scripts/format.sh b/scripts/format.sh
new file mode 100755
index 0000000..3f36e86
--- /dev/null
+++ b/scripts/format.sh
@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+
+set -eu
+set -o pipefail
+
+: '
+
+Runs clang-format on the code in src/
+
+Return `1` if there are files to be formatted, and automatically formats them.
+
+Returns `0` if everything looks properly formatted.
+
+'
+ # Set up the environment by installing mason and clang++
+ # See https://github.com/mapbox/node-cpp-skel/blob/master/docs/extended-tour.md#configuration-files
+./scripts/setup.sh --config local.env
+source local.env
+
+# Add clang-format as a dep
+mason install clang-format ${MASON_LLVM_RELEASE}
+mason link clang-format ${MASON_LLVM_RELEASE}
+
+# Run clang-format on all cpp and hpp files in the /src directory
+find src/ -type f -name '*.hpp' -o -name '*.cpp' \
+ | xargs -I{} clang-format -i -style=file {}
+
+# Print list of modified files
+dirty=$(git ls-files --modified src/)
+
+if [[ $dirty ]]; then
+    echo "The following files have been modified:"
+    echo $dirty
+    exit 1
+else
+    exit 0
+fi
\ No newline at end of file
diff --git a/src/module.cpp b/src/module.cpp
index 613525a..ea59b11 100644
--- a/src/module.cpp
+++ b/src/module.cpp
@@ -1,32 +1,36 @@
-#include <nan.h>
+#include "object_async/hello_async.hpp"
+#include "object_sync/hello.hpp"
 #include "standalone/hello.hpp"
 #include "standalone_async/hello_async.hpp"
-#include "object_sync/hello.hpp"
-#include "object_async/hello_async.hpp"
+#include <nan.h>
 // #include "your_code.hpp"
 
 // "target" is a magic var that nodejs passes into a module's scope.
-// When you write things to target, they become available to call from Javascript world.
-static void init(v8::Local<v8::Object> target) {
+// When you write things to target, they become available to call from
+// Javascript world.
+static void init(v8::Local<v8::Object> target)
+{
 
     // expose hello method
     Nan::SetMethod(target, "hello", standalone::hello);
-    
+
     // expose helloAsync method
     Nan::SetMethod(target, "helloAsync", standalone_async::helloAsync);
 
     // expose HelloObject class
     object_sync::HelloObject::Init(target);
-    
+
     // expose HelloObjectAsync class
     object_async::HelloObjectAsync::Init(target);
 
-   /**
-    * You may have noticed there are multiple "hello" functions as part of this module.
-    * They are exposed a bit differently.
-    * 1) standalone::hello    // exposed above
-    * 2) HelloObject.hello    // exposed in object_sync/hello.cpp as part of HelloObject
-    */
+    /**
+   * You may have noticed there are multiple "hello" functions as part of this
+   * module.
+   * They are exposed a bit differently.
+   * 1) standalone::hello    // exposed above
+   * 2) HelloObject.hello    // exposed in object_sync/hello.cpp as part of
+   * HelloObject
+   */
 
     // add more methods/classes below that youd like to use in Javascript world
     // then create a directory in /src with a .cpp and a .hpp file.
diff --git a/src/module_utils.hpp b/src/module_utils.hpp
index be643b1..8d40302 100644
--- a/src/module_utils.hpp
+++ b/src/module_utils.hpp
@@ -3,23 +3,27 @@
 
 namespace utils {
 
-  /*
-  * This is an internal function used to return callback error messages instead of
-  * throwing errors.
-  * Usage:
-  *
-  * v8::Local<v8::Function> callback;
-  * return CallbackError("error message", callback);  // "return" is important to prevent duplicate callbacks from being fired!
-  * 
-  *
-  * "inline" is important here as well. See for more contex:
-  * - https://github.com/mapbox/node-cpp-skel/pull/52#discussion_r126847394 for context
-  * - https://github.com/mapbox/cpp/pull/29 ...eventually point this to glossary when it merges
-  * 
-  */
-  inline void CallbackError(std::string message, v8::Local<v8::Function> callback) {
-  	v8::Local<v8::Value> argv[1] = { Nan::Error(message.c_str()) };
-  	Nan::MakeCallback(Nan::GetCurrentContext()->Global(), callback, 1, argv);
-  }
-
+/*
+* This is an internal function used to return callback error messages instead of
+* throwing errors.
+* Usage:
+*
+* v8::Local<v8::Function> callback;
+* return CallbackError("error message", callback);  // "return" is important to
+* prevent duplicate callbacks from being fired!
+*
+*
+* "inline" is important here as well. See for more contex:
+* - https://github.com/mapbox/node-cpp-skel/pull/52#discussion_r126847394 for
+* context
+* - https://github.com/mapbox/cpp/pull/29 ...eventually point this to glossary
+* when it merges
+*
+*/
+inline void CallbackError(std::string message,
+                          v8::Local<v8::Function> callback)
+{
+    v8::Local<v8::Value> argv[1] = {Nan::Error(message.c_str())};
+    Nan::MakeCallback(Nan::GetCurrentContext()->Global(), callback, 1, argv);
+}
 }
\ No newline at end of file
diff --git a/src/object_async/hello_async.cpp b/src/object_async/hello_async.cpp
index 6b67657..fec53d5 100644
--- a/src/object_async/hello_async.cpp
+++ b/src/object_async/hello_async.cpp
@@ -2,9 +2,9 @@
 #include "../module_utils.hpp"
 
 #include <exception>
-#include <stdexcept>
 #include <iostream>
 #include <map>
+#include <stdexcept>
 
 /**
  * Asynchronous class, called HelloObjectAsync
@@ -16,7 +16,7 @@
 
 /**
  * Say hello while doing expensive work in threads
- * 
+ *
  * @name helloAsync
  * @memberof HelloObjectAsync
  * @param {Object} args - different ways to alter the string
@@ -35,59 +35,65 @@
 // If this was not defined within a namespace, it would be in the global scope.
 namespace object_async {
 
-  // Custom constructor, assigns custom name arg passed in from Javascript world.
-  // This constructor uses member init list via the colon, aka "direct initialization", which is more efficient than using assignment operators.
-  // This constructor is using move semantics to literally "move" the value of name to a new place in memory (to the "name_" variable).
-  // This avoids copying the value and duplicating memory allocation, which can negatively affect performance.
-  HelloObjectAsync::HelloObjectAsync(std::string && name) : 
-    name_(std::move(name)) {} 
-
-
-  // Triggered from Javascript world when calling "new HelloObjectAsync(name)"
-  NAN_METHOD(HelloObjectAsync::New) {
+// Custom constructor, assigns custom name arg passed in from Javascript world.
+// This constructor uses member init list via the colon, aka "direct
+// initialization", which is more efficient than using assignment operators.
+// This constructor is using move semantics to literally "move" the value of
+// name to a new place in memory (to the "name_" variable).
+// This avoids copying the value and duplicating memory allocation, which can
+// negatively affect performance.
+HelloObjectAsync::HelloObjectAsync(std::string&& name)
+    : name_(std::move(name)) {}
+
+// Triggered from Javascript world when calling "new HelloObjectAsync(name)"
+NAN_METHOD(HelloObjectAsync::New)
+{
     if (info.IsConstructCall())
     {
         try
-        {   
-            if (info.Length() >= 1) {
-              if (info[0]->IsString()) 
-              {
-                // Don't want to risk passing a null string around, which might create unpredictable behavior.
-                Nan::Utf8String utf8_value(info[0]);
-                int len = utf8_value.length();
-                if (len <= 0) {
-                   return Nan::ThrowTypeError("arg must be a non-empty string");
+        {
+            if (info.Length() >= 1)
+            {
+                if (info[0]->IsString())
+                {
+                    // Don't want to risk passing a null string around, which might create unpredictable behavior.
+                    Nan::Utf8String utf8_value(info[0]);
+                    int len = utf8_value.length();
+                    if (len <= 0)
+                    {
+                        return Nan::ThrowTypeError("arg must be a non-empty string");
+                    }
+
+                    // This line converts a V8 string to a C++ std::string.
+                    // In the background, it triggers memory allocation (stack allocating, but std:string is also dynamically allocating memory in the heap)
+                    // We want to avoid heap allocation to ensure more performant code.
+                    // See https://github.com/mapbox/cpp/blob/master/glossary.md#stack-allocation
+                    // and https://stackoverflow.com/questions/79923/what-and-where-are-the-stack-and-heap/80113#80113
+                    // Also, providing the length allows the std::string constructor to avoid calculating the length internally
+                    // and should be faster since it skips an operation.
+                    std::string name(*utf8_value, len);
+
+                    // This line is where HelloObjectAsync takes ownership of "name" with the use of move semantics.
+                    // Then all later usage of "name" are passed by reference (const&), but the actual home or address in memory
+                    // will always be owned by this instance of HelloObjectAsync. Generally important to know what has ownership of an object.
+                    // When a object/value is a member of a class (like "name"), we know the class (HelloObjectAsync) has full control of the scope of the object/value.
+                    // This avoids the scenario of an object/value being destroyed or becoming out of scope.
+                    auto* const self = new HelloObjectAsync(std::move(name));
+                    self->Wrap(info.This()); // Connects C++ object to Javascript object (this)
                 }
-
-                // This line converts a V8 string to a C++ std::string.
-                // In the background, it triggers memory allocation (stack allocating, but std:string is also dynamically allocating memory in the heap)
-                // We want to avoid heap allocation to ensure more performant code.
-                // See https://github.com/mapbox/cpp/blob/master/glossary.md#stack-allocation
-                // and https://stackoverflow.com/questions/79923/what-and-where-are-the-stack-and-heap/80113#80113
-                // Also, providing the length allows the std::string constructor to avoid calculating the length internally 
-                // and should be faster since it skips an operation. 
-                std::string name(*utf8_value, len);
-                
-                // This line is where HelloObjectAsync takes ownership of "name" with the use of move semantics.
-                // Then all later usage of "name" are passed by reference (const&), but the actual home or address in memory 
-                // will always be owned by this instance of HelloObjectAsync. Generally important to know what has ownership of an object. 
-                // When a object/value is a member of a class (like "name"), we know the class (HelloObjectAsync) has full control of the scope of the object/value. 
-                // This avoids the scenario of an object/value being destroyed or becoming out of scope.
-                auto *const self = new HelloObjectAsync(std::move(name));
-                self->Wrap(info.This());  // Connects C++ object to Javascript object (this)
-              }
-              else
-              {
+                else
+                {
+                    return Nan::ThrowTypeError(
+                        "arg must be a string");
+                }
+            }
+            else
+            {
                 return Nan::ThrowTypeError(
-                    "arg must be a string");
-              }
-            } else {
-              return Nan::ThrowTypeError(
                     "must provide string arg");
             }
-
         }
-        catch (const std::exception &ex)
+        catch (const std::exception& ex)
         {
             return Nan::ThrowTypeError(ex.what());
         }
@@ -99,96 +105,121 @@ namespace object_async {
         return Nan::ThrowTypeError(
             "Cannot call constructor as function, you need to use 'new' keyword");
     }
-  }
+}
 
+// This function performs expensive allocation of std::map, querying, and string
+// comparison, therefore threads are nice & busy.
+// Also, notice that name is passed by reference (std::string const& name)
+std::string do_expensive_work(bool louder, std::string const& name)
+{
 
-  // This function performs expensive allocation of std::map, querying, and string comparison, therefore threads are nice & busy.
-  // Also, notice that name is passed by reference (std::string const& name)
-  std::string do_expensive_work(bool louder, std::string const& name) {  
+    std::map<std::size_t, std::string> container;
+    std::size_t work_to_do = 100000;
 
-      std::map<std::size_t,std::string> container;  
-      std::size_t work_to_do=100000;
+    for (std::size_t i = 0; i < work_to_do; ++i)
+    {
+        container.emplace(i, std::to_string(i));
+    }
 
-      for (std::size_t i=0;i<work_to_do;++i) {
-          container.emplace(i,std::to_string(i));
-      }  
+    for (std::size_t i = 0; i < work_to_do; ++i)
+    {
+        std::string const& item = container[i];
+        if (item != std::to_string(i))
+        {
 
-      for (std::size_t i=0;i<work_to_do;++i) {
-          std::string const& item = container[i];
-          if (item != std::to_string(i)) {
+            // AsyncHelloWorker's Execute function will take care of this error
+            // and return it to js-world via callback
+            throw std::runtime_error("Uh oh, this should never happen");
+        }
+    }
 
-              // AsyncHelloWorker's Execute function will take care of this error 
-              // and return it to js-world via callback
-              throw std::runtime_error("Uh oh, this should never happen");
-          }
-      }  
+    std::string result = "...threads are busy async bees...hello " + name;
 
-      std::string result = "...threads are busy async bees...hello " + name;
- 
-      if (louder)
-      {
+    if (louder)
+    {
         result += "!!!!";
-      }
-     
-      return result;  
-
-  }  
-
-  // This is the worker running asynchronously and calling a user-provided callback when done.
-  // Consider storing all C++ objects you need by value or by shared_ptr to keep them alive until done.
-  // Nan AsyncWorker docs: https://github.com/nodejs/nan/blob/master/doc/asyncworker.md
-  struct AsyncHelloWorker : Nan::AsyncWorker {
-
-      using Base = Nan::AsyncWorker;  
-
-      AsyncHelloWorker(bool louder, std::string const& name, Nan::Callback* callback)
-          : Base(callback), result_{""}, louder_{louder}, name_{name} { }  
-
-      // The Execute() function is getting called when the worker starts to run.
-      // - You only have access to member variables stored in this worker.
-      // - You do not have access to Javascript v8 objects here.
-      void Execute() override {
-          try {
-              result_ = do_expensive_work(louder_, name_);
-          } catch (const std::exception& e) {
-              SetErrorMessage(e.what());
-          }
-      }  
-
-      // The HandleOKCallback() is getting called when Execute() successfully completed.
-      // - In case Execute() invoked SetErrorMessage("") this function is not getting called.
-      // - You have access to Javascript v8 objects again
-      // - You have to translate from C++ member variables to Javascript v8 objects
-      // - Finally, you call the user's callback with your results
-      void HandleOKCallback() override {
-          Nan::HandleScope scope;  
-
-          const auto argc = 2u;
-          v8::Local<v8::Value> argv[argc] = {Nan::Null(), Nan::New<v8::String>(result_).ToLocalChecked()};  
-
-          callback->Call(argc, argv);
-      }  
-
-      std::string result_;
-      const bool louder_;
-      // We are taking a reference to the name instance passed in from instantiating HelloObjectAsync above (HelloObjectAsync::New)
-      std::string const& name_;
-  };  
-
-
-  NAN_METHOD(HelloObjectAsync::helloAsync) {
-    // "info" comes from the NAN_METHOD macro, which returns differently according to the Node version
-    // "What is node::ObjectWrap???" The short version is that node::ObjectWrap and wrapping/unwrapping objects 
-    // is the somewhat clumsy way it is possible to bind Node and C++. The main points to remember:
-    // - To access a class instance inside a C++ static method, you must unwrap the object.
-    // - The C++ methods must be static to make them available at startup across the language boundary (JS <-> C++).
-    HelloObjectAsync* h = Nan::ObjectWrap::Unwrap<HelloObjectAsync>(info.Holder());
+    }
+
+    return result;
+}
+
+// This is the worker running asynchronously and calling a user-provided
+// callback when done.
+// Consider storing all C++ objects you need by value or by shared_ptr to keep
+// them alive until done.
+// Nan AsyncWorker docs:
+// https://github.com/nodejs/nan/blob/master/doc/asyncworker.md
+struct AsyncHelloWorker : Nan::AsyncWorker
+{
+
+    using Base = Nan::AsyncWorker;
+
+    AsyncHelloWorker(bool louder, std::string const& name,
+                     Nan::Callback* callback)
+        : Base(callback), result_{""}, louder_{louder}, name_{name} {}
+
+    // The Execute() function is getting called when the worker starts to run.
+    // - You only have access to member variables stored in this worker.
+    // - You do not have access to Javascript v8 objects here.
+    void Execute() override
+    {
+        try
+        {
+            result_ = do_expensive_work(louder_, name_);
+        }
+        catch (const std::exception& e)
+        {
+            SetErrorMessage(e.what());
+        }
+    }
+
+    // The HandleOKCallback() is getting called when Execute() successfully
+    // completed.
+    // - In case Execute() invoked SetErrorMessage("") this function is not
+    // getting called.
+    // - You have access to Javascript v8 objects again
+    // - You have to translate from C++ member variables to Javascript v8 objects
+    // - Finally, you call the user's callback with your results
+    void HandleOKCallback() override
+    {
+        Nan::HandleScope scope;
+
+        const auto argc = 2u;
+        v8::Local<v8::Value> argv[argc] = {
+            Nan::Null(), Nan::New<v8::String>(result_).ToLocalChecked()};
+
+        callback->Call(argc, argv);
+    }
+
+    std::string result_;
+    const bool louder_;
+    // We are taking a reference to the name instance passed in from instantiating
+    // HelloObjectAsync above (HelloObjectAsync::New)
+    std::string const& name_;
+};
+
+NAN_METHOD(HelloObjectAsync::helloAsync)
+{
+    // "info" comes from the NAN_METHOD macro, which returns differently according
+    // to the Node version
+    // "What is node::ObjectWrap???" The short version is that node::ObjectWrap
+    // and wrapping/unwrapping objects
+    // is the somewhat clumsy way it is possible to bind Node and C++. The main
+    // points to remember:
+    // - To access a class instance inside a C++ static method, you must unwrap
+    // the object.
+    // - The C++ methods must be static to make them available at startup across
+    // the language boundary (JS <-> C++).
+    HelloObjectAsync* h =
+        Nan::ObjectWrap::Unwrap<HelloObjectAsync>(info.Holder());
 
     bool louder = false;
 
     // Check second argument, should be a 'callback' function.
-    // This allows us to set the callback so we can use it to return errors instead of throwing.
-    // Also, "info" comes from the NAN_METHOD macro, which returns differently according to the version of node
+    // This allows us to set the callback so we can use it to return errors
+    // instead of throwing.
+    // Also, "info" comes from the NAN_METHOD macro, which returns differently
+    // according to the version of node
     if (!info[1]->IsFunction())
     {
         return Nan::ThrowTypeError("second arg 'callback' must be a function");
@@ -198,66 +229,81 @@ namespace object_async {
     // Check first argument, should be an 'options' object
     if (!info[0]->IsObject())
     {
-        return utils::CallbackError("first arg 'options' must be an object", callback);
+        return utils::CallbackError("first arg 'options' must be an object",
+                                    callback);
     }
     v8::Local<v8::Object> options = info[0].As<v8::Object>();
 
-    // Check options object for the "louder" property, which should be a boolean value
+    // Check options object for the "louder" property, which should be a boolean
+    // value
     if (options->Has(Nan::New("louder").ToLocalChecked()))
     {
-        v8::Local<v8::Value> louder_val = options->Get(Nan::New("louder").ToLocalChecked());
+        v8::Local<v8::Value> louder_val =
+            options->Get(Nan::New("louder").ToLocalChecked());
         if (!louder_val->IsBoolean())
         {
-            return utils::CallbackError("option 'louder' must be a boolean", callback);
+            return utils::CallbackError("option 'louder' must be a boolean",
+                                        callback);
         }
         louder = louder_val->BooleanValue();
     }
 
-    // Create a worker instance and queues it to run asynchronously invoking the callback when done.
-    // - Nan::AsyncWorker takes a pointer to a Nan::Callback and deletes the pointer automatically.
-    // - Nan::AsyncQueueWorker takes a pointer to a Nan::AsyncWorker and deletes the pointer automatically.
-    auto* worker = new AsyncHelloWorker{louder, h->name_, new Nan::Callback{callback}};
+    // Create a worker instance and queues it to run asynchronously invoking the
+    // callback when done.
+    // - Nan::AsyncWorker takes a pointer to a Nan::Callback and deletes the
+    // pointer automatically.
+    // - Nan::AsyncQueueWorker takes a pointer to a Nan::AsyncWorker and deletes
+    // the pointer automatically.
+    auto* worker =
+        new AsyncHelloWorker{louder, h->name_, new Nan::Callback{callback}};
     Nan::AsyncQueueWorker(worker);
-  
-  }
-
-  // Singleton
-  Nan::Persistent<v8::Function> &HelloObjectAsync::create_once()
-  {
-      static Nan::Persistent<v8::Function> init;
-      return init;
-  }
-
-  void HelloObjectAsync::Init(v8::Local<v8::Object> target)
-  {
-      // A handlescope is needed so that v8 objects created in the local memory space (this function in this case)
-      // are cleaned up when the function is done running (and the handlescope is destroyed)
-      // Fun trivia: forgetting a handlescope is one of the most common causes of memory leaks in node.js core
-      // https://www.joyent.com/blog/walmart-node-js-memory-leak
-      Nan::HandleScope scope;
-
-      // This is saying:
-      // "Node, please allocate a new Javascript string object
-      // inside the V8 local memory space, with the value 'HelloObjectAsync' "
-      v8::Local<v8::String> whoami = Nan::New("HelloObjectAsync").ToLocalChecked();
-       
-      // Create the HelloObject
-      auto fnTp = Nan::New<v8::FunctionTemplate>(HelloObjectAsync::New); // Passing the HelloObject::New method above
-      fnTp->InstanceTemplate()->SetInternalFieldCount(1); // It's 1 when holding the ObjectWrap itself and nothing else
-      fnTp->SetClassName(whoami); // Passing the Javascript string object above
-
-      // Add custom methods here.
-      // This is how helloAsync() is exposed as part of HelloObjectAsync.
-      // This line is attaching the "helloAsync" method to a JavaScript function prototype.
-      // "helloAsync" is therefore like a property of the fnTp object 
-      // ex: console.log(HelloObjectAsync.helloAsync) --> [Function: helloAsync]
-      SetPrototypeMethod(fnTp, "helloAsync", helloAsync);
-
-      // Create an unique instance of the HelloObject function template,
-      // then set this unique instance to the target
-      const auto fn = Nan::GetFunction(fnTp).ToLocalChecked();
-      create_once().Reset(fn);  // calls the static &HelloObjectAsync::create_once method above. This ensures the instructions in this Init function are retained in memory even after this code block ends.
-      Nan::Set(target, whoami, fn);
-  }
-
+}
+
+// Singleton
+Nan::Persistent<v8::Function>& HelloObjectAsync::create_once()
+{
+    static Nan::Persistent<v8::Function> init;
+    return init;
+}
+
+void HelloObjectAsync::Init(v8::Local<v8::Object> target)
+{
+    // A handlescope is needed so that v8 objects created in the local memory
+    // space (this function in this case)
+    // are cleaned up when the function is done running (and the handlescope is
+    // destroyed)
+    // Fun trivia: forgetting a handlescope is one of the most common causes of
+    // memory leaks in node.js core
+    // https://www.joyent.com/blog/walmart-node-js-memory-leak
+    Nan::HandleScope scope;
+
+    // This is saying:
+    // "Node, please allocate a new Javascript string object
+    // inside the V8 local memory space, with the value 'HelloObjectAsync' "
+    v8::Local<v8::String> whoami = Nan::New("HelloObjectAsync").ToLocalChecked();
+
+    // Create the HelloObject
+    auto fnTp = Nan::New<v8::FunctionTemplate>(
+        HelloObjectAsync::New); // Passing the HelloObject::New method above
+    fnTp->InstanceTemplate()->SetInternalFieldCount(
+        1);                     // It's 1 when holding the ObjectWrap itself and nothing else
+    fnTp->SetClassName(whoami); // Passing the Javascript string object above
+
+    // Add custom methods here.
+    // This is how helloAsync() is exposed as part of HelloObjectAsync.
+    // This line is attaching the "helloAsync" method to a JavaScript function
+    // prototype.
+    // "helloAsync" is therefore like a property of the fnTp object
+    // ex: console.log(HelloObjectAsync.helloAsync) --> [Function: helloAsync]
+    SetPrototypeMethod(fnTp, "helloAsync", helloAsync);
+
+    // Create an unique instance of the HelloObject function template,
+    // then set this unique instance to the target
+    const auto fn = Nan::GetFunction(fnTp).ToLocalChecked();
+    create_once().Reset(fn); // calls the static &HelloObjectAsync::create_once
+                             // method above. This ensures the instructions in
+                             // this Init function are retained in memory even
+                             // after this code block ends.
+    Nan::Set(target, whoami, fn);
+}
 }
\ No newline at end of file
diff --git a/src/object_async/hello_async.hpp b/src/object_async/hello_async.hpp
index 9d79267..7e77adb 100644
--- a/src/object_async/hello_async.hpp
+++ b/src/object_async/hello_async.hpp
@@ -3,34 +3,35 @@
 
 namespace object_async {
 
-    /**
-     * HelloObject class
-     * This is in a header file so we can access it across other .cpp files if necessary
-     * Also, this class adheres to the rule of Zero because we define no custom destructor or copy constructor
-     */
-    class HelloObjectAsync: public Nan::ObjectWrap {
-
-        public:
-            // initializer
-            static void Init(v8::Local<v8::Object> target);
-
-            // methods required for the V8 constructor
-            static NAN_METHOD(New);
-            static Nan::Persistent<v8::Function> &create_once();
-
-            // helloAsync, custom async method tied to Init of this class
-            // method's logic lives in ./hello.cpp
-            static NAN_METHOD(helloAsync);
-
-            // C++ Constructor
-            // Passing the arg by rvalue reference (&&)
-            HelloObjectAsync(std::string&& name);
-
-        private:
-            // member variable
-            // specific to each instance of the class
-            std::string name_;
-
-	};
-
+/**
+ * HelloObject class
+ * This is in a header file so we can access it across other .cpp files if
+ * necessary
+ * Also, this class adheres to the rule of Zero because we define no custom
+ * destructor or copy constructor
+ */
+class HelloObjectAsync : public Nan::ObjectWrap
+{
+
+  public:
+    // initializer
+    static void Init(v8::Local<v8::Object> target);
+
+    // methods required for the V8 constructor
+    static NAN_METHOD(New);
+    static Nan::Persistent<v8::Function>& create_once();
+
+    // helloAsync, custom async method tied to Init of this class
+    // method's logic lives in ./hello.cpp
+    static NAN_METHOD(helloAsync);
+
+    // C++ Constructor
+    // Passing the arg by rvalue reference (&&)
+    HelloObjectAsync(std::string&& name);
+
+  private:
+    // member variable
+    // specific to each instance of the class
+    std::string name_;
+};
 }
\ No newline at end of file
diff --git a/src/object_sync/hello.cpp b/src/object_sync/hello.cpp
index 21cd3ad..e773b5c 100644
--- a/src/object_sync/hello.cpp
+++ b/src/object_sync/hello.cpp
@@ -10,7 +10,7 @@
 
 /**
  * Say hello
- * 
+ *
  * @name hello
  * @memberof HelloObject
  * @returns {String}
@@ -19,62 +19,67 @@
  * console.log(x); // => '...initialized an object...hello greg'
  */
 
-// If this was not defined within a namespace, it would be in the global scope. 
-// Namespaces are used because C++ has no notion of scoped modules, so all of the code you write in any file could conflict with other code.
-// Namespaces are generally a great idea in C++ because it helps scale and clearly organize your application. 
+// If this was not defined within a namespace, it would be in the global scope.
+// Namespaces are used because C++ has no notion of scoped modules, so all of
+// the code you write in any file could conflict with other code.
+// Namespaces are generally a great idea in C++ because it helps scale and
+// clearly organize your application.
 namespace object_sync {
 
-  // Custom constructor, assigns custom name passed in from Javascript world.
-  // This constructor uses member init list via the semicolon, aka "direct initialization" 
-  // which is more efficient than using assignment operators.
-  HelloObject::HelloObject(std::string && name) : 
-    name_(std::move(name)) {}
+// Custom constructor, assigns custom name passed in from Javascript world.
+// This constructor uses member init list via the semicolon, aka "direct initialization"
+// which is more efficient than using assignment operators.
+HelloObject::HelloObject(std::string&& name) : name_(std::move(name)) {}
 
-  // Triggered from Javascript world when calling "new HelloObject(name)"
-  NAN_METHOD(HelloObject::New) {
+// Triggered from Javascript world when calling "new HelloObject(name)"
+NAN_METHOD(HelloObject::New)
+{
     if (info.IsConstructCall())
     {
         try
-        {   
-            if (info.Length() >= 1) {
-              if (info[0]->IsString()) 
-              {
-                // Don't want to risk passing a null string around, which might create unpredictable behavior.
-                Nan::Utf8String utf8_value(info[0]);
-                int len = utf8_value.length();
-                if (len <= 0) {
-                   return Nan::ThrowTypeError("arg must be a non-empty string");
+        {
+            if (info.Length() >= 1)
+            {
+                if (info[0]->IsString())
+                {
+                    // Don't want to risk passing a null string around, which might create unpredictable behavior.
+                    Nan::Utf8String utf8_value(info[0]);
+                    int len = utf8_value.length();
+                    if (len <= 0)
+                    {
+                        return Nan::ThrowTypeError("arg must be a non-empty string");
+                    }
+
+                    // This line converts a V8 string to a C++ std::string.
+                    // In the background, it triggers memory allocation (stack allocating, but std:string is also dynamically allocating memory in the heap)
+                    // We want to avoid heap allocation to ensure more performant code.
+                    // See https://github.com/mapbox/cpp/blob/master/glossary.md#stack-allocation
+                    // and https://stackoverflow.com/questions/79923/what-and-where-are-the-stack-and-heap/80113#80113
+                    // Also, providing the length allows the std::string constructor to avoid calculating the length internally
+                    // and should be faster since it skips an operation.
+                    std::string name(*utf8_value, len);
+
+                    // This line is where HelloObject takes ownership of "name" with the use of move semantics.
+                    // Then all later usage of "name" are passed by reference (const&), but the acutal home or address in memory
+                    // will always be owned by this instance of HelloObject. Generally important to know what has ownership of an object.
+                    // When a object/value is a member of a class (like "name"), we know the class has full control of the scope of the object/value.
+                    // This avoids the scenario of an object/value being destroyed or becoming out of scope.
+                    auto* const self = new HelloObject(std::move(name));
+                    self->Wrap(info.This()); // Connects C++ object to Javascript object (this)
                 }
-
-                // This line converts a V8 string to a C++ std::string.
-                // In the background, it triggers memory allocation (stack allocating, but std:string is also dynamically allocating memory in the heap)
-                // We want to avoid heap allocation to ensure more performant code.
-                // See https://github.com/mapbox/cpp/blob/master/glossary.md#stack-allocation
-                // and https://stackoverflow.com/questions/79923/what-and-where-are-the-stack-and-heap/80113#80113
-                // Also, providing the length allows the std::string constructor to avoid calculating the length internally 
-                // and should be faster since it skips an operation. 
-                std::string name(*utf8_value, len);
-                
-                // This line is where HelloObject takes ownership of "name" with the use of move semantics.
-                // Then all later usage of "name" are passed by reference (const&), but the acutal home or address in memory 
-                // will always be owned by this instance of HelloObject. Generally important to know what has ownership of an object. 
-                // When a object/value is a member of a class (like "name"), we know the class has full control of the scope of the object/value. 
-                // This avoids the scenario of an object/value being destroyed or becoming out of scope.
-                auto *const self = new HelloObject(std::move(name));
-                self->Wrap(info.This()); // Connects C++ object to Javascript object (this)
-              }
-              else
-              {
+                else
+                {
+                    return Nan::ThrowTypeError(
+                        "arg must be a string");
+                }
+            }
+            else
+            {
                 return Nan::ThrowTypeError(
-                    "arg must be a string");
-              }
-            } else {
-              return Nan::ThrowTypeError(
                     "must provide string arg");
             }
-
         }
-        catch (const std::exception &ex)
+        catch (const std::exception& ex)
         {
             return Nan::ThrowTypeError(ex.what());
         }
@@ -86,64 +91,83 @@ namespace object_sync {
         return Nan::ThrowTypeError(
             "Cannot call constructor as function, you need to use 'new' keyword");
     }
-  }
-
-  // NAN_METHOD is applicable to methods you want to expose to JS world
-  NAN_METHOD(HelloObject::hello) {
-
-    // Note: a HandleScope is automatically included inside NAN_METHOD. See the docs at NAN that say:
-    // 'Note that an implicit HandleScope is created for you on JavaScript-accessible methods so you do not need to insert one yourself.'
-    // at https://github.com/nodejs/nan/blob/2dfc5c2d19c8066903a19ced6a72c06d2c825dec/doc/scopes.md#nanhandlescope
-
-    // "What is node::ObjectWrap???" The short version is that node::ObjectWrap and wrapping/unwrapping objects 
-    // is the somewhat clumsy way it is possible to bind Node and C++. The main points to remember:
-    // - To access a class instance inside a C++ static method, you must unwrap the object.
-    // - The C++ methods must be static to make them available at startup across the language boundary (JS <-> C++).
+}
+
+// NAN_METHOD is applicable to methods you want to expose to JS world
+NAN_METHOD(HelloObject::hello)
+{
+
+    // Note: a HandleScope is automatically included inside NAN_METHOD. See the
+    // docs at NAN that say:
+    // 'Note that an implicit HandleScope is created for you on
+    // JavaScript-accessible methods so you do not need to insert one yourself.'
+    // at
+    // https://github.com/nodejs/nan/blob/2dfc5c2d19c8066903a19ced6a72c06d2c825dec/doc/scopes.md#nanhandlescope
+
+    // "What is node::ObjectWrap???" The short version is that node::ObjectWrap
+    // and wrapping/unwrapping objects
+    // is the somewhat clumsy way it is possible to bind Node and C++. The main
+    // points to remember:
+    // - To access a class instance inside a C++ static method, you must unwrap
+    // the object.
+    // - The C++ methods must be static to make them available at startup across
+    // the language boundary (JS <-> C++).
     HelloObject* h = Nan::ObjectWrap::Unwrap<HelloObject>(info.Holder());
 
     // "info" comes from the NAN_METHOD macro, which returns differently
     // according to the version of node
-    info.GetReturnValue().Set(Nan::New<v8::String>("...initialized an object...hello " + h->name_).ToLocalChecked());
-  
-  }
-  
-  // This is a Singleton, which is a general programming design concept for creating an instance once within a process.
-  Nan::Persistent<v8::Function> &HelloObject::create_once()
-  {
-      static Nan::Persistent<v8::Function> init;
-      return init;
-  }
-
-  void HelloObject::Init(v8::Local<v8::Object> target)
-  {
-      // A handlescope is needed so that v8 objects created in the local memory space (this function in this case)
-      // are cleaned up when the function is done running (and the handlescope is destroyed)
-      // Fun trivia: forgetting a handlescope is one of the most common causes of memory leaks in node.js core
-      // https://www.joyent.com/blog/walmart-node-js-memory-leak
-      Nan::HandleScope scope;
-
-      // This is saying:
-      // "Node, please allocate a new Javascript string object
-      // inside the V8 local memory space, with the value 'HelloObject' "
-      v8::Local<v8::String> whoami = Nan::New("HelloObject").ToLocalChecked();
-       
-      // Officially create the HelloObject
-      auto fnTp = Nan::New<v8::FunctionTemplate>(HelloObject::New); // Passing the HelloObject::New method above
-      fnTp->InstanceTemplate()->SetInternalFieldCount(1); // It's 1 when holding the ObjectWrap itself and nothing else
-      fnTp->SetClassName(whoami); // Passing the Javascript string object above
-
-      // Add custom methods here.
-      // This is how hello() is exposed as part of HelloObject.
-      // This line is attaching the "hello" method to a JavaScript function prototype.
-      // "hello" is therefore like a property of the fnTp object 
-      // ex: console.log(HelloObject.hello) --> [Function: hello]
-      SetPrototypeMethod(fnTp, "hello", hello);
-
-      // Create an unique instance of the HelloObject function template,
-      // then set this unique instance to the target
-      const auto fn = Nan::GetFunction(fnTp).ToLocalChecked();
-      create_once().Reset(fn);  // calls the static &HelloObject::create_once method above. This ensures the instructions in this Init function are retained in memory even after this code block ends.
-      Nan::Set(target, whoami, fn);
-  }
+    info.GetReturnValue().Set(
+        Nan::New<v8::String>("...initialized an object...hello " + h->name_)
+            .ToLocalChecked());
+}
+
+// This is a Singleton, which is a general programming design concept for
+// creating an instance once within a process.
+Nan::Persistent<v8::Function>& HelloObject::create_once()
+{
+    static Nan::Persistent<v8::Function> init;
+    return init;
+}
+
+void HelloObject::Init(v8::Local<v8::Object> target)
+{
+    // A handlescope is needed so that v8 objects created in the local memory
+    // space (this function in this case)
+    // are cleaned up when the function is done running (and the handlescope is
+    // destroyed)
+    // Fun trivia: forgetting a handlescope is one of the most common causes of
+    // memory leaks in node.js core
+    // https://www.joyent.com/blog/walmart-node-js-memory-leak
+    Nan::HandleScope scope;
+
+    // This is saying:
+    // "Node, please allocate a new Javascript string object
+    // inside the V8 local memory space, with the value 'HelloObject' "
+    v8::Local<v8::String> whoami = Nan::New("HelloObject").ToLocalChecked();
+
+    // Officially create the HelloObject
+    auto fnTp = Nan::New<v8::FunctionTemplate>(
+        HelloObject::New); // Passing the HelloObject::New method above
+    fnTp->InstanceTemplate()->SetInternalFieldCount(
+        1);                     // It's 1 when holding the ObjectWrap itself and nothing else
+    fnTp->SetClassName(whoami); // Passing the Javascript string object above
+
+    // Add custom methods here.
+    // This is how hello() is exposed as part of HelloObject.
+    // This line is attaching the "hello" method to a JavaScript function
+    // prototype.
+    // "hello" is therefore like a property of the fnTp object
+    // ex: console.log(HelloObject.hello) --> [Function: hello]
+    SetPrototypeMethod(fnTp, "hello", hello);
+
+    // Create an unique instance of the HelloObject function template,
+    // then set this unique instance to the target
+    const auto fn = Nan::GetFunction(fnTp).ToLocalChecked();
+    create_once().Reset(fn); // calls the static &HelloObject::create_once method
+                             // above. This ensures the instructions in this Init
+                             // function are retained in memory even after this
+                             // code block ends.
+    Nan::Set(target, whoami, fn);
+}
 
 } // namespace object_sync
\ No newline at end of file
diff --git a/src/object_sync/hello.hpp b/src/object_sync/hello.hpp
index 75a5a9c..c4a744e 100644
--- a/src/object_sync/hello.hpp
+++ b/src/object_sync/hello.hpp
@@ -3,34 +3,33 @@
 
 namespace object_sync {
 
-    /**
+/**
      * HelloObject class
      * This is in a header file so we can access it across other .cpp files if necessary
      * Also, this class adheres to the rule of Zero because we define no custom destructor or copy constructor
      */
-    class HelloObject: public Nan::ObjectWrap {
-
-        public:
-            // initializer
-            static void Init(v8::Local<v8::Object> target);
-
-            // methods required for the V8 constructor (?)
-            static NAN_METHOD(New);
-            static Nan::Persistent<v8::Function> &create_once();
-
-            // hello, custom sync method tied to Init of this class
-            // method's logic lives in ./hello.cpp
-            static NAN_METHOD(hello);
-
-            // C++ Constructor
-            // Passing the arg by rvalue reference (&&)
-            HelloObject(std::string&& name);
-
-        private:
-            // member variable
-            // specific to each instance of the class
-            std::string name_;
-
-	};
-
+class HelloObject : public Nan::ObjectWrap
+{
+
+  public:
+    // initializer
+    static void Init(v8::Local<v8::Object> target);
+
+    // methods required for the V8 constructor (?)
+    static NAN_METHOD(New);
+    static Nan::Persistent<v8::Function>& create_once();
+
+    // hello, custom sync method tied to Init of this class
+    // method's logic lives in ./hello.cpp
+    static NAN_METHOD(hello);
+
+    // C++ Constructor
+    // Passing the arg by rvalue reference (&&)
+    HelloObject(std::string&& name);
+
+  private:
+    // member variable
+    // specific to each instance of the class
+    std::string name_;
+};
 }
\ No newline at end of file
diff --git a/src/standalone/hello.cpp b/src/standalone/hello.cpp
index 1220548..1a3a9cb 100644
--- a/src/standalone/hello.cpp
+++ b/src/standalone/hello.cpp
@@ -10,18 +10,21 @@
  * console.log(check); // => "hello world"
  */
 namespace standalone {
-// If this was not defined within a namespace, it would be in the global scope. 
-// Namespaces are used because C++ has no notion of scoped modules, so all of the code you write in any file could conflict with other code.
-// Namespaces are generally a great idea in C++ because it helps scale and clearly organize your application. 
+// If this was not defined within a namespace, it would be in the global scope.
+// Namespaces are used because C++ has no notion of scoped modules, so all of
+// the code you write in any file could conflict with other code.
+// Namespaces are generally a great idea in C++ because it helps scale and
+// clearly organize your application.
 
-
-  // hello is a "standalone function" because it's not a class.
-  // If this function was not defined within a namespace, it would be in the global scope.
-  NAN_METHOD(hello) {
+// hello is a "standalone function" because it's not a class.
+// If this function was not defined within a namespace, it would be in the
+// global scope.
+NAN_METHOD(hello)
+{
 
     // "info" comes from the NAN_METHOD macro, which returns differently
     // according to the version of node
-    info.GetReturnValue().Set(Nan::New<v8::String>("hello world").ToLocalChecked());
-  
-  }
+    info.GetReturnValue().Set(
+        Nan::New<v8::String>("hello world").ToLocalChecked());
+}
 } // namespace standalone
\ No newline at end of file
diff --git a/src/standalone/hello.hpp b/src/standalone/hello.hpp
index 1856841..5db064c 100644
--- a/src/standalone/hello.hpp
+++ b/src/standalone/hello.hpp
@@ -1,21 +1,28 @@
 #pragma once
 #include <nan.h>
 // specify #include with carrots, ex: <nan.h> --> look for header in global
-// specify #include with quotes, ex: "hello.hpp" --> look for header in location relative to this file
+// specify #include with quotes, ex: "hello.hpp" --> look for header in location
+// relative to this file
 
 /*
 
-  Namespace is an organizational method that helps to clearly show where a method is coming from.
-  Namespaces are generally a great idea in C++ because they help us scale things. C++ has no notion of scoped modules,
-  so all of the code you write in any file could potentially conflict with other classes/functions/etc. 
+  Namespace is an organizational method that helps to clearly show where a
+  method is coming from.
+  Namespaces are generally a great idea in C++ because they help us scale
+  things. C++ has no notion of scoped modules,
+  so all of the code you write in any file could potentially conflict with other
+  classes/functions/etc.
   Namespaces help to differentiate pieces of your code.
- 
-  The convention In this skeleton is to name the namespace to match the name of the subdirectory where it lives.
-  So in this case, the namespace is called "standalone" because this method lives within the "standalone" subdirectory.
-  If there is another "hello" function used for another example, the compiler will know the difference between the two:
- 
+
+  The convention In this skeleton is to name the namespace to match the name of
+  the subdirectory where it lives.
+  So in this case, the namespace is called "standalone" because this method
+  lives within the "standalone" subdirectory.
+  If there is another "hello" function used for another example, the compiler
+  will know the difference between the two:
+
   standalone::hello
-       
+
        VS
 
   potato::hello
@@ -23,8 +30,7 @@
 */
 namespace standalone {
 
-	// hello, custom sync method tied to module.cpp
-	// method's logic lives in hello.cpp
-	NAN_METHOD(hello);
-
+// hello, custom sync method tied to module.cpp
+// method's logic lives in hello.cpp
+NAN_METHOD(hello);
 }
\ No newline at end of file
diff --git a/src/standalone_async/hello_async.cpp b/src/standalone_async/hello_async.cpp
index 4e69037..3e9c205 100644
--- a/src/standalone_async/hello_async.cpp
+++ b/src/standalone_async/hello_async.cpp
@@ -2,9 +2,9 @@
 #include "../module_utils.hpp"
 
 #include <exception>
-#include <stdexcept>
 #include <iostream>
 #include <map>
+#include <stdexcept>
 
 /**
  * This is an asynchronous standalone function that logs a string.
@@ -17,95 +17,118 @@
  * var module = require('./path/to/lib/index.js');
  * module.helloAsync({ louder: true }, function(err, result) {
  *   if (err) throw err;
- *   console.log(result); // => "...threads are busy async bees...hello world!!!!"
+ *   console.log(result); // => "...threads are busy async bees...hello
+ * world!!!!"
  * });
  */
 
-// If this was not defined within a namespace, it would be in the global scope. 
-// Namespaces are used because C++ has no notion of scoped modules, so all of the code you write in any file could conflict with other code.
-// Namespaces are generally a great idea in C++ because it helps scale and clearly organize your application. 
+// If this was not defined within a namespace, it would be in the global scope.
+// Namespaces are used because C++ has no notion of scoped modules, so all of
+// the code you write in any file could conflict with other code.
+// Namespaces are generally a great idea in C++ because it helps scale and
+// clearly organize your application.
 namespace standalone_async {
 
-  // Expensive allocation of std::map, querying, and string comparison,
-  // therefore threads are busy
-  std::string do_expensive_work(bool louder) {  
+// Expensive allocation of std::map, querying, and string comparison,
+// therefore threads are busy
+std::string do_expensive_work(bool louder)
+{
 
-      std::map<std::size_t,std::string> container;  
-      std::size_t work_to_do=100000;
+    std::map<std::size_t, std::string> container;
+    std::size_t work_to_do = 100000;
 
-      for (std::size_t i=0;i<work_to_do;++i) {
-          container.emplace(i,std::to_string(i));
-      }  
+    for (std::size_t i = 0; i < work_to_do; ++i)
+    {
+        container.emplace(i, std::to_string(i));
+    }
+
+    for (std::size_t i = 0; i < work_to_do; ++i)
+    {
+        std::string const& item = container[i];
+        if (item != std::to_string(i))
+        {
 
-      for (std::size_t i=0;i<work_to_do;++i) {
-          std::string const& item = container[i];
-          if (item != std::to_string(i)) {
+            // AsyncHelloWorker's Execute function will take care of this error
+            // and return it to js-world via callback
+            throw std::runtime_error("Uh oh, this should never happen");
+        }
+    }
 
-              // AsyncHelloWorker's Execute function will take care of this error 
-              // and return it to js-world via callback
-              throw std::runtime_error("Uh oh, this should never happen");
-          }
-      }  
+    std::string result = "...threads are busy async bees...hello world";
 
-      std::string result = "...threads are busy async bees...hello world";
- 
-      if (louder)
-      {
+    if (louder)
+    {
         result += "!!!!";
-      }
-     
-      return result;  
-
-  }  
-
-  // This is the worker running asynchronously and calling a user-provided callback when done.
-  // Consider storing all C++ objects you need by value or by shared_ptr to keep them alive until done.
-  // Nan AsyncWorker docs: https://github.com/nodejs/nan/blob/master/doc/asyncworker.md
-  struct AsyncHelloWorker : Nan::AsyncWorker {
-      using Base = Nan::AsyncWorker;  
-
-      AsyncHelloWorker(bool louder, Nan::Callback* callback)
-          : Base(callback), result_{""}, louder_{louder} { }  
-
-      // The Execute() function is getting called when the worker starts to run.
-      // - You only have access to member variables stored in this worker.
-      // - You do not have access to Javascript v8 objects here.
-      void Execute() override {
-          // The try/catch is critical here: if code was added that could throw an unhandled error INSIDE the threadpool, it would be disasterous
-          try {
-              result_ = do_expensive_work(louder_);
-          } catch (const std::exception& e) {
-              SetErrorMessage(e.what());
-          }
-      }  
-
-      // The HandleOKCallback() is getting called when Execute() successfully completed.
-      // - In case Execute() invoked SetErrorMessage("") this function is not getting called.
-      // - You have access to Javascript v8 objects again
-      // - You have to translate from C++ member variables to Javascript v8 objects
-      // - Finally, you call the user's callback with your results
-      void HandleOKCallback() override {
-          Nan::HandleScope scope;  
-
-          const auto argc = 2u;
-          v8::Local<v8::Value> argv[argc] = {Nan::Null(), Nan::New<v8::String>(result_).ToLocalChecked()};  
-
-          callback->Call(argc, argv);
-      }  
-
-      std::string result_;
-      const bool louder_;
-  };  
-
-  // helloAsync is a "standalone function" because it's not a class.
-  // If this function was not defined within a namespace ("standalone_async" specified above), it would be in the global scope.
-  NAN_METHOD(helloAsync) {
+    }
+
+    return result;
+}
+
+// This is the worker running asynchronously and calling a user-provided
+// callback when done.
+// Consider storing all C++ objects you need by value or by shared_ptr to keep
+// them alive until done.
+// Nan AsyncWorker docs:
+// https://github.com/nodejs/nan/blob/master/doc/asyncworker.md
+struct AsyncHelloWorker : Nan::AsyncWorker
+{
+    using Base = Nan::AsyncWorker;
+
+    AsyncHelloWorker(bool louder, Nan::Callback* callback)
+        : Base(callback), result_{""}, louder_{louder} {}
+
+    // The Execute() function is getting called when the worker starts to run.
+    // - You only have access to member variables stored in this worker.
+    // - You do not have access to Javascript v8 objects here.
+    void Execute() override
+    {
+        // The try/catch is critical here: if code was added that could throw an
+        // unhandled error INSIDE the threadpool, it would be disasterous
+        try
+        {
+            result_ = do_expensive_work(louder_);
+        }
+        catch (const std::exception& e)
+        {
+            SetErrorMessage(e.what());
+        }
+    }
+
+    // The HandleOKCallback() is getting called when Execute() successfully
+    // completed.
+    // - In case Execute() invoked SetErrorMessage("") this function is not
+    // getting called.
+    // - You have access to Javascript v8 objects again
+    // - You have to translate from C++ member variables to Javascript v8 objects
+    // - Finally, you call the user's callback with your results
+    void HandleOKCallback() override
+    {
+        Nan::HandleScope scope;
+
+        const auto argc = 2u;
+        v8::Local<v8::Value> argv[argc] = {
+            Nan::Null(), Nan::New<v8::String>(result_).ToLocalChecked()};
+
+        callback->Call(argc, argv);
+    }
+
+    std::string result_;
+    const bool louder_;
+};
+
+// helloAsync is a "standalone function" because it's not a class.
+// If this function was not defined within a namespace ("standalone_async"
+// specified above), it would be in the global scope.
+NAN_METHOD(helloAsync)
+{
 
     bool louder = false;
 
     // Check second argument, should be a 'callback' function.
-    // This allows us to set the callback so we can use it to return errors instead of throwing.
-    // Also, "info" comes from the NAN_METHOD macro, which returns differently according to the version of node
+    // This allows us to set the callback so we can use it to return errors
+    // instead of throwing.
+    // Also, "info" comes from the NAN_METHOD macro, which returns differently
+    // according to the version of node
     if (!info[1]->IsFunction())
     {
         return Nan::ThrowTypeError("second arg 'callback' must be a function");
@@ -115,29 +138,33 @@ namespace standalone_async {
     // Check first argument, should be an 'options' object
     if (!info[0]->IsObject())
     {
-        return utils::CallbackError("first arg 'options' must be an object", callback);
+        return utils::CallbackError("first arg 'options' must be an object",
+                                    callback);
     }
     v8::Local<v8::Object> options = info[0].As<v8::Object>();
 
-    // Check options object for the "louder" property, which should be a boolean value
+    // Check options object for the "louder" property, which should be a boolean
+    // value
     if (options->Has(Nan::New("louder").ToLocalChecked()))
     {
-        v8::Local<v8::Value> louder_val = options->Get(Nan::New("louder").ToLocalChecked());
+        v8::Local<v8::Value> louder_val =
+            options->Get(Nan::New("louder").ToLocalChecked());
         if (!louder_val->IsBoolean())
         {
-            return utils::CallbackError("option 'louder' must be a boolean", callback);
+            return utils::CallbackError("option 'louder' must be a boolean",
+                                        callback);
         }
         louder = louder_val->BooleanValue();
     }
 
-    // Creates a worker instance and queues it to run asynchronously, invoking the callback when done.
-    // - Nan::AsyncWorker takes a pointer to a Nan::Callback and deletes the pointer automatically.
-    // - Nan::AsyncQueueWorker takes a pointer to a Nan::AsyncWorker and deletes the pointer automatically.
+    // Creates a worker instance and queues it to run asynchronously, invoking the
+    // callback when done.
+    // - Nan::AsyncWorker takes a pointer to a Nan::Callback and deletes the
+    // pointer automatically.
+    // - Nan::AsyncQueueWorker takes a pointer to a Nan::AsyncWorker and deletes
+    // the pointer automatically.
     auto* worker = new AsyncHelloWorker{louder, new Nan::Callback{callback}};
     Nan::AsyncQueueWorker(worker);
-  
-  }
+}
 
 } // namespace standalone_async
-
-
diff --git a/src/standalone_async/hello_async.hpp b/src/standalone_async/hello_async.hpp
index 92c1269..5181fc2 100644
--- a/src/standalone_async/hello_async.hpp
+++ b/src/standalone_async/hello_async.hpp
@@ -5,17 +5,23 @@
 
 /*
 
-  Namespace is an organizational method that helps to clearly show where a method is coming from.
-  Namespaces are generally a great idea in C++ because they help us scale things. C++ has no notion of scoped modules,
-  so all of the code you write in any file could potentially conflict with other classes/functions/etc. 
+  Namespace is an organizational method that helps to clearly show where a
+  method is coming from.
+  Namespaces are generally a great idea in C++ because they help us scale
+  things. C++ has no notion of scoped modules,
+  so all of the code you write in any file could potentially conflict with other
+  classes/functions/etc.
   Namespaces help to differentiate pieces of your code.
- 
-  The convention In this skeleton is to name the namespace to match the name of the subdirectory where it lives.
-  So in this case, the namespace is called "standalone" because this method lives within the "standalone" subdirectory.
-  If there is another "hello" function used for another example, the compiler will know the difference between the two:
- 
+
+  The convention In this skeleton is to name the namespace to match the name of
+  the subdirectory where it lives.
+  So in this case, the namespace is called "standalone" because this method
+  lives within the "standalone" subdirectory.
+  If there is another "hello" function used for another example, the compiler
+  will know the difference between the two:
+
   standalone::hello
-       
+
        VS
 
   potato::hello
@@ -23,8 +29,7 @@
 */
 namespace standalone_async {
 
-	// hello, custom sync method tied to module.cpp
-	// method's logic lives in hello.cpp
-	NAN_METHOD(helloAsync);
-
+// hello, custom sync method tied to module.cpp
+// method's logic lives in hello.cpp
+NAN_METHOD(helloAsync);
 }
\ No newline at end of file
