Awesome JavaScript Talks

Anjana's next talk at JSConf EU in May: http://2017.jsconf.eu/speakers/anjana-vakil-immutable-data-structures-for-functional-js.html Slides: https://slidr.io/vakila/learning-functional-programming-with-javascript

JavaScript programmers like to use words like, “event-loop”, “non-blocking”, “callback”, “asynchronous”, “single-threaded” and “concurrency”. We say things like “don’t block the event loop”, “make sure your code runs at 60 frames-per-second”, “well of course, it won’t work, that function is an asynchronous callback!” If you’re anything like me, you nod and agree, as if it’s all obvious, even though you don’t actually know what the words mean; and yet, finding good explanations of how JavaScript actually works isn’t all that easy, so let’s learn! With some handy visualisations, and fun hacks, let’s get an intuitive understanding of what happens when JavaScript runs. Transcript: http://2014.jsconf.eu/speakers/philip-roberts-what-the-heck-is-the-event-loop-anyway.html License: For reuse of this video under a more permissive license please get in touch with us. The speakers retain the copyright for their performances.

See also https://github.com/ry/deno JSConf EU is coming back in 2019 https://2019.jsconf.eu/

Slides: http://www.slideshare.net/floydophone/react-preso-v2 React, the new open-source JS library from Facebook and Instagram, is a different way to write JavaScript apps. When it was introduced at JSConf US in May, the audience was shocked by some of its design principles. One sarcastic tweet from an audience member ended up describing React's philosophy quite accurately: https://twitter.com/cowboy/status/339858717451362304 At Facebook and Instagram, we're trying to push the limits of what's possible on the web with React. My talk will start with a brief introduction to the framework, and then dive into three controversial topics: Throwing out the notion of templates and building views with JavaScript, "re-rendering" your entire application when your data changes, and a lightweight implementation of the DOM and events. License: For reuse of this video under a more permissive license please get in touch with us. The speakers retain the copyright for their performances.

Have you ever had a bug where things were happening in the wrong order, or particular style changes were being ignored? Ever fixed that bug by wrapping a section of code in a setTimeout? Ever found that fix to be unreliable, and played around with the timeout number until it kinda almost always worked? This talk looks at the browser's event loop, the thing that orchestrates the main thread of the browser, which includes JavaScript, events, and rendering. We'll look at the difference between tasks, microtasks, requestAnimationFrame, requestIdleCallback, and where events land. Hopefully you'll never have to use setTimeout hacks again!" Jake is developer advocate for Google Chrome. He's one of the editors of the service worker spec, so he's into offline-first, push messaging and web performance. JSConf.Asia - Capitol Theatre, Singapore - 27 January 2018 Source: https://2018.jsconf.asia/ License: For reuse of this video under a more permissive license please get in touch with us. The speakers retain the copyright for their performances.

http://2017.jsconf.eu/speakers/anjana-vakil-immutable-data-structures-for-functional-js.html Functional programming has been gaining a lot of popularity in the JS community, and with good reason: rejecting side-effects and mutability - in-place changes to data - helps avoid a lot of headaches. But when you refuse to mutate objects, you have to create a whole new object each time something changes, which can slow things down and eat up memory, making functional programming seem inefficient. That’s where immutable data structures come in - to save the day, and time and space! Also called “persistent data structures”, they help you efficiently make new “modified” versions of immutable objects, by reusing parts of the old object that you don’t need to change. In this talk we’ll take a look at how these data structures work, why they’re fantastic for functional programming, and how we can easily use them in our JS code thanks to libraries like Mori and Immutable.js.

Slides: http://afabbro.github.io/jsconf2013/ I am not an expert developer. I am also not a beginning developer. I'm an intermediate developer, and I want to navigate the path from being a mediocre or good developer, to becoming a great or expert level developer. How in the heck do I do this? The tutorial ecosystem of the web is heavily skewed towards beginners, but what about the rest of us? If you identify with these statements in the slightest, then this talk is for you. With ideas from cognitive science, education, and some advice from admired programmers along the way, we are going to explore what it means to be a world-class developer and what we need to do to get there. I'll talk a little bit about the philosophy, attitude, and habits (both good and bad) required for learning how to learn better, and then we will talk about the kinds of skills and knowledge that an expert programmer in general needs. Along the way we'll touch about various myths and cognitive biases about who can and cannot be a great programmer, and leave you with a path to get started. By the end of the talk, I will have proposed a curriculum of topics that should take an intermediate developer and turn them into an advanced one, and special attention will be given to mastery of the JavaScript language. Meet Angelina Angelina Fabbro is a programmer based in Vancouver, Canada and works at Steamclock Software. Angelina has a background in cognitive science, building clever robots and researching what people pay attention to. Her record as a web developer is balanced with modern iOS experience and a keen sense of design. Angelina also both teaches and mentors for the Vancouver chapter of Ladies Learning Code.

http://2017.jsconf.eu/speakers/franziska-hinkelmann-javascript-engines-how-do-they-even.html Want to know how JavaScript engines work? Why is JavaScript so fast? What is just-in-time compilation? We’ll look at basic concepts of compilers, challenges posed by modern JavaScript, and how to write compiler-friendly JavaScript.

