List of videos

How good are your tests? Would they still pass if the tested code was changed? If so, there may be problems with your code, your tests, or both! Mutation Testing helps reveal these cases.It makes lots of slightly altered versions, called "mutants", of your functions, and runs your functions' unit tests, using each of its mutants instead. If a mutant makes any test fail, that mutant "dies". "Survivors" imply flaws: your code might not be meaningful enough that a slight mutation would change the behavior, your tests might not be strict enough to catch the difference that the mutation made, or both! This talk will tell you how to use mutation testing, its benefits, drawbacks, and pitfalls, and how it works under the hood.There will be several examples(in clear pseudocode), and a list of tools for some popular languages(including of course Javascript). You will come away equipped with a powerful new technique for making sure your tests are strict and your code is meaningful. Slides: https://www.slideshare.net/slideshow/embed_code/key/aNJFQMKvzrBvO4 JSConf Hawaii will return soon https://www.jsconfhi.com/

Our story begins with a humble 'await fetch': your script fires off an HTTP request and settles down to nap, trusting that it'll be awoken when response data is available. While your program does nothing, a cascade of activity is now taking place: in your JS runtime, your operating system, and your hardware. What happens while your code is waiting for something to happen? In this talk, we'll peek behind the layers of the event loop, select/epoll nonblocking I/O, and hardware architecture to answer a simple question: what is waiting, and how does a program wait? Slides: https://chromakode.com/m/how-to-wait/ JSConf Hawaii will return soon https://www.jsconfhi.com/

Node.js 10.5.0 introduced 'worker_threads', enabling the creation of simple multi-threaded applications in JavaScript. This may sound daunting if you've never dealt with threads before in another language. But JavaScript threads are pretty simple and, very importantly, fun. This talk will be a quick introduction to the fun of worker_threads. I promise not to make any "you got your multi-threaded chocolate in my single-threaded JavaScript peanut butter" jokes. Thumbnail photo by Etienne Girardet on Unsplash Slides: https://www.palacefamilysteakhouse.com/multimedia/jsconfhi2020.pdf Story of University of Hawaii and Ethernet: https://mailchi.mp/d93c463d5650/the-secret-nerd-history-of-hawaii JSConf Hawaii will return soon https://www.jsconfhi.com/

Commenting code is a more nuanced thing than we give it credit for. There are a couple of schools of thought on this. One states that if you feel a comment is necessary, you should rewrite it to be more legible. This is true. But it's also not true. In the process of writing a comment, you can often find things that could be written better, but it's not an either/or, for the following reason: Code can describe how, but it cannot explain why. There is just not one right way or one reason to write a comment.In this session, we'll dig into some of the many beneficial types of comments that might all serve a different purpose, followed by patterns we might want to avoid. In the process we'll talk about being good teammates, collaborating, and writing the most legible code we can. JSConf Hawaii will return soon https://www.jsconfhi.com/

Who's the jock? The nerd? The misfit? Who's the type A overachiever, or the moody artist, or the partier? Get to know each of these JavaScript frameworks through the hallowed medium of the teen comedy. In this talk, we'll dig into what makes these frameworks unique, as well as the things they have in common. And, as in every good millennial teen movie, you'll leave with a better understanding of each one. Slides: https://slides.com/letakeane/react-vue-svelte/ JSConf Hawaii will return soon https://www.jsconfhi.com/

Custom Hooks in React are useful for much more than just managing the local state and one-dimensional side-effects you see in almost every React Hooks example. They can be used to build sophisticated memoization pipelines and chained-effects that automatically manage local and network resources. But most importantly, they provide a new new layer of abstraction to accomplish new and amazing patterns that we couldn't have just over a year ago. On the surface, this abstraction layer is simply collection of custom hooks, but when unlocked, it can be the most powerful piece of your application architecture. JSConf Hawaii will return soon https://www.jsconfhi.com/

Modern web applications have become increasingly costly in terms of size resulting in slower page load times in slower networks. Client Side Rendering (CSR) becomes a bottleneck in slower networks whereas Server Side Rendering (SSR) becomes a bottleneck when large volumes of content need to be generated in one-go. Progressive rendering is a technique that allows us to flush portions of a webpage to the browser in chunks as soon as they are rendered on the server without having to wait for the whole page to be rendered. This will massively improve the FCP (First Contentful Paint) and FMP (First Meaningful Paint) metrics and reduce page load time in slower networks. This talk will demonstrate effective ways to progressively render a webpage from the server to the client and highlight important performance aspects of rendering modern websites. Slides: https://www.icloud.com/keynote/01RnZigm2R6g9FwMXVQ8uwmKw#jsconf-hi JSConf Hawaii will return soon https://www.jsconfhi.com/

TC39 is the international standards committee in charge of charting the future of JavaScript through the ECMAScript standard. In this panel, members of the committee join Cassidy Williams to answer questions sourced from the JSConf Hawaii audience, including questions about how the committee decides on changes to the language, and how companies, organizations, or individuals can get more involved. Learn more about TC39: https://github.com/tc39 JSConf Hawaii will return soon https://www.jsconfhi.com/

Modern websites are often composed out of megabytes of JavaScript – not all of which we wrote ourselves: Ads, social plugins, tweets, instagrams, video players and other things get assembled together and more often than not don’t play all too well with each other. When we started the AMP project we quickly realized we’d have to support this type of third party JS. In this talk we’ll do a deep dive into how we manage to maintain page performance and decent user experience nonetheless. Bring your wetsuit, because we’ll dive deep into some of the more rarely explored corners of the JavaScript language.