Talk about ECMAScript 6 at YAPC::Asia Tokyo 2015
http://yapcasia.org/2015/talk/show/44721562-10e4-11e5-88a0-d7f07d574c3a
https://www.youtube.com/watch?v=oSPv5IPDSxE
Getting started with ES6 : Future of javascriptMohd Saeed
Motivation: Why should we use ES6?
ES6 Features
What to be covered next?
How to use ES6 Features today?
Transpilers ( source-to-source Compiler)
Famous Build Tools
Web developers constantly look for the latest and greatest ways to hone their craft, but changes come fast. From jQuery to Angular to Ember to React, CoffeeScript to TypeScript, it seems there is always something new. But ES6 is something different. With ES6 we are seeing the evolution of core JavaScript. It includes syntactic improvements and great new features never before seen in client-side code. Linters and transpilers for ES6 are readily available and easy to use. There is no need to wait; learn how to leverage the power of "the new JavaScript" in your applications, today!
Everybody is talking about ES6, but is anyone out there using it in production? Mango recently started adopting ES6 features that make our front-end code easier to write and maintain.
In this talk, I will explain why we decided to use ES6, how we started to use it in production (using npm, browserify and babel) and I'll explain what problems we found along the way and how we solved them.
Links:
https://getmango.com
https://getmango.com/blog/writing-es6-modules-with-6to5/
http://kangax.github.io/compat-table/
https://github.com/zloirock/core-js
https://github.com/mango/emitter
http://wiki.ecmascript.org/doku.php?id=harmony:specification_drafts
http://benmccormick.org/2015/04/07/es6-classes-and-backbone-js/
ECMAScript 6: A Better JavaScript for the Ambient Computing EraAllen Wirfs-Brock
We've entered the Ambient Computing Era and JavaScript is its dominant programing language, But a new computing era needs a new and better JavaScript. It's called ECMAScript 6 and it's about to become the new JavaScript standard. Why do we need it? Why did it take so long? What's in it? When can you use it? Answers will be given.
Rami Sayar presented on ECMAScript 6 (ES6) features including block scoping with let and const, destructuring, modules and classes, and iterators and generators. ES6 is targeted for ratification in mid-2015 and brings significant updates to JavaScript. Browser and Node.js support is emerging for ES6 features through experimental flags or transpilation to ES5.
The next version of JavaScript, ES6, is starting to arrive. Many of its features are simple enhancements to the language we already have: things like arrow functions, class syntax, and destructuring. But other features will change the way we program JavaScript, fundamentally expanding the capabilities of the language and reshaping our future codebases. In this talk we'll focus on two of these, discovering the the myriad possibilities of generators and the many tricks you can pull of with template strings.
This document discusses new features in ECMAScript (ES) 6 including: enhanced object literals with shorthand property and method definitions; destructuring assignment for arrays and objects; template strings for string interpolation; iterators, generators, and for-of loops; modules with named and default exports; and the module loader API. It provides code examples to demonstrate these new features and compares them to CommonJS and ES5 syntax.
Getting started with ES6 : Future of javascriptMohd Saeed
Motivation: Why should we use ES6?
ES6 Features
What to be covered next?
How to use ES6 Features today?
Transpilers ( source-to-source Compiler)
Famous Build Tools
Web developers constantly look for the latest and greatest ways to hone their craft, but changes come fast. From jQuery to Angular to Ember to React, CoffeeScript to TypeScript, it seems there is always something new. But ES6 is something different. With ES6 we are seeing the evolution of core JavaScript. It includes syntactic improvements and great new features never before seen in client-side code. Linters and transpilers for ES6 are readily available and easy to use. There is no need to wait; learn how to leverage the power of "the new JavaScript" in your applications, today!
Everybody is talking about ES6, but is anyone out there using it in production? Mango recently started adopting ES6 features that make our front-end code easier to write and maintain.
In this talk, I will explain why we decided to use ES6, how we started to use it in production (using npm, browserify and babel) and I'll explain what problems we found along the way and how we solved them.
Links:
https://getmango.com
https://getmango.com/blog/writing-es6-modules-with-6to5/
http://kangax.github.io/compat-table/
https://github.com/zloirock/core-js
https://github.com/mango/emitter
http://wiki.ecmascript.org/doku.php?id=harmony:specification_drafts
http://benmccormick.org/2015/04/07/es6-classes-and-backbone-js/
ECMAScript 6: A Better JavaScript for the Ambient Computing EraAllen Wirfs-Brock
We've entered the Ambient Computing Era and JavaScript is its dominant programing language, But a new computing era needs a new and better JavaScript. It's called ECMAScript 6 and it's about to become the new JavaScript standard. Why do we need it? Why did it take so long? What's in it? When can you use it? Answers will be given.
Rami Sayar presented on ECMAScript 6 (ES6) features including block scoping with let and const, destructuring, modules and classes, and iterators and generators. ES6 is targeted for ratification in mid-2015 and brings significant updates to JavaScript. Browser and Node.js support is emerging for ES6 features through experimental flags or transpilation to ES5.
The next version of JavaScript, ES6, is starting to arrive. Many of its features are simple enhancements to the language we already have: things like arrow functions, class syntax, and destructuring. But other features will change the way we program JavaScript, fundamentally expanding the capabilities of the language and reshaping our future codebases. In this talk we'll focus on two of these, discovering the the myriad possibilities of generators and the many tricks you can pull of with template strings.
This document discusses new features in ECMAScript (ES) 6 including: enhanced object literals with shorthand property and method definitions; destructuring assignment for arrays and objects; template strings for string interpolation; iterators, generators, and for-of loops; modules with named and default exports; and the module loader API. It provides code examples to demonstrate these new features and compares them to CommonJS and ES5 syntax.
This document provides an overview of JavaScript including its history, key features, and comparisons to other languages. It also discusses important JavaScript concepts like objects, functions, events, and libraries like jQuery. Key topics covered include the window, document, location, and history objects, arrays, cookies, closures, inheritance, callbacks, and popular JavaScript libraries and frameworks.
ECMAScript is the name of the international standard that defines JavaScript. ES6 → ECMAScript 2015. Latest ECMAScript version is ES7 which is ECMAScript 2016.
Basically it is a superset of es5
The document discusses new features introduced in ECMAScript (ES) 6 and beyond, including block scoping, default parameter values, rest parameters, template strings, modules, classes, symbols, iterators, generators, array and object destructuring, spread syntax, and more. ES6 was finalized in 2015 and introduced many new syntax and API additions to JavaScript. Future versions of ES, such as ES7 and ES8, have continued to evolve the language with additional features like async functions. Tools like Babel and TypeScript allow using these new JavaScript features today by compiling code to older JavaScript versions.
This document introduces ES2015 (ECMAScript 2015), which updated the JavaScript language with new syntaxes and libraries. It summarizes some of the key additions, including classes, template literals, object literal extensions, Maps, destructuring, and more. These features are now supported by modern browsers. The document provides examples of code using the old syntax versus the new syntax for classes, template literals, Maps, and destructuring to illustrate the changes. It also lists some references for further exploring ES2015.
How DRY impacts JavaScript performance // Faster JavaScript execution for the...Mathias Bynens
This document discusses techniques for improving JavaScript performance by following the DRY (Don't Repeat Yourself) principle. It identifies DOM manipulation, function calls, and property lookups as particularly slow operations in JavaScript. The document provides examples of inefficient code and more optimized alternatives that avoid repetition through caching elements, using document fragments for DOM changes, and minimizing scope lookups. Overall, the document advocates structuring code in a DRY way to improve performance, especially within loops, intervals, and event handlers.
The document discusses the beauty of JavaScript and its many features. It covers how JavaScript offers classless object-oriented programming and functional programming. It also discusses how JavaScript can run on both the client-side and server-side. The document provides examples of JavaScript syntax like variables, functions, objects, inheritance through prototypes, and AJAX requests. It emphasizes how libraries help create abstractions and beautiful patterns in JavaScript code.
The document discusses the beauty of JavaScript and its many features. It covers how JavaScript offers classless object-oriented programming and functional programming. It also discusses how JavaScript can run on both the client-side and server-side. The document provides examples of JavaScript syntax like variables, functions, objects, prototypes and more to demonstrate JavaScript's capabilities. It emphasizes that libraries help create abstractions and beautiful patterns in JavaScript code.
This document provides an overview of Node.js for PHP developers, comparing and contrasting features between the two languages/platforms. It covers key differences in variables, data types, operators, functions, classes/objects, modules and other concepts. The document aims to help PHP developers transition to Node.js by highlighting both similarities and differences at a conceptual level.
This document discusses object-relational mappers (ORMs) and several ORM libraries for Go. ORMs allow converting data between object-oriented programming languages and relational databases. While initially hailed, ORMs were later criticized for some assumptions that cost dearly. The document then outlines Go's philosophy regarding ORMs and duality between classes and types. Several popular Go ORM libraries are described, including Gorm, Gorp, and Sqlx, outlining their key features and support for operations like CRUD, relationships, and migrations. The document cautions to avoid opaque struct tags that can introduce semantic errors and to do application logic outside ORM objects.
Have you ever thought, “I wish it was easier to change JavaScript code programmatically?” Maybe you wanted to write or edit a configuration block in source code. Perhaps you wanted to generate customized algorithmic code. For many, this kind of thing seems inaccessible.
The tools exist, though. In this talk, Stephen Vance will look at how he has used recast and esprima to edit and rewrite JavaScript code, leaving the untouched code completely intact, including whitespace and comments. At the end, you should have enough knowledge to be dangerous and start to write the next automatic programming, AI, take-over-the-world, self-improving software.
CoffeeScript is a little language that compiles to JavaScript. It repairs confusing aspects of JavaScript while keeping its flexibility. The document discusses CoffeeScript types like numbers, strings, booleans, objects and functions. It also covers CoffeeScript concepts like variables, operators, expressions, statements, control flow, arrays, objects, loops, classes, inheritance and functions. CoffeeScript aims to expose the good parts of JavaScript in a simpler way.
JRuby, Ruby, Rails and You on the Cloud is a presentation about using Ruby on Rails with JRuby on cloud platforms. It introduces JRuby and how to set up a development environment. It demonstrates generating a Rails scaffold and accessing Java libraries from Rails. Deployment options on platforms like Engine Yard AppCloud are discussed. The presentation provides an overview of testing and recommends resources for learning more about Ruby, Rails, JRuby and deployment strategies.
The document discusses using JRuby to integrate Ruby and Rails into an existing Java/Spring application. It describes using JRuby, Warbler, Rack, and Rails to refactor the application in stages from small changes like adding tests and routing, to medium changes like layering on Rails, to a large refactor of the directory structure and bootstrapping Rails within the Spring context.
This document provides an introduction to Node.js, Express, and MongoDB. Node.js is a JavaScript runtime built on Chrome's V8 engine that allows JavaScript to be run on the server-side. Express is a web application framework for Node.js that provides routing capabilities and middleware support. MongoDB is a non-relational database that stores data in flexible, JSON-like documents, rather than using rigid tables. The document discusses the pros and cons of each technology and provides examples of basic usage and configuration.
Interceptors: Into the Core of PedestalKent Ohashi
Pedestal is a Clojure library for building server-side web applications. It uses interceptors, which are similar to middleware, to modify the request-response context as it passes through the system. The document shows how to create a basic Pedestal project, define routes and handlers, and use interceptors like body-params to extract parameters from requests. Further reading sections provide links to learn more about Pedestal, interceptors, related concepts, and alternative routing libraries.
Talk was given at WebConf Riga 2012. There was some trolling about Symfony 2 and ZF2 just for fun. I actually think these are great projects so sorry if it hury your feelings.
Domains were added to Node.js in 0.8, but their use and workings have been a relative mystery. In short, domains are a structured way of reacting to uncaught exceptions; for example, when creating an HTTP server, you can use domains to send 500 errors when exceptions occur instead of crashing your server. This talk will go over what domains are, how to use them, and some of the subtleties behind how they work.
My Adventures In Objective-C (A Rubyists Perspective)abdels
This document discusses the author's experience with Objective-C and provides an overview of some key concepts in the language. It acknowledges initial frustrations with Objective-C but encourages persistence. The document then covers topics like object-oriented programming concepts in Objective-C, properties, categories, blocks, and interfaces with protocols. It compares Objective-C to other languages like Ruby and provides references for further reading. The overall message is that iOS development using Objective-C, while challenging, is worth learning for access to the powerful iOS platform.
The document provides a history of the ECMAScript specification from 1995 to 2015. It outlines the major releases and additions to the language over time including ES3.1, ES5, ES6, and the ongoing development of future versions. Key changes include the introduction of classes, modules, arrow functions, promises, generators, and more robust collection types like Sets and Maps. The specification is developed by the TC39 committee group within Ecma International.
This document provides an overview of JavaScript including its history, key features, and comparisons to other languages. It also discusses important JavaScript concepts like objects, functions, events, and libraries like jQuery. Key topics covered include the window, document, location, and history objects, arrays, cookies, closures, inheritance, callbacks, and popular JavaScript libraries and frameworks.
ECMAScript is the name of the international standard that defines JavaScript. ES6 → ECMAScript 2015. Latest ECMAScript version is ES7 which is ECMAScript 2016.
Basically it is a superset of es5
The document discusses new features introduced in ECMAScript (ES) 6 and beyond, including block scoping, default parameter values, rest parameters, template strings, modules, classes, symbols, iterators, generators, array and object destructuring, spread syntax, and more. ES6 was finalized in 2015 and introduced many new syntax and API additions to JavaScript. Future versions of ES, such as ES7 and ES8, have continued to evolve the language with additional features like async functions. Tools like Babel and TypeScript allow using these new JavaScript features today by compiling code to older JavaScript versions.
This document introduces ES2015 (ECMAScript 2015), which updated the JavaScript language with new syntaxes and libraries. It summarizes some of the key additions, including classes, template literals, object literal extensions, Maps, destructuring, and more. These features are now supported by modern browsers. The document provides examples of code using the old syntax versus the new syntax for classes, template literals, Maps, and destructuring to illustrate the changes. It also lists some references for further exploring ES2015.
How DRY impacts JavaScript performance // Faster JavaScript execution for the...Mathias Bynens
This document discusses techniques for improving JavaScript performance by following the DRY (Don't Repeat Yourself) principle. It identifies DOM manipulation, function calls, and property lookups as particularly slow operations in JavaScript. The document provides examples of inefficient code and more optimized alternatives that avoid repetition through caching elements, using document fragments for DOM changes, and minimizing scope lookups. Overall, the document advocates structuring code in a DRY way to improve performance, especially within loops, intervals, and event handlers.
The document discusses the beauty of JavaScript and its many features. It covers how JavaScript offers classless object-oriented programming and functional programming. It also discusses how JavaScript can run on both the client-side and server-side. The document provides examples of JavaScript syntax like variables, functions, objects, inheritance through prototypes, and AJAX requests. It emphasizes how libraries help create abstractions and beautiful patterns in JavaScript code.
The document discusses the beauty of JavaScript and its many features. It covers how JavaScript offers classless object-oriented programming and functional programming. It also discusses how JavaScript can run on both the client-side and server-side. The document provides examples of JavaScript syntax like variables, functions, objects, prototypes and more to demonstrate JavaScript's capabilities. It emphasizes that libraries help create abstractions and beautiful patterns in JavaScript code.
This document provides an overview of Node.js for PHP developers, comparing and contrasting features between the two languages/platforms. It covers key differences in variables, data types, operators, functions, classes/objects, modules and other concepts. The document aims to help PHP developers transition to Node.js by highlighting both similarities and differences at a conceptual level.
This document discusses object-relational mappers (ORMs) and several ORM libraries for Go. ORMs allow converting data between object-oriented programming languages and relational databases. While initially hailed, ORMs were later criticized for some assumptions that cost dearly. The document then outlines Go's philosophy regarding ORMs and duality between classes and types. Several popular Go ORM libraries are described, including Gorm, Gorp, and Sqlx, outlining their key features and support for operations like CRUD, relationships, and migrations. The document cautions to avoid opaque struct tags that can introduce semantic errors and to do application logic outside ORM objects.
Have you ever thought, “I wish it was easier to change JavaScript code programmatically?” Maybe you wanted to write or edit a configuration block in source code. Perhaps you wanted to generate customized algorithmic code. For many, this kind of thing seems inaccessible.
The tools exist, though. In this talk, Stephen Vance will look at how he has used recast and esprima to edit and rewrite JavaScript code, leaving the untouched code completely intact, including whitespace and comments. At the end, you should have enough knowledge to be dangerous and start to write the next automatic programming, AI, take-over-the-world, self-improving software.
CoffeeScript is a little language that compiles to JavaScript. It repairs confusing aspects of JavaScript while keeping its flexibility. The document discusses CoffeeScript types like numbers, strings, booleans, objects and functions. It also covers CoffeeScript concepts like variables, operators, expressions, statements, control flow, arrays, objects, loops, classes, inheritance and functions. CoffeeScript aims to expose the good parts of JavaScript in a simpler way.
JRuby, Ruby, Rails and You on the Cloud is a presentation about using Ruby on Rails with JRuby on cloud platforms. It introduces JRuby and how to set up a development environment. It demonstrates generating a Rails scaffold and accessing Java libraries from Rails. Deployment options on platforms like Engine Yard AppCloud are discussed. The presentation provides an overview of testing and recommends resources for learning more about Ruby, Rails, JRuby and deployment strategies.
The document discusses using JRuby to integrate Ruby and Rails into an existing Java/Spring application. It describes using JRuby, Warbler, Rack, and Rails to refactor the application in stages from small changes like adding tests and routing, to medium changes like layering on Rails, to a large refactor of the directory structure and bootstrapping Rails within the Spring context.
This document provides an introduction to Node.js, Express, and MongoDB. Node.js is a JavaScript runtime built on Chrome's V8 engine that allows JavaScript to be run on the server-side. Express is a web application framework for Node.js that provides routing capabilities and middleware support. MongoDB is a non-relational database that stores data in flexible, JSON-like documents, rather than using rigid tables. The document discusses the pros and cons of each technology and provides examples of basic usage and configuration.
Interceptors: Into the Core of PedestalKent Ohashi
Pedestal is a Clojure library for building server-side web applications. It uses interceptors, which are similar to middleware, to modify the request-response context as it passes through the system. The document shows how to create a basic Pedestal project, define routes and handlers, and use interceptors like body-params to extract parameters from requests. Further reading sections provide links to learn more about Pedestal, interceptors, related concepts, and alternative routing libraries.
Talk was given at WebConf Riga 2012. There was some trolling about Symfony 2 and ZF2 just for fun. I actually think these are great projects so sorry if it hury your feelings.
Domains were added to Node.js in 0.8, but their use and workings have been a relative mystery. In short, domains are a structured way of reacting to uncaught exceptions; for example, when creating an HTTP server, you can use domains to send 500 errors when exceptions occur instead of crashing your server. This talk will go over what domains are, how to use them, and some of the subtleties behind how they work.
My Adventures In Objective-C (A Rubyists Perspective)abdels
This document discusses the author's experience with Objective-C and provides an overview of some key concepts in the language. It acknowledges initial frustrations with Objective-C but encourages persistence. The document then covers topics like object-oriented programming concepts in Objective-C, properties, categories, blocks, and interfaces with protocols. It compares Objective-C to other languages like Ruby and provides references for further reading. The overall message is that iOS development using Objective-C, while challenging, is worth learning for access to the powerful iOS platform.
The document provides a history of the ECMAScript specification from 1995 to 2015. It outlines the major releases and additions to the language over time including ES3.1, ES5, ES6, and the ongoing development of future versions. Key changes include the introduction of classes, modules, arrow functions, promises, generators, and more robust collection types like Sets and Maps. The specification is developed by the TC39 committee group within Ecma International.
This document discusses ES6, the new version of JavaScript, and provides an overview of some of its key features including classes, iterators, lambdas, string interpolation, modules, and let block scoping. It encourages readers to begin using ES6 today by leveraging transpilation tools like Babel that allow ES6 code to run on current browsers and platforms. The best resource mentioned for learning ES6 is the Babel website, which contains tutorials, a live code editor, and helps developers get started with ES6.
You believe in the power of JavaScript modules, but you have an existing app, stack or platform infrastructure to keep running. Between maintenance and new features, where do you carve out time to switch over? After a brief overview of modules and why they're great, we'll dig into how to actually migrate a code base, from plotting your approach to implementation tips.
Video: http://youtu.be/FbdcdC8mqwE?t=50m51s (watch the entire video from the beginning for other great talks about shadow DOM and competing task runners)
Talk from February 19, 2014 NYCHTML5 Meetup: http://www.meetup.com/nychtml5/events/160684962/
This document provides a history of JavaScript and ECMAScript specifications from 1995 to the present. It discusses the standardization process and key people and organizations involved like B. Eich, TC39, and ECMA. Major versions and proposed features are summarized, including ES6/ES2015 additions like arrow functions, block scoping with let/const, classes, modules, iterators/generators, and proxies.
The document discusses common mistakes made when working with JavaScript. It provides examples of incorrect uses of objects, functions, constructors, closures, and prototypes. It also discusses problems with global variables, parsing integers, and not returning "this" from non-getter methods. The document recommends better practices for these JavaScript concepts and features.
Here are the slides that I gave for The Arizona Software Community meetup.
http://www.meetup.com/azsoftcom/events/222936544/
This was a gentle introduction to some of the features in EcmaScript 2015 and how and why you may use them.
This document provides an overview of an ES6 hackathon focusing on new features in ES6 including block scope, modules, destructuring, arrow functions, classes, template literals, internationalization, spread syntax, generators, sets, promises and more. Attendees will have 30 minutes to work on code challenges exploring these new ES6 features using resources like JSFiddle and TypeScript. The challenges involve updating functions to use new syntax like arrow functions, default parameters and object shorthand, satisfying class assertions, and improving outputs using template strings and internationalization.
This Presentation depicts JavaScript concept for Csharp developer.It helps to understand the concepts of JavaScript resembling/differentiate them with C# concepts.
This document discusses new features coming to JavaScript in ECMAScript 6, including:
1) Block scope keywords "let" and "const" that allow for block-level scoping of variables.
2) Shorthand syntax for object literals and method definitions.
3) Destructuring assignments for extracting values from objects and arrays.
4) Default parameter values, rest parameters, and spread syntax for working with functions and arrays.
5) New features like modules, classes, and imports for better organizing code.
"JavaScript in 2016" by Eduard Tomàs
Some years ago in a far far away company, Brendan Eich created JavaScript. A lot of things happened since then. Times changed, the web grown, the language itself was updated, and we as a developers need to adapt too. Last year the last standard of the language arose: ECMAScript 2015 is here, and has some new and interesting features. In this talk we will show the most relevant ones, and also we will introduce some interesting patterns that you can use in JavaScript: you'll learn how to master the language and made JavaScript your best ally to conquest the world!
This document provides an overview of ES6 features and how to set them up for use in Ruby on Rails applications. It describes key ES6 features such as let and const block scoping, template strings, destructuring assignment, default and rest parameters, loops and generators, enhanced object literals, Maps and Sets, arrow functions, modules, and classes. It then provides instructions for using the sprockets-es6 gem to transpile ES6 code to ES5 for use in Rails, as well as using Node.js and Gulp as an alternative approach.
SEMAC 2011 - Apresentando Ruby e Ruby on RailsFabio Akita
The document presents an introduction to Ruby and Ruby on Rails. It discusses the history and evolution of Ruby from 1990 to the present and Ruby on Rails from 2004 onwards. It also covers Ruby and Rails core concepts like object orientation, modules, classes and more. Code examples are provided to demonstrate features like methods, blocks and XML generation.
Scala is a programming language that mixes object oriented and functional programming in a powerful and flexible way. While it can not be considered as a mainstream language, it has seen a growing adoption trend.An important ingredient for this diffusion is its complete interoperability with Java and the fact that it runs on a solid platform such as the JVM.
It is currently the 4th most loved programming language and the 2nd top paying technology of 2016 (StackOverflow Developers Survey).
These slides have been used for a 4h seminar at the University of Cagliari the 17th of December 2016
Your Library Sucks, and why you should use it.Peter Higgins
This document discusses JavaScript libraries and proposes ideas for improving them. It argues that while libraries are useful, developers should understand JavaScript fundamentals first. Current libraries have inconsistent APIs and lack modularity. The document proposes a new "CommonBrowserJS" library with common standards, pure feature detection, and support for CommonJS modules to converge the best ideas from existing libraries. Developing a simple "has.js" library for feature detection could be a first step. Overall the document advocates for improving JavaScript libraries by standardizing APIs and reducing magic while embracing modern JavaScript practices.
An introductory presentation I'm doing at my workplace for other developers. This is geared toward programmers that are very new to javascript and covers some basics, but focuses on Functions, Objects and prototypal inheritance ideas.
This document provides an overview of ECMAScript 6 (ES6), also known as ECMAScript 2015. It discusses the history and standardization of JavaScript and ECMAScript. It then covers many of the new features introduced in ES6, including let and const block scoping, arrow functions, template literals, classes, generators, iterators, promises, and modules. It encourages using ES6 features today via tools like Traceur and Babel that compile ES6 to ES5 for browser compatibility. It also looks ahead to future features planned for ECMAScript 7 and beyond.
This document summarizes the key new features being introduced in ECMAScript 6 (ES6), also known as Harmony. Some of the major additions include block scope with let and const, classes and modules, iterators and generators, arrow functions, and parameter handling improvements with rest/spread. ES6 is designed to be backwards compatible with ES5 while adding new functionality. Many new features are already being implemented in modern browsers and Node.js using flags or alternative syntax like --harmony for testing purposes today.
This document discusses recent compatibility table issues raised by @teppeis. It provides a link to a GitHub page containing an ES6 compatibility table and outlines updates made including new specs, ES modules, test262 integration, and UI improvements. It encourages contributions to further improve the table.
This document discusses Yarn and its advantages over npm. It notes that Yarn uses yarn.lock files instead of npm-shrinkwrap.json files to lock down dependency versions. Yarn is also described as being faster, able to work offline by caching dependencies, and potentially more secure than npm with features like flat mode and module folders. The document suggests Yarn may handle dependencies and devDependencies differently than npm, and questions whether the yarn.lock file should be committed to source control.
This document summarizes a Cybozu Meetup event focused on frontend technologies. It discusses Cybozu's transition from traditional server-rendered web applications to single-page applications built with React. It also covers Cybozu's use of Closure Compiler, TypeScript, JSDoc, and other tools for JavaScript development. Best practices are shared around testing, linting, and integrating third-party code. Accessibility standards and strategies for securely embedding third-party code are also mentioned.
This document summarizes a presentation about single-page applications (SPAs). It discusses what SPAs are, some user experience challenges with SPAs like navigation and accessibility, and solutions to those challenges including server-side rendering and preloading resources. Links are provided to additional resources on topics like accessibility in SPAs and using service workers and prefetching to improve performance. The document concludes by thanking attendees of the presentation.
This document discusses the evolution of JavaScript and the ECMAScript standard over time. It covers new features introduced in ES2015 (ES6) like arrow functions, classes, modules, and new built-in objects. It also mentions upcoming features in ES2017 like async functions and describes the process for proposing and standardizing new JavaScript features.
This document summarizes a talk given about Flowtype, a static type checker for JavaScript. The talk discussed how Flowtype allows for strong type inference in React.js projects, checks propTypes statically, and is fast. While Flowtype is not a language itself and just a type checker, its type annotations use a colon instead of TypeScript's angle brackets. The speaker was eager for Flowtype's continued development, as its documentation and support for contributing were still incomplete.
This presentation provides valuable insights into effective cost-saving techniques on AWS. Learn how to optimize your AWS resources by rightsizing, increasing elasticity, picking the right storage class, and choosing the best pricing model. Additionally, discover essential governance mechanisms to ensure continuous cost efficiency. Whether you are new to AWS or an experienced user, this presentation provides clear and practical tips to help you reduce your cloud costs and get the most out of your budget.
Generating privacy-protected synthetic data using Secludy and MilvusZilliz
During this demo, the founders of Secludy will demonstrate how their system utilizes Milvus to store and manipulate embeddings for generating privacy-protected synthetic data. Their approach not only maintains the confidentiality of the original data but also enhances the utility and scalability of LLMs under privacy constraints. Attendees, including machine learning engineers, data scientists, and data managers, will witness first-hand how Secludy's integration with Milvus empowers organizations to harness the power of LLMs securely and efficiently.
Digital Marketing Trends in 2024 | Guide for Staying AheadWask
https://www.wask.co/ebooks/digital-marketing-trends-in-2024
Feeling lost in the digital marketing whirlwind of 2024? Technology is changing, consumer habits are evolving, and staying ahead of the curve feels like a never-ending pursuit. This e-book is your compass. Dive into actionable insights to handle the complexities of modern marketing. From hyper-personalization to the power of user-generated content, learn how to build long-term relationships with your audience and unlock the secrets to success in the ever-shifting digital landscape.
Salesforce Integration for Bonterra Impact Management (fka Social Solutions A...Jeffrey Haguewood
Sidekick Solutions uses Bonterra Impact Management (fka Social Solutions Apricot) and automation solutions to integrate data for business workflows.
We believe integration and automation are essential to user experience and the promise of efficient work through technology. Automation is the critical ingredient to realizing that full vision. We develop integration products and services for Bonterra Case Management software to support the deployment of automations for a variety of use cases.
This video focuses on integration of Salesforce with Bonterra Impact Management.
Interested in deploying an integration with Salesforce for Bonterra Impact Management? Contact us at sales@sidekicksolutionsllc.com to discuss next steps.
HCL Notes and Domino License Cost Reduction in the World of DLAUpanagenda
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-and-domino-license-cost-reduction-in-the-world-of-dlau/
The introduction of DLAU and the CCB & CCX licensing model caused quite a stir in the HCL community. As a Notes and Domino customer, you may have faced challenges with unexpected user counts and license costs. You probably have questions on how this new licensing approach works and how to benefit from it. Most importantly, you likely have budget constraints and want to save money where possible. Don’t worry, we can help with all of this!
We’ll show you how to fix common misconfigurations that cause higher-than-expected user counts, and how to identify accounts which you can deactivate to save money. There are also frequent patterns that can cause unnecessary cost, like using a person document instead of a mail-in for shared mailboxes. We’ll provide examples and solutions for those as well. And naturally we’ll explain the new licensing model.
Join HCL Ambassador Marc Thomas in this webinar with a special guest appearance from Franz Walder. It will give you the tools and know-how to stay on top of what is going on with Domino licensing. You will be able lower your cost through an optimized configuration and keep it low going forward.
These topics will be covered
- Reducing license cost by finding and fixing misconfigurations and superfluous accounts
- How do CCB and CCX licenses really work?
- Understanding the DLAU tool and how to best utilize it
- Tips for common problem areas, like team mailboxes, functional/test users, etc
- Practical examples and best practices to implement right away
Building Production Ready Search Pipelines with Spark and MilvusZilliz
Spark is the widely used ETL tool for processing, indexing and ingesting data to serving stack for search. Milvus is the production-ready open-source vector database. In this talk we will show how to use Spark to process unstructured data to extract vector representations, and push the vectors to Milvus vector database for search serving.
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2024/06/temporal-event-neural-networks-a-more-efficient-alternative-to-the-transformer-a-presentation-from-brainchip/
Chris Jones, Director of Product Management at BrainChip , presents the “Temporal Event Neural Networks: A More Efficient Alternative to the Transformer” tutorial at the May 2024 Embedded Vision Summit.
The expansion of AI services necessitates enhanced computational capabilities on edge devices. Temporal Event Neural Networks (TENNs), developed by BrainChip, represent a novel and highly efficient state-space network. TENNs demonstrate exceptional proficiency in handling multi-dimensional streaming data, facilitating advancements in object detection, action recognition, speech enhancement and language model/sequence generation. Through the utilization of polynomial-based continuous convolutions, TENNs streamline models, expedite training processes and significantly diminish memory requirements, achieving notable reductions of up to 50x in parameters and 5,000x in energy consumption compared to prevailing methodologies like transformers.
Integration with BrainChip’s Akida neuromorphic hardware IP further enhances TENNs’ capabilities, enabling the realization of highly capable, portable and passively cooled edge devices. This presentation delves into the technical innovations underlying TENNs, presents real-world benchmarks, and elucidates how this cutting-edge approach is positioned to revolutionize edge AI across diverse applications.
Have you ever been confused by the myriad of choices offered by AWS for hosting a website or an API?
Lambda, Elastic Beanstalk, Lightsail, Amplify, S3 (and more!) can each host websites + APIs. But which one should we choose?
Which one is cheapest? Which one is fastest? Which one will scale to meet our needs?
Join me in this session as we dive into each AWS hosting service to determine which one is best for your scenario and explain why!
Fueling AI with Great Data with Airbyte WebinarZilliz
This talk will focus on how to collect data from a variety of sources, leveraging this data for RAG and other GenAI use cases, and finally charting your course to productionalization.
Programming Foundation Models with DSPy - Meetup SlidesZilliz
Prompting language models is hard, while programming language models is easy. In this talk, I will discuss the state-of-the-art framework DSPy for programming foundation models with its powerful optimizers and runtime constraint system.
Dandelion Hashtable: beyond billion requests per second on a commodity serverAntonios Katsarakis
This slide deck presents DLHT, a concurrent in-memory hashtable. Despite efforts to optimize hashtables, that go as far as sacrificing core functionality, state-of-the-art designs still incur multiple memory accesses per request and block request processing in three cases. First, most hashtables block while waiting for data to be retrieved from memory. Second, open-addressing designs, which represent the current state-of-the-art, either cannot free index slots on deletes or must block all requests to do so. Third, index resizes block every request until all objects are copied to the new index. Defying folklore wisdom, DLHT forgoes open-addressing and adopts a fully-featured and memory-aware closed-addressing design based on bounded cache-line-chaining. This design offers lock-free index operations and deletes that free slots instantly, (2) completes most requests with a single memory access, (3) utilizes software prefetching to hide memory latencies, and (4) employs a novel non-blocking and parallel resizing. In a commodity server and a memory-resident workload, DLHT surpasses 1.6B requests per second and provides 3.5x (12x) the throughput of the state-of-the-art closed-addressing (open-addressing) resizable hashtable on Gets (Deletes).
Your One-Stop Shop for Python Success: Top 10 US Python Development Providersakankshawande
Simplify your search for a reliable Python development partner! This list presents the top 10 trusted US providers offering comprehensive Python development services, ensuring your project's success from conception to completion.
TrustArc Webinar - 2024 Global Privacy SurveyTrustArc
How does your privacy program stack up against your peers? What challenges are privacy teams tackling and prioritizing in 2024?
In the fifth annual Global Privacy Benchmarks Survey, we asked over 1,800 global privacy professionals and business executives to share their perspectives on the current state of privacy inside and outside of their organizations. This year’s report focused on emerging areas of importance for privacy and compliance professionals, including considerations and implications of Artificial Intelligence (AI) technologies, building brand trust, and different approaches for achieving higher privacy competence scores.
See how organizational priorities and strategic approaches to data security and privacy are evolving around the globe.
This webinar will review:
- The top 10 privacy insights from the fifth annual Global Privacy Benchmarks Survey
- The top challenges for privacy leaders, practitioners, and organizations in 2024
- Key themes to consider in developing and maintaining your privacy program
9. –Brendan Eich
from Effective JavaScript
“My solution to the challenging
requirements and crazy-short schedule
was to make JavaScript extremely
malleable from the start.”
https://www.flickr.com/photos/jsconf/4587502948/
11. JavaScript has many pitfalls…
• Prototype inheritance (No class)
• new, this
• Function scope (No block scope)
• Global variables (No module system)
• Hoisting
• NaN, undefined
• typeof null
• with, eval
12. Example: No Class
function Person(name) {
this.name = name;
}
Person.prototype.greet = function() {
console.log("Hello, I'm " + this.name);
};
var bob = new Person("Bob");
bob.greet();
// "Hello, I'm Bob"
• Use Prototype to emulate Classes
13. If you miss "new", dangerous!
function Person(name) {
this.name = name;
}
// Oh! You forget `new`
var bob = Person("Bob");
console.log(bob); // undefined
// Global leak!!!!!!!!!!
console.log(window.name); // "Bob"
19. Practice: Be sure to call with "new"
function Person(name) {
// check!
if (this instanceof Person) {
return new Person(name);
}
this.name = name;
}
// without `new`
var bob = Person("Bob");
bob.greet();
// "Hello, I'm Bob"
24. ES6 Classes: Simple!
class Person {
constructor(name) {
this.name = name;
}
greet() {
console.log("Hello, I'm " + this.name);
}
}
var bob = new Person("Bob");
bob.greet();
// without `new`
var bob = Person("Bob"); // Error!
25. Classes based on Prototype
function Person(name) {
this.name = name;
}
Person.prototype.greet = function() {
console.log("Hello, I'm " + this.name);
};
var bob = new Person("Bob");
bob.greet();
// "Hello, I'm Bob"
OUT OF DATE!
26. Be sure to call with `new`
function Person(name) {
// check!
if (this instanceof Person) {
return new Person(name);
}
this.name = name;
}
// without `new`
var bob = Person("Bob");
bob.greet();
// "Hello, I'm Bob"
OUT OF DATE!
27. New ES6 features deprecates
yesterday’s best-practices
No more altJS!
https://www.flickr.com/photos/jorge-11/2765216505/
30. You can use ES6 now!
• Modern browsers and io.js (node.js) support
half of ES6 features.
• Safari 9 (WebKit) will support many ES6 features soon.
• Except for IE11…
31. Transpiler and polyfill
• ES6 Transpiler:
source code converter from ES6 to ES5/ES3
• ES6 Polyfill:
library to provide ES6 built-in classes,
functions and objects for ES5/ES3
33. Babel
• The most compatible (71%) ES6 transpiler
• Integrated with core-js (polyfill library)
• Usage:
• CLI: npm i -g babel
• Browserify: babelify
• REPL on the Web (Try it out!)
40. Prefer arrow function
// ES5 old function
var add = function(a, b) {
return a + b;
};
// ES6 arrow function!
var add = (a, b) => {
return a + b;
};
var add = (a, b) => a + b;
var square = n => n * n;
// good for array filter chains
[1, 2, 3, 4].filter(n => n % 2 === 0).map(n => n * n);
41. Assign “this” to “self”
var john = {
name: "John",
helloLater: function() {
// save `this` as `self`
var self = this;
setTimeout(function() {
// `this` is not available. use `self`.
console.log("Hello, I'm " + self.name);
}, 1000);
}
}
john.helloLater();
// "Hello, I'm John" after 1sec
OUT OF DATE!
42. Arrow function don’t need "self"
let john = {
name: "John",
helloLater: function() {
// use arrow function
setTimeout(() => {
// `this` is available here!
console.log("Hello, I'm " + this.name);
}, 1000);
}
}
john.helloLater();
// "Hello, I'm John" after 1sec
44. ES6 Classes
class Person {
constructor(name) {
this.name = name;
}
greet() {
console.log("Hello, I'm " + this.name);
}
}
var bob = new Person("Bob");
bob.greet();
45. Classes based on Prototype
function Person(name) {
this.name = name;
}
Person.prototype.greet = function() {
console.log("Hello, I'm " + this.name);
};
var bob = new Person("Bob");
bob.greet();
// "Hello, I'm Bob"
OUT OF DATE!
46. Handmade inheritance function
// handmade function to extend
function __extends(child, parent) {
for (var key in parent) {
if (Object.prototype.hasOwnProperty.call(parent, key)) {
child[key] = parent[key];
}
}
function ctor() {
this.constructor = child;
}
ctor.prototype = parent.prototype;
child.prototype = new ctor();
child.__super__ = parent.prototype;
return child;
};
function Programmer(name, language) {
Person.call(this, name);
this.language = language;
}
__extends(Programmer, Person);
OUT OF DATE!
47. ES6 Class inheritance
class Programmer extends Person {
constructor(name, language) {
super(name);
this.language = language;
}
greet() {
super.greet();
console.log("I like " + this.language);
}
}
var bob = new Programmer("Bob", "JavaScript");
bob.greet();
// "Hello, I'm Bob"
// "I like JavaScript"
• with "extends" and "super"
• can extends built-in classes like "Error"
49. Module pattern
// Global module
var myModule = (function () {
// Module object
var module = {},
privateVariable = "Hello World";
function privateMethod() {
// ...
}
module.publicProperty = "Foobar";
module.publicMethod = function () {
console.log( privateVariable );
};
return module;
})();
OUT OF DATE!
50. CommonJS Modules
// import
var foo = require('foo');
foo();
// export
exports.bar = function() {
console.log('bar');
}
OUT OF DATE!
• node.js/npm friendly
• browserify/webpack to build for browser
51. ES6 Modules
• run anywhere (browsers, node.js…) if ES6 available
• easy to parse statically
• strict mode by default in modules
// export (./module.js)
export var foo = "foo!";
export function bar() {}
export class Baz {
baz() {}
}
// import
import {foo, bar, Baz} from "./module";
console.log(foo); // "foo!"
bar();
new Baz();
52. Write “use strict;”
• Strict mode is useful even in ES6.
• In ES6 Module, always strict mode!
• You don’t have write “use strict;” in ES6 modules.
"use strict";
// Error!
with (obj) {}
// Error!
var obj = {a: 1, a: 1};
OUT OF DATE!
54. ES5 has only function scope
function foo() {
var num = 1;
// ... too many statements
if (true_condition) {
// same scope! overwrite above `num`!
var num = 2;
// .. some process
}
console.log(num);
// 2 !!!
}
55. Weird hoisting(巻き上げ)
var a = 'outer';
function bar() {
console.log(a);
var a = 'inner';
}
bar();
// undefined !!!
56. Weird hoisting(巻き上げ)
var a = 'outer';
function bar() {
// hoisting!
var a;
console.log(a);
a = 'inner';
}
bar();
// undefined !!!
57. Place “var”s at the top of the scope
• for function scope and hoisting
function init() {
// `var` once at the top of the scope!
var i,
cell,
cells = document.getElementsByTagName('td');
for (i = 0; i < cells.length; i++) {
cell = cells[i];
cell.addEventListener('click', function() {
cell.style.backgroundColor = '#00F';
}, false);
}
}
OUT OF DATE!
58. Use ES6 let or const anytime!
• let and const create block scope
• no hoisting
• no more "var"!
function foo() {
let num = 1;
// ... too many statements
if (true_condition) {
// different scope!
let num = 2;
}
console.log(num);
// 1
}
59. with for-loop
• each iterate creates its own block scope
for (let i = 0; i < 5; i++) {
// new block scope is created for each iteration
setTimeout(() => console.log(i), i * 100);
}
// display "1", "2", "3", "4", "5"
60. const
• immutable value (not immutable object)
• use like Java's final
const foo = 1;
foo = 100; // Error!
const foo = 1000; // Error!
// properties are mutable
const obj = {};
obj.foo = 1; // No error
62. Incorrect default params
function add(a, b) {
// if "a" is 0, 1 is assigned to "a".
a = a || 1;
b = b || 2;
return a + b;
}
add(0, 0); // 1 + 2 = 3
• Incorrect, but occur frequently
63. function add(a, b) {
// correct, but awful..
if (a === undefined) {
a = 1;
}
if (b === undefined) {
b = 2;
}
return a + b;
}
add(0, 0); // 0 + 0 = 0
Handmade default params
comparing to undefined
OUT OF DATE!
64. ES6 Default Parameters
// default value for each param
function add(a = 1, b = 2) {
return a + b;
}
add(); // 1 + 2 = 3
add(0); // 0 + 2 = 2
add(undefined, 0); // 1 + 0 = 1
add(0, 0); // 0 + 0 = 0
66. Use "arguments" for variable-length
arguments
function foo(first, second) {
console.log("first:", first);
console.log("second:", second);
// arguments is an ArrayLike, not an Array.
var rest = Array.prototype.slice.call(arguments, 2);
console.log("rest:", rest);
}
foo(1, 2, 3, 4, 5);
// first: 1
// second: 2
// rest: [3, 4, 5]
OUT OF DATE!
67. ES6 Rest Params instead of arguments
• You don’t have to use `arguments`
function foo(first, second, ...rest) {
console.log("first:", first);
console.log("second:", second);
console.log("rest:", rest);
}
foo(1, 2, 3, 4, 5);
// first: 1
// second: 2
// rest: [3, 4, 5]
74. Concat with "+" or String#join()
// concat with variables
var name = 'Bob';
var str = "Hello, I'm " + name + ".";
// create multiple lines
var multi = ["line1", "line2", "line3"].join("n");
OUT OF DATE!
75. Template Literal
// interpolation
var name = 'Bob';
var str = `Hello, I'm ${name}.`;
// multiple lines
var multi =
`line1
line2
line3`;
• back-quoted string
88. Use Object as a dictionary
// some keys are dangerous
var obj = {};
var key = "toString";
obj[key] = "value1";
String(obj);
// TypeError: can't convert obj to string
OUT OF DATE!
• some special keys are dangerous
89. Use Object as a dictionary
// cannot use object as a key
var key1 = {name: "key1"};
var key2 = {name: "key2"};
obj[key1] = "value1";
obj[key2] = "value2";
console.log(obj[key1]);
// "value2"
console.log(Object.keys(obj));
// ["[object Object]"]
OUT OF DATE!
• cannot use an object as a key
90. ES6 Map
// no dangerous keys
let map = new Map();
map.set("toString", "value1");
map.get("toString"); // "value1"
String(map); // "[object Map]"
// object as a key
let key1 = {};
let key2 = {};
let m = new Map();
m.set(key1, "v1");
m.set(key2, "v2");
m.get(key1); // "v1"
91. ES6 Set
let set = new Set();
set.add("value1");
console.log(set.size); // 1
// unique
set.add("value1");
console.log(set.size); // 1
• not easy to implement Set in ES5
105. The TC39 Process: Annual
• TC39 committee approves acceptance for each stage.
Stage 0: Strawman (idea)
Stage 1: Proposal (problem, solution and demo/polyfill)
Stage 2: Draft (initial spec)
Stage 3: Candidate (review and feedback)
Stage 4: Finished (two implementations at least)
• Stage 4 features are published as ES201X
on July every year.
108. Exponentiation Operator
// x ** y
let squared = 2 ** 2;
// same as: 2 * 2
let cubed = 2 ** 3;
// same as: 2 * 2 * 2
// x **= y
let a = 2;
a **= 2;
// same as: a = a * a;
113. SIMD
let a = SIMD.Float32x4(1.0, 2.0, 3.0, 4.0);
let b = SIMD.Float32x4(5.0, 10.0, 15.0, 20.0);
let c = SIMD.Float32x4.add(a,b);
// c: (6.0, 12.0, 18.0, 24.0)
• Single Instruction Multiple Data
• Vector data calculation
115. May the Babel be with you!
• It's too far for all browsers to support ES6.
• IE11 will live until Jun 10, 2023…
• You will be able to stop transpiling features
that browsers support natively.
• Also ES201X features are available via Babel.
116. Design your policy:
Which ES6 features do you use?
• Which browsers/node.js do you support?
• If you need IE8 (ES3), it's not easy to use ES6…
• Which feature is effective for your project?
• Is the feature easy to transpile/polyfill?
117. Easy to transpile/polyfill?
• No problem
Arrow function, let/const, Extended Object literal, Classes
Extended function params, Template literal, Map/Set, Promise…
• Be careful/Partial
Module, Generator, Symbol
• Hard/Impossible
WeakMap/Set, Proxy, Reflect, Tail Call Optimization