DEV Community: Orim Dominic Adah

Accepted Into Enye Cohort 5

Orim Dominic Adah — Fri, 12 Sep 2025 13:56:58 +0000

Welcome to Enye Cohort 5 [Feb 8, 12:25 AM]

I saw the mail some minutes after midnight while making fixes to an app I was building. I had kept my mail tab open because Mr. Uche Nnandi had promised us via the Slack group that we'd get mails that weekend. I smiled when I saw it, and then I laughed, and then, I relaxed.

...before now

I had applied for Enye cohort 2 and 4 internships. I didn't continue with the application. I was either very busy with deliverables, or I felt that I could not complete the task before the deadline.

I got a mail from the Enye team on Jan 15 informing me that the Enye cohort 5 internship was open for applications. The benefits of participating in the internship were listed, and I was more interested and willing than I ever was. I had more free time and as a self-taught developer, I needed a process that would put me through building software using the proper tools and processes. I applied and told my friends to apply too.

Phase One

I was sent a link to the first task and I was asked to submit it in 5 days. The purpose of the task was for the Enye team to gauge applicants' understanding of 'working with JSON data and RESTful APIs, and to gauge applicants' understanding of user experience in frontend development' too.

It was an interesting two-part task that required applicants to develop and deploy a frontend application that displays data from an API beautifully well and a backend application that returns currency rates based on requests from a client.

I set a deadline for myself to submit before the deadline, and I did. I put in a lot, but I didn't expect much. No thanks to rejection letters with poor user experience.

Phase Two

I received a congratulatory mail that my submission was accepted, 202. I was also added to a private channel on the Slack group for applicants whose phase one submission had been accepted.

The task for the second phase was to ace the cut-off mark on a multiple-choice questions test about JavaScript, React and, Node.js. I was to take the test whenever I felt comfortable.

Like the first task, I tried what I could, but unlike it, I was a tad hopeful. Even at that, I choose to not pay much attention to receiving a congratulatory mail; to numb the effect of mails that hurt.

Phase Three

I got another congratulatory mail informing me that I had passed the phase two test. This mail came with a test attached. What's that maxim again? The reward for good work is more work init?

This test hit me and stretched me, but I loved it. It required applicants to do the following for an application that was described:

create user story mapping diagrams using Miro,
create a UI design using Figma,
describe and design a standard API documentation for the application using Swagger,
leverage Lucid Chart to create entity relationship diagrams for the database entities of the application,
list and describe the various APIs, deployment platforms, frameworks, libraries, and other tech that will be needed to build the application; state the advantages and disadvantages of the chosen tech, state the reason for choosing it over its competitors, and also state how relevant the chosen tech is to the development of the application,

in five days. All these in five days!

What really got me interested in this task was that I had an idea to build this particular application the year before, but I didn't know what (best and free-tier) tools to build it with. I also didn't know how best to architect it. After reading the task description, I said to myself What you've been pushing away has finally hugged you tight. I've built apps, but I didn't follow this process.

I hadn't used any of these tools before, except Figma. I wrote user stories for apps I built, but I'd never arranged them into activities, tasks and stories and placed them into sprints. I spent two days (thank you PHCN) learning the proper format for user story mappings.

Creating the standard APIs using Swagger became less stressful and faster for me when I learnt about components. The user experience in using Miro was awesome and it helped. That I had this application in mind before I was assigned this task made creating the entity-relationship diagram easier for me.

I put a lot of work into the justification for the technologies to be used in building out the application. My idea was that, even if I didn't pass to the next phase, I'd have learnt what tech to use to build the app myself.

I did not finish the Figma design task, and I wasn't bothered much. One of the instructions on the task read You will be judged based on the quality of your work. I felt confident that the focus was on attention to detail and quality, not quantity.

Video Interview

The congratulatory mail for passing the phase three test came with a request for a recorded video with answers to interview questions that verified my soft skills and had to be submitted in three days.

Final Thoughts

The experience was awesome. Even if I hadn't been selected, I'd still be happy I went through the process and here are my reasons:

