Node + Javascript Interactive 2018, and other things that I found in Vancouver

Recently I spent a lovely week in Vancouver hearing talks and chatting with some fantastic Javascript developers from around the world. This was my first time attending Node + Javascript Interactive 2018 conference; an event focused on bringing together the maintainers, end users, vendors, and companies focused on advancing Node.js and Javascript ecosystem.

It was a really cool experience, on top of it that was also my first time in Canada, and hosted in one of the best Convention Center in the world. And I came away from the event feeling profoundly inspired and confident in the Node.js, Javascript projects and the community behind it.

Having visited the event made me realize how immense the community has grown, but still, at the same time need to put in the work to evolve our governance and our process to do better.

Serverless, security, diagnostics, machine learning, and the Internet of Things are a few of the many different topics that covered during Node + Js Interactive.

But first, let’s not ignore the elephant in the room, which is..

The City

I didn’t understand when I came across Canadians who live in Vancouver joking about they live in igloos. The wonder immediately answered the second my friends and I landed at Vancouver International Airport. It was the most blazing hours in the day, and it’s only 13 °C.

That said, the first hour I was in Vancouver, I already felt like at home due to the warm welcome from the locals and a lot of areas to explore.

at University of British Columbia
at University of British Columbia

Not too far from my hotel, there is a public park named Stanley Park. It was massive. I really mean it, it was like a giant park on steroid. The walkway around the park is the world’s longest uninterrupted waterfront walkway. With a view of the coast at one side and forest on the other hand, it was challenging to hold the urge of not to run through it.

Still adapting with the new weather I wasn’t confident at first though. Considering I never did long distance runs in this kind of weather, I honestly didn’t know whether it was a wise choice or a stupid one 😂. But I was like “screw it let’s do this”, then I gasped, took my running shoes, pulled the bull by the horns and went for a run anyway.

It turned out quite a delight though… 😃

After a half marathon run at Staley Park Seawall

The Venue

Image creditsource

The event took place in the Vancouver Convention Center, one of Canada’s largest convention centers. The building hosted the International Broadcast Centre for the 2010 Winter Olympics and 2010 Winter Paralympics.

It was huge and lovely, the events room was spacious, the WiFi adequate, and the staffs were helpful. And it has this giant pixelated dolphin statue right outside the entrance:

photo by: Rama Dimasatria

The Talks

There are a lot of talks presented in a day, in some cases, there can be four talks given at the same time. So I can’t go to all the presentations if I want to.

That being said, I still was bombarded with so much great content, here are some of my highlights.

Opening Remarks

Jory and Tracy kicked everything off with some opening remarks. I liked that a Code of Conduct was mentioned and I like the idea of different colors of lanyards represent whether certain people willing to actively engaged in conversations or no.

Programmers Don’t Like People?… Or Do They?

Photo by: Rama Dimasatria

April Wensel was first to speak — she gave an excellent talk on the topic of a prevalent issue that software engineers are having nowadays: a not healthy stereotype of good programmers and why we should choose compassion as the pilot.

Since the early days of computing, the prevailing stereotype has been the isolated, sedentary, sleep-deprived, antisocial programmer.

The culture that has developed around this harmful stereotype has led to unbalanced and ineffective teams, destructive behavior in our communities, and the high incidence of burnout among developers. The software may be built on machines, but it’s produced by and for human beings.

She started to explain why this issue is essential. Here were my main takeaways:

  • There are a lot of suffering in the software industry: stress & burnout, “talent shortage,” lack of diversity, poor UX, unethical products, failed projects, etc.
  • We don’t care enough about humans,
  • Compassionate coding: a conscious business bringing emotional intelligence and ethics to the tech industry through training, coaching, consulting, speaking, and writing.
  • Definition of Compassion: “The feeling that arises when you are confronted with another’s suffering and feel motivated to relieve that suffering,”
  • Benefits of compassion: joy, resilience, peace of mind, job satisfaction, and a lower chance of burnout.

Practice being compassionate can be adopted in many different areas and workflow in our day to day workflow.

How to be a good programmer? Use compassion as a guide. Technology is inherently about compassion because we are supposed to make people’s lives better.

Building Great CLI Experiences in Node

Jeff Dickey’s talk titled “building Great CLI Experiences in Node” was an excellent guide to make awesome CLIs. Moreover because of that nowadays, there is a renewed interest in CLI applications to help automate everyday tasks and improve developer experience by building on top of APIs. Compared to web apps, CLIs are much faster to build and work great for developer tools and admin interfaces.

In this talk, Jeff, a CLI engineer at Heroku, introduced the oclif CLI framework built from the Heroku and Salesforce CLIs to show how to create flexible CLIs of our own easily.

CLIs are powerful because they could provide:

  • repeatable or composable tasks,
  • creating maching-readable output,
  • scripting,
  • interacting with an API

Some principles to keep in mind when building your next CLI application:

  1. Having proper help documentation is essential,
  2. Prefer flags to args,