Generators have been around in JavaScript since ES2015, yet remain largely ignored by many JS devs, who don’t see why or how they’d use them in their day-to-day work. But generators - which we can think of as special functions whose execution can be “paused” and resumed later on - are actually extremely powerful tools for producing and consuming series of data. That makes them perfect for implementing lazy sequences, custom iterables, animation, even the convenient asynchronous programming we now enjoy with “await”! In this talk we’ll dive into how JS generators work, what makes them so powerful, and why you should care. https://jsconfbp.com/speakers/anjana-vakil About Anjana: Anjana suffers from a chronic case of curiosity, which led her from philosophy to English teaching to computational linguistics to software development. These days she mostly codes & teaches from her home base in San Francisco, but she’ll always be a traveler at heart. Nerd out with her about functional programming & JavaScript, ask her about the Recurse Center & Outreachy, and definitely invite her to your karaoke party!

https://2018.jsconf.is/speakers/dan-abramov/ React 16 was released several months ago. Even though this update was largely API-compatible, the rewritten internal engine included new long-requested features and opened the door for exciting future possibilities. In this talk, Dan will share the React team’s vision for what the future of React might look like, including some never before seen prototypes. Whether or not you use React, Dan hopes that you will find something valuable in this talk, and that it sparks new conversations about building delightful user interfaces.

Frameworks exist because writing maintainable apps in vanilla JavaScript is hard. But frameworks aren’t free: downloading and parsing those extra bytes slows things up, just when your users are deciding whether to stick around. Instead of choosing between bulky frameworks and maintainability nightmares, what if we could tell the computer ‘here are the blueprints, now you write the code’? In this talk we’ll discover a new breed of tools, such as Svelte, that let you do exactly that. OMG JSConf EU is coming back in 2019 https://2019.jsconf.eu/

It’s clear by now that the robots are coming for us. Breakthroughs in AI fill our streams and news feeds, themselves the products of AI, the echoing algorithmic screams of a new kind of mind being born. Using deeplearn.js, we’ll find out how deep learning systems learn and examine how they think. The fundamental building blocks of AI have never been more accessible. Let’s explore the architecture of these new minds, which are growing to mediate our every interaction. JSConf EU is coming back in 2019 https://2019.jsconf.eu/

We all take for granted that when we push enter in the browsers address bar, magic happens. The browser gets our HTML, that intern requests all the dependencies, insert magic, other things happen and then we have our site rendered. Simple, right, right… Like many people as I’ve progressed in my career, building for the web, I’ve become curious as to how the browser does what it does. What makes it tick, how it turns a string of HTML into a data structure, how CSS & JavaScript come into play. Things like render tree, style recalculation, paints, reflows, all alien words will start to make sense by the end of this talk. Suddenly you’ll understand why people recommend you place script tags at the bottom of the document, inlining critical CSS & all sorts of other performance techniques. Intro music by @halfbyte

The JS package commons is in the hands of a for-profit entity. We trust npm with our shared code, but we have no way to hold npm accountable for its behavior. A trust-based system cannot function without accountability, but somebody still has to pay for the servers. How did we get here, and what should JavaScript do now? https://2019.jsconf.eu/c-j-silverio/the-economics-of-open-source.html

Javascript has always been a language with very little syntactic sugar—for better or worse. With ES6/2015, and future iterations,though, Javascript is gaining a more and more abstract and expressive syntax. To some it might appear that our language—which already seems accessible and approachable for beginners— is becoming even more accessible and approachable. However, both the humanities and CS education research have proven that abstraction, while a powerful tool for knowledgeable practitioners, can be an equally powerful foil for beginners. As we enter the era of language-level abstractions in ES6/2015, we are charged with the task of rethinking how we teach JavaScript. Through an interdisciplinary montage I will identify the problem of teaching abstraction as a ubiquitous demand across nearly every domain, and align the issues of creativity and critical thinking in the humanities with issues in computer science. The talk will conclude with a discussion of how the discipline of computer science and that of the humanities can inform each other to produce more effective and creative solutions to both developing and teaching abstractions.

http://2017.jsconf.eu/speakers/lin-clark-a-cartoon-intro-to-webassembly.html WebAssembly is fast. It’s being called “the future of the web”. It’s speed and potential have major browser vendors working together to make it a reality. And it’s on it’s way—the MVP hit multiple browsers in October of last year. But what makes it fast? Starting from the basics, this talk will walk you through what WebAssembly is, and then why it’s fast.

This talk will explore the conceptual underpinnings of asynchronous programming options, and the drawbacks and advantages to each. JS has supported callbacks since 2009, and as years have gone by it’s added support for promises, generators, and now async/await. On a surface level, each of these techniques seeks to answer a question of how to access data not immediately available, but a deeper look into how each works on a granular level will show their implementation differences and how these differences affect usage. We’ll also take a look at how intermediate values, and errors are affected by each method. I’ll walk through a series of scenarios so you can better visualize performance differences, and how each method propagates data through the stack and the event loop. Finally, I’ll talk about where the future of async may be headed. Armed with new knowledge from this deep dive, the potentially treacherous road to fully understanding async will hopefully become a smoother ride! OMG JSConf EU is coming back in 2019 https://2019.jsconf.eu/