The Enye team was supportive throughout the application period, and the grading processes were relatively fast. I got response mails in less than a week
The tasks were clear, straightforward, and involved real-life tasks. They also inspired autonomy. The Enye team made sure that applicants were never hand-held in completing their tasks.
I believe the process was fair. If it wasn't, someone would have complained on the Slack channel. Although I never asked for feedback, I believe that some applicants received feedback on their submitted tasks when they asked.
The process wasn't focused on filtering out applicants. Those who didn't make it to the selected 30 were put on a waitlist as replacements, in the event that someone from the selected 30 wasn't interested in the internship.

Thank you Enye. I look forward to working with the founders and engineers who I'll be matched with during the internship. I look forward to creating magic with you all!

What do you do while waiting?

Orim Dominic Adah — Fri, 28 Feb 2020 03:21:03 +0000

We've all been there and we'll never stop being there. Times like when npm install takes forever, long running test suites we hope all pass and the infamous Gradle builds that take longer than the Shawshank Redemption with commercials.

What do you do during these times?

Play swords with a colleague?
Surf dev.to?
Watch Youtube videos?
Pet your pet?
Snapchat?
Take a walk?

Share what you do in these wait times that holds you back from exploding with anxiety! Lets all learn and have fun. Someone might just adopt yours! 😉

Kindly share the work/life related website(s) you never fail to visit everyday, and why

Orim Dominic Adah — Tue, 18 Feb 2020 00:38:55 +0000

Everyone has that dev, work or life related website they never fail to visit EVERY DAY of their dev life. It could be

StackOverflow for answers to their dev-related questions,
Dev.to for articles containing solutions to work and work-life challenges, and fun stuff,
Hackerank for coding challenges and jobs,
Toptal for freelancing jobs,
Codepen,
FreeCodeCamp,

or any other one.

Kindly share with us and tell us why that website is a daily go-to for you. You never know.. You may win someone over to that website through its usefulness to you🤷‍♀️😉

What are your basic metrics for judging a website as a Product Manager or Developer?

Orim Dominic Adah — Tue, 11 Feb 2020 04:06:43 +0000

Every website development project has its requirements. A lot of times, these requirements come from the purpose of the website.

That being said, there are some basic requirements we expect some web development projects to have as product managers or developers. These may include

SEO friendliness
Low time-to-first-byte (TTFB)
Low time-to-first-interaction (TTFI)
Accessibility

Others may include PWA, performance-related metrics and so on.

What are the basic standards you try to meet when you have a web development project (personal or contracted)?

Why do some Programming Tutorials not place emphasis on Software Architecture Principles?

Orim Dominic Adah — Tue, 04 Feb 2020 07:29:55 +0000

Why do some programming tutorials not include software architecture principles such as SOLID and design (anti-)patterns in building the projects that accompany the tutorials?

These principles are important as they support the lifespan of any software project. What's more? They are better learnt using examples and use cases (of which the project being built during the tutorial contains a plethora of).

This #discuss begs the question

Why do some programming tutorials not place emphasis on software architecture principles while building the project(s) being built during the tutorial?

And do you think they should?

Which tool/language documentation do you have a strong confidence in?

Orim Dominic Adah — Mon, 27 Jan 2020 12:39:33 +0000

While developing anything, we are often faced with challenges on achieving what we want. At this point, a lot of us immediately search and visit the first stackoverflow link related to the challenge 👩‍💻👨‍💻..

BUT

is there a language or tool which whenever you have challenges building something with it, you will check its documentation first before stackoverflow and why?

Predicting JavaScript Equality Comparisons Correctly

Orim Dominic Adah — Tue, 21 Jan 2020 16:06:34 +0000

Predicting the result of an equality check of two or more values in JavaScript has been a part of the language that trips many developers; but not anymore, as this article stops at nothing in providing you with a straightforward and understandable approach to it.

This article does not include explanations for edge case comparisons such as [] == "" and [undefined] == [null]

Introduction

Determining if any set of values are equal in JavaScript is achieved using any one of these:

The Abstract Equality Operator (==)
The Strict Equality Operator (===)
Object.is

The major difference between the strict equality operator and the abstract equality operator is NOT that the strict equality operator checks for the equality of the value types being compared and the abstract equality operator does not; but that the strict equality operator does not allow coercion before comparison, while the abstract equality operator allows coercion before comparison.

Irrespective of the operator used, the result of checking the equality of any set of values is either true (if the values compared are equal) or false (if the values compared are not equal).

Comparison with the Abstract Equality Operator (`==`)

When comparing the equality of any set of values using ==,