A CLI can accept two types of shell inputs: flags and args. Flags require a bit more typing but make the CLI much clearer.

For example, in the Heroku CLI, there is a command called heroku fork. It took in a source app to copy from and a destination app to copy to. Initially, this used a flag and an argument like this:

$ heroku fork FROMAPP --app TOAPP

Using a flag and an arg, it was really confusing which was the source and which was the destination app. It will be much brighter if we changed this to use flags for both:

$ heroku fork --from FROMAPP --to TOAPP

3. Ensure you can get the CLI version through any of the following:

$ mycli version # multi only
$ mycli --version
$ mycli -V

4. Mind the streams.

5. Handle things going wrong by make your errors informative,

6. Be fancy! :D

7. Make prompts if you can.

8. Use tables to give output data.

9. CLIs need to start quickly. Use $ time mycli to benchmark your CLI.

  • <100ms: very fast (sadly, not feasible for scripting languages)
  • 100ms–500ms: fast enough, aim here
  • 500ms-2s: usable, but not going to impress anyone
  • 2s+: languid, users will prefer to avoid your CLI at this point

10. Encourage contributions, keep your code open source.

11. Be clear about subcommand.

12. Follow XDG-spec.

From Parentheses to Perception: How Your Code Becomes Someone Else’s Reality

Jenna Zeigen took us on an exciting journey on how does code become neurons firing in someone else’s brain. The unique part of this talk is the slides contains lyrics of songs that somehow represent the ideas in every slide. I don’t understand how she did this.

My takeaways from the talk were, there are four steps how codes finally represent something in our mind: Parsing, Rendering, Perceiving, and Comprehending.

Slides are available here.

Math In JavaScript Can Be Awesome

Dominic Kramer opened my eyes to a different way to consider doing math in Javascript. We know that TensorFlow.js (js.tensorflow.org) are powerful tools for utilizing machine learning in JavaScript. However, their capabilities extend beyond machine learning.

In this talk, he demonstrated that how these libraries are making JavaScript an excellent platform for mathematics and scientific computing in areas beyond machine learning by showing concrete examples of using the libraries to explore other exciting areas of mathematics.

Create an Engaging Native Mobile App with Vue and NativeScript

Jen Looper gave an informative talk introducing Nativescript. If you have a website build with Vue.js, with this framework, you can engage users even further through the native mobile app using the same technology.

In this talk, Jen explained the mechanic and the process building Elocute, a web app for language teachers with a paired mobile app that students use to perfect their spoken language skills.

Some highlights why Vue is great for mobile:

  • Vue’s 2.0 adoption of the virtual DOM enables native mobile rendering (Angular 2+ is similar),
  • Vue offers a great way for web developers to embrace mobile platforms via NativeScript or Weex,
  • Vue is lightweight so highly appropriate for mobile,
  • NativeScript and Vue have great code-sharing potential

The Q&A at the end of the talk is also interesting, such as:

  • Which one is better, start building the web app or mobile app? There is no particular recommendation, but most people build the web first, knowing that vue is since the beginning designed for websites.
  • The info about hot reloading feature that will be released soon.

There are some other talks about Vue, but I couldn’t watch because of the time constraint, such as:

  • A React Point of Vue — by Divya Sasidharan, Lucro Global LLC [presentation],
  • Vue Vixens Workshop — by Jen Looper, Progress

GraphQL — Accelerated

GraphQL is a query language that is rapidly gaining broad adoption across the community. It combines type validation with a query and filtering syntax that makes it easy to get up-and-running with a powerful web API in almost no time. Features like running parallel queries or update-all become much more comfortable because they are first-class citizens of GraphQL. Add to that a vibrant community that keeps creating excellent tooling and documentation; it’s clear why GraphQL has become so popular with developers.

But every abstraction has a cost, and GraphQL is no exception. The added complexity and a new schema format to parse and execute mean new performance bottlenecks. In addition to performance issues, the wrong use of GraphQL can lead to architectural bottlenecks.

Instead of viewing this as a problem Matteo & Mathias took this as a challenge. In this talk, they covered what GraphQL is, why it’s great and how they made it run a lot faster on Node.js, in fact, much faster.

Machine Learning in the Browser with deeplearnJS

Even if you’ve never done anything with machine learning, you have probably already heard that it will change our way of thinking about computing forever. But how can you a web developer, who’s never been interested much in statistics benefit from the ML hype?

In this talk, Lian Li first explain what the difference between Expert Systems and Machine Learning. And then, she gave the tools to build a small self-learning application that runs entirely in the browser with deeplearn.js.

The code that presented in the talk is available here on Github.

Standardizing JavaScript — a Look at Ecma and TC39

It was Jory’s talk. Actually I didn’t watch this talk in full since it began, but still the last 10 minutes of the presentations were quite interesting.

The talk led us on a brief history of Javascript and introduction to Ecma, the standards body home to the JavaScript specification and its standardization efforts, what it means to create and implement open standards, and describe TC39’s role and impact on the world of web standards.

