I had the pleasure of attending NodeConf Oslo, a one day event on June 4th. As this was my first JS/Node conference ever, I didn’t quite know what to expect, but I was really looking forward to it! In the end I can honestly say it was an awesome experience, one that I definitely won't forget.
But enough of me and more of what really matters, how it was and what happened exactly.

During the whole day we got to enjoy awesome talks that went from running Node in production, to Node-powered desktop apps through Electron, Node on microcrontollers…
So, you’ve probably guessed it, if I had to sum up the whole day:

Although I'm only highlighting a few of the talks, they were all brilliant. The ones listed and described below were just my personal favourites, so take this with a (very large) pinch of salt. Probably the best thing for you to do is to also check the videos of all the talks. Trust me, you won't regret it!

Running and successfully deploying NodeJS apps in production can sometimes be a buzz-kill. It happens and we've all been through it, we've got that amazing app, but how can we successfully deploy and run it, with minimum effort and without compromising any of its performance? Well, luckily, our very own Luke Bond showed us how you can easily setup a NodeJS app using regular Linux tools, like systemd.

And why would one do such a thing instead of using something like PM2? Luke gave a number of reasons for it, but probably the most important one may be that, as it turns out, not everyone is a NodeJS developer (yeah, I'm just as surprised as you!). Therefore, the ability to use regular Linux tools is sometimes a great plus for organisations that, for example, have a sys admin/devops team used to administrate a set of linux machines.

Over the course of the talk other tools are highlighted, like balancer, a very tiny lightweight load balancer, and how you can use it to compose your app environment.

If you think this is awesome, believe me, I can tell you this is even better than you would expect! Do yourself a favour and do check the video of this talk.

Live coding presentations are always a bit risky, aren't they? Well, let me tell you, definitely not for Kelsey. Hers was absolutely awesome! She presented the Tessel 2, a prototyping IoT board running NodeJS.

In case you're wondering, this is quite something, because suddenly you have the whole power of Node + NPM on a simple micro-contoller which, as Kelsey showed us, is pretty easy to setup and develop on. In no time she was blinking LEDs, running HTTP servers allowing everyone to interact with the board and even tweeting based on some environment change. Have a look at the talk, it is really worth it.

Remember the days when developing for the desktop implied the chaotic management of dependencies and constraints for endless different systems? Node on the desktop was a breath of fresh air a lot of people were looking for. But how does it work under the hood? Thankfully Evan showed us, giving a brilliant talk on how the Electron framework came to be.

Based on Node Webkit, Electron was the merge of Chromium and Node into a single runtime with the ability to make your apps have the look and feel of your common native app, while being the product of web based technologies. Chromium powers your window views, allowing you to use our much loved HTML, CSS and Web APIs. On the other end, Node gives you access to your real system, with all the core modules we're so used to. This was no easy feat it seems... I was honestly staggered to see how they pulled the amazing engineering stunt of merging the two event loops, the Node one (using libuv) and the Chromium one, through a third event loop to hook them all together. It was only when Evan opened the console inside his application, made a require('fs') and started showing that it was just what you would expected it to be, that it really hit me how awesome this all was. I truly advise you to see it for yourself, check the talk here.

Test Driven Development can sometimes be a spooky word for a lot of developers. And while for some this might mean "a whole bunch of tests everywhere" it's actually a little more than that. Justin presented in a awesome way what TDD really is and the benefits of using it.

The core idea is really simple, when implementing some new functionality start by writing a test that fails, then write the bare minimum code needed in order for the test to succeed, finally refactor your code in order to keep it simple and maintainable. Pretty simple right? Well, it turns out, it's not always that easy. That's why Justin demonstrated some of the approaches you should use, how you should use them and he even showed a library he built to help you out while building your tests, called testdouble.js. If you're still sceptic about TDD, my suggestion is for you to definitely watch his talk.

Eirik gave what was, for me, one of the best talks of the day. It had the perfect mix of mad science engineering and escalator gifs (yeah, you've read it right). He presented two stories about two distinct persons called Erik (such coincidence am I right?).

The first one was a brewer facing some problems during his brewing process. Luckily this brewer saw a chance to improve this same process by first using what seemed like everyone's first NodeJS stack, a tangled mess of NodeJS and PHP and finally ended up on a fullstack JS real time system that allowed much more than just measuring the brewing stats... Let's just say that Eirik presented what might have been the first musical composition I've seen made by a black IPA (and no, I wasn't drunk).

After having your mind blown by the first Erik story, the second Erik didn't disappoint at all. He managed to hack a slot car racing track and create a VR game out of it where, by using a Google cardboard, you could drive a car in the slot track through a web page.

If you're like me and this whole idea managed to awake your inner mad engineer, I think you'll really love to watch the whole talk here.

Monkey patching is something that, in some contexts, might make any sane developer start itching and twitching just from thinking about it. Fortunately, the scenario Thomas presented us with was nothing like that.

Today, instrumenting NodeJS can be a painful task due to the async nature of it. Imagine you have your regular HTTP server and you want to follow the life cycle of a request, keeping track of each stage of it while also tracking the IO, all of this with little to no overhead (remember, production). It shouldn't be that hard, right? Well, wrong... Unfortunately, NodeJS is still lacking an API which exposes to the userland the ability to maintain context across async calls, which is something we definitely need in order to keep track of the context of every HTTP request you receive. So, shall we give up? Well, Thomas showed us that there's no need to panic if you correctly patch every async operation in Node core. The result? It's pretty amazing! But if you don't believe me, check the talk.

Overall, it was really cool to get to meet such inspiring speakers and attendees. It turns out, we're just people coming from all around the world, sharing the same love for NodeJS. And all of this was only possible thanks to the amazing work done by the organisers of NodeConf Oslo, who put together a truly amazing event.