There are seven value types here: undefined, null, Boolean, Number, String, Object and Symbol.

if the value types of any of the set of values to be compared are the same, there is no need for coercion; hence, a strict equality comparison is performed and the result is returned, otherwise;
undefined and null values are coercively equal to each other; in other words, testing if undefined == null will return true. undefined and null will not coerce to any other type (Boolean, Number, String, Object, or Symbol) when == is used to compare their equality with these other types;
all String and Boolean values are first coerced to Number values before a check for the equality of the values is determined. (The Boolean false is coerced to +0, while true is coerced to +1.);
all objects (remember that null is not an object in this case) are coerced to their primitive values before an equality check is carried out.

The primitive value of an object is determined internally by the JavaScript engine, however, depending on the object hint, the object is either coerced to a String (in the case of arrays) or to a Number.

Comparison with the Strict Equality Operator (`===`)

When comparing the equality of any set of values using ===,

if the value types (Number, String e.t.c) of the set of values under comparison are different, the JavaScript engine avoids coercion immediately and returns false; otherwise,
if the set of values under comparison are of type String and they are exactly the same sequence of code units (same length and same code units at corresponding indices), the JavaScript engine returns true; otherwise, it returns false.
if the set of values under comparison are of the Boolean type, the JavaScript engine returns true if the values are the same, otherwise it returns false
if the set of values under comparison are of the type Symbol and they have the same Symbol value, the JavaScript engine returns true, otherwise, it returns false;
if the set of values under comparison are of the Object type and they reference the same object in memory, the JavaScript engine returns true, otherwise, it returns false.
if any of the values under comparison is NaN, the JavaScript engine returns false;
+0 and -0 Number values are equal to each other, therefore, return true.

Practice Time!

What will be the result of the following comparisons?

0 == null
false == undefined
true == 1
'JavaScript' == true
'JavaScript' == false

Answers

false. null will not coerce to any other value except undefined
false. false gets coerced to its Number value (+0), but undefined does not get coerced to its Number value (which is NaN). Since +0 is not the same as undefined, false is returned.

You can answer the rest in the comments section, with an explanation for your answer, and also feel free to add your own questions too 😉.

Cheers 🥂

Formatting Numbers in JavaScript with Intl.NumberFormat

Orim Dominic Adah — Mon, 13 Jan 2020 20:34:45 +0000

According to the documentation on MDN,

The Intl.NumberFormat object is a constructor for objects that enable language-sensitive number formatting

And this means what in practice?

It simply means that with Intl.NumberFormat, JavaScript can construct an object that will have the ability to style (or to be technically correct, format) numbers based on human languages. In other words, numbers can be styled in a more human-understandable format.

Instead of numbers being presented as bland as 1234 or 4561254, numbers can be better presented as 1,234 or $4,561.254. You get the gist? Good!

How does this work? Well, the syntax is simple.

const formatterObject = new Intl.NumberFormat([locales[, options]]);

What the syntax above means is this:

formatterObject is the object constructed (created) by Intl.NumberFormat. formatterObject holds methods that can be used to format numbers,
locales represents the code for human language that we want to format the number in. And why is this important?

Different languages have different ways of displaying numbers. A number like 123456 will be displayed in Spanish as 123.456, in English as 123,456 and in the Indian numerical system as 1,23,456. localesis a code in the form of a string that informs formatterObject of which language to use when formatting.

You can find a list of the locales under subtag
here. Examples are 'hi' for Hindi, 'de-AT' for German (de) used in Austria (AT) and 'en-IN' for English (en) used in India (IN). Number system codes such as "arab", "arabext" and "latn"

options refers to additional configurations that can be used to configure how formatterObject styles numbers. options is an object.

Don't be dismayed by the square braces [] in the syntax. They are simply saying Hey developer! Whatever is within me is optional. You can decide to exclude them when writing the syntax and the default configurations will be used.

Using the number 1234567890.1234 as an example, lets convert our knowledge into code.

const num = 1234567890.1234;

// setup formatters
const hindiNumberFormatter = new Intl.NumberFormat("en-IN");
const britishNumberFormatter = new Intl.NumberFormat("en-GB");
const spanishNumberFormatter = new Intl.NumberFormat("es-ES");

