gregbabula

[gregbabula]

10 Things I Regret About Node.js - Ryan Dahl

[gregbabula]

Designing very large JavaScript applications

Over the last years a modular approach to programming in JS gained a huge following and with the advent of virtual DOM building isomorphic JavaScript application for the web became dramatically more approachable; yet, we are still largely deploying monolithic application blobs that know how to render the settings page of our single page apps before accepting user input on the homepage. 

 My talk will explore 2 primary themes: 

 How to build highly sophisticated web apps that load a constant amount of JS to make the first page the user sees interactive; where constant means, even if you have 100s of engineers write code for your app for a year, the size will still be the same. How to throughout the lifecycle of your application never load a single line of JS that is not currently needed.

As part of this exploration I will introduce 3 novel concepts: lazy decoration, asynchronous dependency injection and reverse dependencies in module systems.

[gregbabula]

Async patterns to scale your multicore JavaScript elegantly.

“JavaScript is a toy language because it doesn’t support multithreading.” Heard that one before? Although the event loop means our program does one thing at a time, JavaScript is actually well-suited for a plethora of concurrency problems while avoiding typical multithreading woes. You might say JavaScript is single-threaded… just so it can be multithreaded!

[gregbabula]

Advanced Async and Concurrency Patterns in JavaScript

Kyle Simpson, better known as Getify, speaks about Advanced Async and Concurrency Patterns in JavaScript at the JS.LA meetup.

[gregbabula]

High Performance JS in V8

This year, V8 launched Ignition and Turbofan, the new compiler pipeline that handles all JavaScript code generation. Previously, achieving high-performance in Node.js meant catering to the oddities of our now-deprecated Crankshaft compiler. This talk covers our new code-generation architecture - what makes it special, a bit about how it works, and how to write high performance code for the new V8 pipeline.

[gregbabula]

Circular References in Node.js

In Node.js, when a circular reference is detected, the require that triggered that reference returns an empty object instead of the normal full object. For example, here is one module in a file called circularReferenceB.js:

const circularReferenceA = require('./circularReferenceA'); module.exports = { printProperty1: () => { console.log(circularReferenceA.property1); } };

And here is one in circularReferenceA.js which is run directly with node circularReferenceA.js:

const circularReferenceB = require('./circularReferenceB'); circularReferenceB.printProperty1(); // undefined module.exports = { property1: 'value1' };

The circularReferenceB.printProperty1 returns undefined because circularReferenceA has not been initialized yet. A log in circularReferenceB.js makes this clear:

console.log('circularReferenceA require:', circularReferenceA); // circularReferenceA require: {}

Keep in mind the required relationships don’t need to be directly circular. For example, A->B->C->A will result in C getting an empty A module by default. The key is that JavaScript is executed dynamically, so each require is executed as it is found. So circularReferenceB.js gets the non-initialized circularReferenceA.js which is empty by default.

There are a few general ways to fix this:

Duplicate needed code: Simple and gauranteed to work, but this can create maintainence nightmares.

Set any module.exports at the top: If this is set before any code is run, at least that code should be getting the latest version of the module. The issue is if the module.exports requires the code in the module to be run first to generate some of its content.

Use dependency injection The part of the needed module can simply be passed in. There is some up extra logic needed for this across multiple modules, but it should handle every situation without code duplication.

Below is an example of 3 given the above files. Firstly circularReferenceA.js:

const circularReferenceB = require('./circularReferenceB'); const property1 = 'value1'; circularReferenceB.printProperty1(property1); // value1 module.exports = { property1: property1 };

And circularReferenceB.js:

const circularReferenceA = require('./circularReferenceA'); module.exports = { printProperty1: (property1) => { console.log(property1); } };

Despite all of the above, it is best to evaluate why a circular dependency came up because it almost always indicates a flaw in software architecture. Though when the timelines are short or there is no way around the relationship, then keep in mind the above.

Github Location: https://github.com/Jacob-Friesen/obscurejs/blob/master/2017/circularReferenceA.js

[gregbabula]

Debugging in 2017 with Node.js

[gregbabula]

Is JavaScript Making Us Better Professionals?

We can all agree that JavaScript is a trending programming language. But is this a good thing? Is JavaScript the right language to learn or to study? Can we push the language into the academic field so that students are better prepared for the jobs of the future in IT? 

[gregbabula]

A Story About Types and JavaScript

Why do we exactly need those types? Are we not choosing Javascript for its dynamic nature? Let's see how a bit of rigour can help us on the long run.

[gregbabula]

Warping Time with Async/Await

The JS world is a constant surprise. Just look at the recent years and you'll see why. The language itself is maturing and the angles from which we look at it are becoming more and more diverse. We've arrived from 10-year release cycles to yearly feature upgrades. ES2017 is upon us and together with it, a new tool that gives us time-warping superpowers: Async/Await. Come learn (almost) all there is to know about it and how you can start using it today. It's going to be fun!

[gregbabula]

Static and Dynamic Next.js

With Next.js, you can create React applications that automatically server-render, code-split and hot-reload, with no setup. This talk will explore the two most powerful new features of Next.js: static exports and dynamic imports. These allow for the creation of high-performance advanced applications, examples of which we'll demonstrate live, on stage.

[gregbabula]

How to get started and build something with GraphQL

GraphQL presents new ways for clients to fetch data by focusing on the needs of product developers and client applications. Building a product with GraphQL is easy once you wrapped your head around the key concepts: many awesome tools are around and it's a real pleasure to use them.

[gregbabula]

V8, Advanced JavaScript, & the Next Performance Frontier

“This talk will help developers write performant JavaScript, use new language constructs (ES2015+, async/await, etc.), and learn about the latest developments in modern benchmarking. We'll also demo DevTools asynchronous debugging features and new JavaScript code coverage tools.”

[gregbabula]

Next.js: Universal React Made Easy and Simple

[gregbabula]

What the... JavaScript?

Kyle Simpsons talk for Forward 2 attempts to “pull out the crazy” from JavaScript. He wants to help you produce cleaner, more elegant, more readable code, then inspire people to contribute to the open source community.

[gregbabula]

JavaScript Patterns for 2017

The JavaScript language and ecosystem have seen dramatic changes in the last 2 years. In this sessions we'll look at patterns for organizing code using modules, talk about some of the pros and cons of new language features, and look at the current state of build tools and build patterns.

[gregbabula]

ReactCasts #9 - Immutability in JavaScript

In this episode I'll talk about why immutability is important and how it can benefit you. I will draw some comparisons between JavaScript (which doesn't treat data as immutable by default) and programming languages that have immutability built in. Finally, I will show how to make immutable operations in plain Javascript.