Jory Burson opened my eyes that how we create technology is as important as the technology itself.

NPM and the future of Javascript

Laurie Voss gave a fantastic talk on insights he had gathered, studying the NPM data. NPM has more than 10 million users, and they download 7 billion packages a week. In the talk, he stated that it gives them more data about what JavaScript users are doing and where the community is going than anybody else.

He presented the talk in three parts:

  1. What you should know about npm,
  2. What npm knows about you, and
  3. The future of JavaScript

He gave some suggestions on what will be hot in 2019 and where the community is going. Here were my main takeaways:

  • React is slowing down,
  • Angular is seeing fewer downloads,
  • Vue most likely will be the next big thing (?),
  • GraphQL libraries are on the rise,
  • Learning from history: nothing last forever,
  • If people start re-using React modules, React will live forever,
  • Web components would be great if they worked but they don’t, yet…

And here some advised prediction for 2019:

  • Learn GraphQL,
  • You will be bundling, transpiling and linting for quite some time,
  • Use Typescript,

But whatever happens next, the future looks fun though ;D

Performance Optimizations for Progressive Web Apps

Most web developers can build a responsive site, but fail to meet performance requirements for mobile. In this talk, Chris Lorenzo covered why the performance of your site is so important and dive into the Chrome performance tools to explain precisely how a browser loads a site and what causes things to slow down.

Lastly, he also talked about how to create your own PWA with service workers and app installs. The slide is available here https://bit.ly/2kYFOjk.

Some other talks that also covered Progressive Web Apps topic:

  • Cross-platform Progressive Web Apps — by Simon MacDonald, Adobe [slides]
  • Bridging the Designer-Developer Gap, PWA Edition — by Antoinette Janus, PBS Kids [slides]

Optimize Your JSON Payload Efficiency x10 times

In Cloud deployments, we foresee an exponential increase of JSON payload across distributed end-points, causing performance bottleneck in the application. In this talk, Gireesh Punathil presented a truly asynchronous version of standard JSON APIs that is highly scalable, fault-tolerant and highly consumable.

The critical functions of these APIs are to perform marshaling / un-marshaling of extensive data incrementally and yielding back to the application occasionally, improving the overall concurrency of the system, improving concurrency level by ten times above 1MB of JSON data.

Actually, I thought the speaker talked very slowly and not so clear to my ears, which may be because of at the time I sat on the back row. But detailed slides are available here for download.

Another talk that also in scaling related theme:

  • The Art of Building Node.js Projects at Scale — Raymond Feng, IBM [slides]

Scaling Webpack to Thousands of Concurrent Builds

Charlie Robbins’ talk titled “Scaling Webpack to Thousands of Concurrent Builds” was an excellent follow on what to do if you need a lot of builds across multiple environments like development, test, and production.

This talk covered the challenges (and solutions) to scale webpack & npm install to thousands of daily builds with high bursts of concurrency during peak hours.

Fast Talks

Before the closing remarks, we had “fast talks,” these were 10 minutes long talks on a variety of subjects.

Developing Code, Confidence and Community

First up, Corinne Warnshuis share some inspiring stories of empowerment from the community especially for women that interested in computer science.

Controlling Tesla Model 3 from Node.js

Next up, and my favorite fast talk was by Alex Roytman, demonstrated controlling Tesla Model 3 using Node.js and a tablet.

JavaScript: Enterprise Adoption and Usage

Despite being over two decades old, not until recent years has JavaScript indeed been acknowledged as a first-class citizen within corporate enterprise software.

And finally, we had Garth Hansen leading us to look at some of the hurdles JavaScript has overcome to reach its current level of adoption. And also a glance into JavaScript architecture and tooling being used today within The Walt Disney Company.

Final Thoughts

I thought this was an excellently ran conference. It included great speakers, engaging sponsors, and allowed a fantastic community to meet up — what else could you want!

Another interesting thing is that if we look at the range of companies represented by the speaker it would be hard to find more different areas of concern. We had someone from a commerce business, top open source projects, a finance-related company, not-for-profits and more! But yet there was still these common themes recurring again and again.


Some other takeaways that might be helpful if you are going to conferences regarding the seating perspective:

First, If you want the maximum focus on the talks and more likely want to engage with the speaker, sit in the front row. The second row from the front is my recommendation. Your head would not too cramped to look at the screen, but good enough to document the talk. I found a lot of people who take notes always in the front rows.

Second, Say hi to the closest person sitting in your row, or in the front, or the in the back. You know what, if you really want to talk to a person even if they’re 10 meters from you, just walk and say hi.


Last but not least, I’d like to thank Bukalapak for sponsoring my trip to this awesome event.

And I’d also like to recommend other tech companies to do the same, giving opportunities to their engineers to be engaged closely with renown engineers in the industry all over the world. I think it will provide colors to our local community in Indonesia, and will improve our tech culture in many different ways in the long run.