// use formatters
console.log(hindiNumberFormatter.format(num)); // 1,23,45,67,890.123
console.log(britishNumberFormatter.format(num)); // 1,234,567,890.123
console.log(spanishNumberFormatter.format(num)); // 1.234.567.890,123

What happened?

We created three types of number formatters with Intl.NumberFormat: hindiNumberFormatter, britishNumberFormatter and spanishNumberFormatter. Each formatter was created with a locale configuration that sets the formatting language of the formatter.

Next, we use the format method on the formatters to style the number num and display the result on the console.

And why is the last 4 not displayed in the formatted result? Did you notice that? Okay. Lets try another example:

const num = 1234567890.1234;
const formatConfig = {
  style: "currency",
  currency: "USD", // CNY for Chinese Yen, EUR for Euro
  minimumFractionDigits: 2,
  currencyDisplay: "symbol",
};

// setup formatters
const britishNumberFormatter = new Intl.NumberFormat("en-GB", formatConfig);
const spanishNumberFormatter = new Intl.NumberFormat("es-ES", formatConfig);

// use formatters
console.log(britishNumberFormatter.format(num)); // US$1,234,567,890.12
console.log(spanishNumberFormatter.format(num)); // 1.234.567.890,12 US$

😃 Interesting! What happened here again?

Remember the second parameter in the Intl.NumberFormat? The options object? It is used to setup additional configurations for how formatterObject would format numbers passed to it. With properties such as style (possible values are "decimal" for plain number formatting, "currency" for currency formatting, and "percent" for percent formatting; the default is "decimal"), currency, maximumSignificantDigits (values are integers that determine how many significant digits the number to be formatted should have), minimumFractionDigits (having the value of an integer that determines the how many decimal digits the formatted number should have).

As in the second example, did you notice that the last two decimal digits (3 and 4) are not in the formatted number? That's because the minimum number of decimal digits we set in the options parameter as formatConfig, (minimumFractionDigits) was 2. See?

Apart from the format method on the formatterObject, there is also another method, the formatToParts method which returns an array of objects representing the number string in parts that can be used for custom locale-aware formatting.
For example:

const num = 1234.5678;

const britishNumberFormatter = new Intl.NumberFormat("en-GB");
const spanishNumberFormatter = new Intl.NumberFormat("es-ES");

console.log(britishNumberFormatter.formatToParts(num));
/*
[
  0: Object { type: "integer", value: "1" }
  1: Object { type: "group", value: "," }
  2: Object { type: "integer", value: "234" }
  3: Object { type: "decimal", value: "." }
  4: Object { type: "fraction", value: "568" }
]
*/
console.log(spanishNumberFormatter.formatToParts(num)); // 1.234.567.890,123
/*
[
  0: Object { type: "integer", value: "1234" }
  1: Object { type: "decimal", value: "," }
  2: Object { type: "fraction", value: "568" }
] */

formatToParts splits the formatted number into parts, and determines the digit type (integer or fraction) and the symbol type (group or decimal).

Other configuration options for options can be found in the MDN documentation for Intl.NumberFormat.

Experimental Features with Intl.NumberFormat

Some interesting features are being added to Intl.NumberFormat such as the ability to format with units (l, mi/h, mph), using exponential notations (E⁸, E^-2) and BigInt support. These features cannot be used in production code yet. At the moment, only Chrome 77+ provides support for these features.

const num = 1235.12;
const formatConfig = {
  style: "units",
  unit: "meter-per-second",
};

// setup formatters
const britishNumberFormatter = new Intl.NumberFormat("en", formatConfig); // 1,235.12 m/s

It's a pity but at the time of this writing, Intl.NumberFormat does not exist in Node.js.

All the best of all the best as you use Intl.NumberFormat to display numbers in styles customised for human languages and human-readable formats.

Cheers!

Darting into Flutter - My Experience

Orim Dominic Adah — Mon, 06 Jan 2020 03:25:29 +0000

Around the fourth quarter of 2019, my boss informs me about his plans to develop an e-commerce application for the clients of one of his companies. He asks me about what web application technologies I know of that can satisfy the requirements of the application, and after personal research, I presented my list of available options to him; subtly marketing React Native to him. This was because according to my findings, there were more developers in the community using it than the other options. It had to be the best, right? Popularity-driven development!.

One other reason I hadn't been sold the Flutter 'wave' was because I had to learn Dart (yet another language! 😭). I had learnt Java for developing android applications some years earlier and TypeScript when we had to develop Angular applications. Not another language again please! Please!

He summons me up some days later to tell me about Flutter and asks me about what I knew about it. I remind him that I had briefed him about it earlier, and how it does about the same thing as React Native (still marketing React Native to him, subtly). My boss tells me he thinks that Flutter is great for the next set of applications that he wants us to build (🙄 why won't an ardent fan of Google technologies think so? 😕)

My boss, being the awesome marketer that he habitually is, doesn't give me an opportunity to object at all. He quickly shows me sample applications built using Flutter. That was the first thing that got me hooked!

He makes me learn it with him, watching videos from the amazing Angela Yu of London App Brewery, who taught it in an energetic fashion. Second hook!

One framework for Web, Android, iOS and in anxious expectation, Fuschia. What's not to be hooked about? Hook three!

At this point, I had lost my skepticism over Flutter. I had become hooked! I was in, and it was as if the veil of bias over my perspective was lifted.

The last thing that got me hooked was the Dart programming language. Understanding it was easy because of my previous experience with Java and JavaScript. Dart seemed like a middle ground between both languages to me; without the perks of JavaScript and the relative complexities of Java. My boss kept affectionately calling Dart the best of both worlds.

Although I was pretty disappointed when I found out that Flutter for the web platform was still undergoing technical review and could not be used in production at the time, I was delighted that when it eventually becomes stable, I'll be one of the first to test it out. Hmm. The countless things a bias perspective can make you accept! 😉

I checked the Flutter community on Twitter, and was impressed with the timely updates and support I saw. Don't ask me! I've already added the 💙 emoji to my name on Twitter and have started following @FlutterDev, @MartinAguinis, @filiphracek, @remi_rousselet and Simon Lightfoot.

I hope to learn, make the best use of, have fun with and contribute to this awesome framework - Flutter - in the coming days.

Handling animations properly with the RxJS finalize operator

Orim Dominic Adah — Tue, 23 Jul 2019 06:57:52 +0000

I was building an Angular application recently which had to request for data from an API. Since I was using the Angular HttpClient, the response for the data request was wrapped in an observable by default.

Whenever a GET request for data was initiated, I wanted an animated ellipses to be displayed, indicating that the data retrieval process was ongoing. If the data was successfully retrieved, or an error occured during the retrieval process, the animated ellipses should exit the screen.

An observable is a data type that continually emits data to a subscriber that is attached to it. A subscriber is a data type that continually listens for data emitted from an observable it is subscribed to. When a subscriber subscribes to an observable, the subscriber is provided with three handlers to respond to the data that the observable emits. These three handlers are:

The next handler - executed when the observable source emits a new value from its data sequence,
The error handler - executed when an error occurs in the emission of values from the observable's data sequence, and
The complete handler - executed when there is no more value available to be emitted from the observable sequence

Assuming the getResults method below returns an observable, the next, error and complete handlers are exemplified in its subscribe method as shown in the code snippet below

getResults().subscribe(
  results => console.log('Next handler executed with results: ', results),
  error => console.error('Error handler executed with error: ', error),
  () => console.log(`Complete handler executed. All values have been emitted`),
);

Being a newbie to observables, I placed the method that hid the animated ellipses in the complete method as demonstrated in the snippet below

getResults().subscribe(
  results => displayResults(results),
  error => notifyOnError(error.message),
  () => hideAnimatedEllipses(),
);

and the animated ellipses was hidden (as long as the request returned no errors). Whenever there was an error, the animated ellipses still danced around the user interface alongside the error message displayed.

In order to solve this, the first thing I did was to execute the hideAnimatedEllipses() method in the complete and error handlers. Sure thing! It worked, but then I got to know about the finalize operator, a better way to get the job done.

Learning about the finalize operator not only solved my problem, it also exposed the fault in my understanding of the three subscription handlers.

I got to find out that after the error handler is executed, further calls to the next handler will have no effect, and that after the complete handler is executed, further calls to next handler will have no effect too. That was why the animated ellipses continued to confidently dance on the user interface in the first instance even after the error message was displayed.

finalize: The finalize operator is executed when an observable's source terminates on complete or on error.

I realised that in the execution of the finalize operator function is where the hideAnimatedEllipses() function should properly reside, and so the code was updated to the code snippet shown below

getResults()
  .pipe(finalize(() => hideAnimatedEllipses()))
  .subscribe(results => displayResults(results), error => notifyOnError(error.message));

In essense

The next handler is executed when the observable source emits a new value from its data sequence,

The error handler is executed when an error occurs in the emission of values from the observable's data sequence. After it is executed, further calls to next will have no effect, and

The complete handler is executed when there is no more value available to be emitted from the observable sequence. After it is executed, further calls to next will have no effect

The finalize operator is executed when an observable's source terminates on complete or on error.The code in the finalize operator is also executed when a subscriber unsubscribes from an observable, thus finalize acts like the finally method of a promise or a try-catch-finally block. Before RxJS v5.5, it was denoted as finally.

You can find more information about the finalize operator in the RxJS docs here

Cheers!😃

Using toLocaleString for number objects in JavaScript

Orim Dominic Adah — Mon, 15 Jul 2019 03:28:02 +0000

The toLocaleString method in JavaScript is present on the array, date, number object and object data types. This article focuses on the toLocaleString method on JavaScript number objects. Note that toLocaleString doesn't exist in Node.js as at the time of this writing.

The toLocaleString method, when called on a JavaScript number object (not a number literal like 234 or 3, but an identifier - a variable or a constant - with a number value), formats the number based on the values passed into it and returns a string representation of the formatted value. Well, so why not use toString if that's all the toLocaleString method does? Good question!

The toLocaleString method takes in arguments that tell it what human language to format the number object into. In other words, while the Britons will write 'five hundred thousand' as 500,000, the Spaniards will write it as 500.000. The toLocaleString will take the number 500000 and if you ask it to format it for the Britons, it will return '500,000'. If asked to format it for the Spaniards, it will return '500.000'. Everyone will understand the number in their native language. Talk about babel, but for JavaScript numbers to humans. It has support for Arabic too. Now, isn't that awesome?

Okay, talk is cheap. Show me the code.

let num = 500000;
let britishNum = num.toLocaleString("en-GB"); //en-GB: Great Britain English
let numeroEsp = num.toLocaleString("es-ES"); //es-ES: Spanish Spanish
let arabicNum = num.toLocaleString("ar-EG"); //ar-EG: Eastern Arabic
console.log("British representation: ", britishNum); // 500,000
console.log("Spanish representation: ", numeroEsp); // 500.000
console.log("Arabic representation: ", arabicNum); // ٥٠٠٬٠٠٠

Awesome init? Now here's some explanation, and some more toLocaleString awesomeness.

The format or syntax for the implementation of toLocaleString is like this: numObj.toLocaleString([locales [, options]]), where

numObj is the number object to be formatted,
locales represents a string (like es-ES or ar-EG) which is the language to be formatted into, (See this stackoverflow question for a list of locales codes.)
options is an object, with properties that contain some really extra-awesome formatting options, like formatting for currency, how many decimal places do you want ish. The square braces [] only mean that locales and options are optional. In other words, one can use the toLocaleString method without passing them in.

😲 So what language will it be formatted into if one doesn't pass in any parameters? To the default language of your browser of course!.

Now to the really extra-awesomeness part. Talk is cheap you say? Show me the code.

Currency formatting

let num = 500000;
let britishCurrency = num.toLocaleString("en-GB", {
  style: "currency",
  currency: "GBP",
});
let japaneseCurrency = num.toLocaleString("ja-JP", {
  style: "currency",
  currency: "JPY",
});

console.log("British currency: ", britishCurrency); // £500,000.00
console.log("Japanese currency: ", japaneseCurrency); // ￥500,000

Number of decimal places

let num = 500000.5525;
let british = num.toLocaleString("en-GB", {
  maximumFractionDigits: 3,
});
let spanish = num.toLocaleString("es-ES", {
  maximumFractionDigits: 2,
});

console.log("British: ", british); // 500,000.553
console.log("Spanish: ", spanish); // 500.000,55

Code shown. Now to the explanation, shall we?

The object passed in after the locales parameter contains properties which one can customise as they please to get the number format that they want. style
currency and
maximumFractionDigits are some of those properties. The object holding those properties is the options parameter in the syntax above.

You can view the MDN Docs on using the options object to customize your toLocaleString output.

Good luck using toLocaleString with number objects!

Cover image by sitepen