JSlang.dev

JavaScript Deep Dives with Wolfram. Since 2015
Inclusive, Test-Driven, Spec-Focused, Collaborative.

9+
Years Active
81
Meetups Held
798
Tests Written
80 Tests
on: function

Most Popular

2024

November 28, 2024
#77 Object.groupBy
      hosted by foobar Agency
      Ria-Burkei-Straße 25, München, Germany
      October 17, 2024
      #76 Proxy
      • Are you mutating the original object?
      • Can a proxy setter/getter be async?
        hosted by Check24
        Erika-Mann-Straße 66, München, Germany
        September 19, 2024
        #75 async generators
        • use an empty async generator
        • an async generator resolve to an object with properties
        • does it wait until it has the next data item?
        • simulate slow data using setTimeout
        hosted by foobar Agency
        Ria-Burkei-Straße 25, München, Germany
        August 13, 2024
        #74 Reflect
        • what does define/deleteProperty do?
        • we can not unfreeze a frozen object using Reflect
        • Trying to unfreeze an object
        June 19, 2024
        #73 closures
        • how far can we nest a closure?
        • `var` vs. `let` in a closure?
        • dynamically created closures
        • block `{ }` has the same rules like closures?
        June 07, 2024
        #jscc24 JSCraftCamp 2024 - TDD Session
        • Evaluate the ratio of request successful/failing (ignoring unknown and missing response statuses)
        • with one request only
        • with with many requests
        May 23, 2024
        #72 `this`
        • `function() {}` vs. `() => {}`
        • `this.this`???
          April 29, 2024
          #71 All about functions
          • Order of execution of nested functions
          • Function names
          • Can we write a getter for fn.bind()?
          • Can we use `this` inside any function?
          March 21, 2024
          #70 Prototype
          • creating a bare object give it prototype
          • is there a minimum prototype
          • clarifications
          • the prototype
          February 22, 2024
          #69 Generators
          • take a string and yield every character
          • Can I return from within a generator?
            January 25, 2024
            async+await
            • What happens to errors inside async functions?
            • Can we use an async function for building a "delay"?
            • Can it block the code execution?

            2023

            December 13, 2023
            Static Initialization Blocks
            • in what order are blocks executed?
            • order of constructor and static blocks
              November 23, 2023
              JavaScript Class (and Prototypes)
              • static fields
              • anonymous class
              • inheritance
              October 24, 2023
              Private Class Feature(s)
              • Are private properties really private?
                September 28, 2023
                Bitwise Shift Operators
                • Explore left shift bitwise operators
                  September 22, 2023
                  SoCraTesAT Bitwise Operators
                  • How can we do multiplication using bitwise operations?
                    June 01, 2023
                    Reflect
                        April 27, 2023
                        Prototype Object
                        • Do functions have a prototype?
                        • Create own object with a custom prototype
                          March 23, 2023
                          How to read the spec
                              February 23, 2023
                              Map, Set, WeakMap, ...
                              • Fundamentals
                              • set.add(1) is the same as set.add("1")??
                              • What happens when we add 0 and -0?
                              • Garbage collection for Weak* ...
                              hosted by CHECK24 Vergleichsportal GmbH
                              Erika-Mann-Straße 66, München, Germany
                              January 19, 2023
                              try-finally (without catch)
                              • Use try+finally without catch?
                              • execution order of try+finally
                              • What happens when a block returns?
                              • What happens when a block throws?
                              hosted by TNG Technology Consulting GmbH
                              Arabellastraße 4a, München, Germany

                              2022

                              December 08, 2022
                              try-catch
                              • is the catch statement required?
                              • how does eval work? (a little bit)
                              • can we nest try-catches?
                              hosted by Mister Spex SE
                              Greifswalder Str. 156, Berlin, Germany
                              November 24, 2022
                              Async Generators
                              • what happens with a value that has been consumed?
                              • whats a diff between yield and return?
                              • is getting the next item async or the item itself?
                              hosted by Alasco GmbH
                              Leopolstraße 21, München, Germany
                              October 27, 2022
                              RegExp (Regular Expression) Objects (ECMAScript Spec Chapter 22.2)
                              • Ways to create regexps (objects, literal, ...), (how) do they differ?
                              • RegExp groups
                              • What methods are on a regexp?
                              September 15, 2022
                              Async Generators
                              • What happens when you mix yielded types (static value and promise)?
                              • for await - how does it work? what kind of syntactic sugar is it?
                                hosted by Collaboration Factory
                                Hopfenstraße 8, München, Germany
                                August 18, 2022
                                JavaScript Generators
                                • what is a generator/iterator
                                  hosted by Alasco GmbH
                                  Leopolstraße 21, München, Germany
                                  June 22, 2022
                                  How to read the spec
                                      May 24, 2022
                                      JavaScript arrays
                                      • How can an array get bigger?
                                      • poke holes into an array
                                      • accessing array elements
                                      April 28, 2022
                                      JavaScript Types
                                      • How can it be stricter (typed)?
                                      • what can be boolean? truthy, falsy, ...
                                        March 31, 2022
                                        flatMap(), flat(), ...
                                        • flat()
                                        • flat() with a string as parameter
                                        • flatMap()
                                        February 24, 2022
                                        BigInt
                                        • BigInt basics
                                        • Number.MAX_*
                                        • JSON and stringify
                                        January 20, 2022
                                        DataView
                                        • buffer is (im)mutable?
                                        • endianness
                                        • 4 bytes
                                        • de/encoding using ArrayBuffer/DataView? base64, etc.

                                        2021

                                        December 16, 2021
                                        Fundamental Objects - Object, Number, String, Boolean, ...
                                        • `new Object` vs `Object()`
                                        • Function object
                                        • Boolean constructor
                                        • `Error`
                                        November 18, 2021
                                        prototype
                                        • what in JS has (no) prototype?
                                        • type coercion ...
                                        • class is syntactic sugar?
                                        October 21, 2021
                                        Operators (%, /, *, ...)
                                        • modulo operator
                                        • comma operator
                                        • execution stops when there is a throw
                                        September 16, 2021
                                        at() - function
                                        • does `at()` work on strings
                                        • at() in arrays
                                          August 05, 2021
                                          Temporal API
                                          • Temporal API
                                          • Calculate with dates
                                          • Calendars
                                          July 01, 2021
                                          Operators: ==, ===, +=, !==, !=, >, &&, ||, |, &, ^ ...
                                          • true+false - how operators work?
                                          • can unary operators create an infinite sequence?
                                          • void ???
                                          • `-undefined` and `+new Date` vs `0+new Date`
                                          June 03, 2021
                                          WeakMap
                                          • WeakMap - intro
                                            April 22, 2021
                                            JavaScript `Promises.finally('part 3')`
                                                March 25, 2021
                                                JavaScript Promises Part 2 (continue from last time)
                                                    February 18, 2021
                                                    JavaScript Promises
                                                    • Promises - How to collect more than one promise (in a loop?)
                                                    • What is Promise.any?
                                                    • How does Promise.prototype.finally work?
                                                    January 21, 2021
                                                    JavaScript Modules
                                                    • JS Modules - files vs. modules

                                                      2020

                                                      December 17, 2020
                                                      Top Level Await
                                                      • Tests
                                                      • Top level await - How to test it?
                                                        November 19, 2020
                                                        Tagged Templates
                                                        • Tagged templates - what the function`s signature
                                                        • What does it return?
                                                          October 22, 2020
                                                          Optional ?. chaining (this time for real)
                                                          • Optional chaining (`?.` operator)
                                                          • Whats the default return value if an element is undefined/null? (without the operator)
                                                          • What about newlines, spaces?
                                                          • How does it work with (async, generators) functions?
                                                          September 24, 2020
                                                          Dot operator and optionally optional chaining
                                                          • dot operator syntax and primitive types
                                                            March 26, 2020
                                                            ES6: Reflect - (REMOTE)
                                                            • Create an object using `Reflect`
                                                            • Override properties using Reflect
                                                            • Object vs. Reflect
                                                            • Work with a frozen object
                                                            February 20, 2020
                                                            async+await
                                                            • async/await
                                                              hosted by HolidayCheck
                                                              Neumarkter Str. 61, München, Germany
                                                              January 30, 2020
                                                              Scope
                                                              • var, let, const
                                                              • hoisting
                                                              • nested scope + hoisting
                                                              • lexical vs dynamic scoping
                                                              hosted by HolidayCheck
                                                              Neumarkter Str. 61, München, Germany

                                                              2019

                                                              December 19, 2019
                                                              Generator - again, again and again
                                                              • Creating a generator
                                                              • Calling a generator
                                                              • Using a generator
                                                              hosted by HolidayCheck
                                                              Neumarkter Str. 61, München, Germany
                                                              November 14, 2019
                                                              Understand Promises - by writing tests
                                                              • Promises basics
                                                              • Promise.all
                                                                hosted by HolidayCheck
                                                                Neumarkter Str. 61, München, Germany
                                                                September 18, 2019
                                                                Advanced Promises - clock-in kata
                                                                • Clock-in kata
                                                                  hosted by HolidayCheck
                                                                  Neumarkter Str. 61, München, Germany
                                                                  August 29, 2019
                                                                  Dynamic Imports
                                                                  • How to use dynamic imports
                                                                  • Relative and absolute paths
                                                                  • Global scope and dir
                                                                  • Nested imports
                                                                  hosted by HolidayCheck
                                                                  Neumarkter Str. 61, München, Germany
                                                                  July 17, 2019
                                                                  ES10 features
                                                                      hosted by HolidayCheck
                                                                      Neumarkter Str. 61, München, Germany
                                                                      June 27, 2019
                                                                      Proxy Object
                                                                      • What can we proxy?
                                                                      • How does the handler work
                                                                      • an async setter
                                                                      • helper, learning, trying out
                                                                      hosted by HolidayCheck
                                                                      Neumarkter Str. 61, München, Germany
                                                                      May 23, 2019
                                                                      prototype
                                                                      • How it works???
                                                                      • Learning about ...
                                                                      • What can we do with the prototype?
                                                                      hosted by HolidayCheck
                                                                      Neumarkter Str. 61, München, Germany
                                                                      March 07, 2019
                                                                      import() as a function
                                                                      • Tests
                                                                        hosted by HolidayCheck
                                                                        Neumarkter Str. 61, München, Germany
                                                                        February 14, 2019
                                                                        Async Iterations (for-await-of)
                                                                        • for-of with async+await
                                                                        • having `await` inside `forEach`
                                                                        • iterate over list of promises
                                                                        hosted by HolidayCheck
                                                                        Neumarkter Str. 61, München, Germany
                                                                        January 24, 2019
                                                                        The Global Object
                                                                        • Access the global object
                                                                        • Inspect the Global Object
                                                                        • Delete from Global Object
                                                                        hosted by HolidayCheck
                                                                        Neumarkter Str. 61, München, Germany

                                                                        2018

                                                                        December 12, 2018
                                                                        Labels
                                                                        • dynamic labels? (can use variables for labels?)
                                                                          hosted by HolidayCheck
                                                                          Neumarkter Str. 61, München, Germany
                                                                          November 22, 2018
                                                                          Proxies
                                                                          • Learning about the `new Proxy()`
                                                                          • What can we do with it?
                                                                            hosted by HolidayCheck
                                                                            Neumarkter Str. 61, München, Germany
                                                                            October 18, 2018
                                                                            Errors
                                                                            • types of errors
                                                                            • props and methods of Error
                                                                            • custom error classes
                                                                            hosted by HolidayCheck
                                                                            Neumarkter Str. 61, München, Germany
                                                                            September 18, 2018
                                                                            Type coercion
                                                                            • Tests
                                                                            • to number
                                                                              hosted by HolidayCheck
                                                                              Neumarkter Str. 61, München, Germany
                                                                              June 07, 2018
                                                                              Generators (maybe also async)
                                                                                  hosted by HolidayCheck
                                                                                  Neumarkter Str. 61, München, Germany
                                                                                  April 19, 2018
                                                                                  Map, Set, WeakMap
                                                                                      hosted by HolidayCheck
                                                                                      Neumarkter Str. 61, München, Germany
                                                                                      March 23, 2018
                                                                                      Functions
                                                                                      • Function
                                                                                      • closure
                                                                                      • this "stuff"
                                                                                      March 22, 2018
                                                                                      ES6 function (again!!!!) - we need to learn more
                                                                                          hosted by HolidayCheck
                                                                                          Neumarkter Str. 61, München, Germany
                                                                                          February 15, 2018
                                                                                          ES6 - Template literals
                                                                                          • tagged template strings, are an advanced form of template strings
                                                                                          • the function can access each part of the template
                                                                                          • the 1st parameter - receives only the pure strings of the template string
                                                                                          • the 2nd and following parameters - contain the values of the processed substitution
                                                                                          • a template string, is wrapped in ` (backticks) instead of \' or "
                                                                                          • by default, behaves like a normal string
                                                                                          • can evaluate variables, which are wrapped in "${" and "}"
                                                                                          • can evaluate any expression, wrapped inside "${...}"
                                                                                          • on tagged template strings you can use the `raw` property like so `s.raw`
                                                                                          • `String.raw` as a static function
                                                                                          • template string, can contain multiline content
                                                                                          • and expressions inside work too
                                                                                          hosted by HolidayCheck
                                                                                          Neumarkter Str. 61, München, Germany

                                                                                          2017

                                                                                          November 09, 2017
                                                                                          ES6 - Proxies
                                                                                          • Proxy, for arrays
                                                                                          • proxy functions
                                                                                            hosted by HolidayCheck
                                                                                            Neumarkter Str. 61, München, Germany
                                                                                            October 05, 2017
                                                                                            SharedArrayBuffer
                                                                                            • web worker
                                                                                            • SharedArrayBuffer
                                                                                              hosted by HolidayCheck
                                                                                              Neumarkter Str. 61, München, Germany
                                                                                              September 07, 2017
                                                                                              (function(){Function, function, () => {}, ...})()
                                                                                              • function session
                                                                                              • `bind()`
                                                                                              • `arguments`
                                                                                              • `this`
                                                                                              hosted by HolidayCheck
                                                                                              Neumarkter Str. 61, München, Germany
                                                                                              August 10, 2017
                                                                                              Generators
                                                                                              • Transmitting a file of 10 chars, with initial package size 1 char
                                                                                              • we set the package size
                                                                                                hosted by HolidayCheck
                                                                                                Neumarkter Str. 61, München, Germany
                                                                                                July 06, 2017
                                                                                                Classes, Prototypes a look under the hood
                                                                                                    hosted by HolidayCheck
                                                                                                    Neumarkter Str. 61, München, Germany
                                                                                                    June 01, 2017
                                                                                                    async and await
                                                                                                        hosted by HolidayCheck
                                                                                                        Neumarkter Str. 61, München, Germany

                                                                                                        2016

                                                                                                        April 26, 2016
                                                                                                        ES6 Promises kata
                                                                                                            hosted by Atoss / Crewmeister
                                                                                                            Am Moosfeld 3, München, Germany
                                                                                                            March 22, 2016
                                                                                                            Mob developing a Promise-kata
                                                                                                                hosted by HolidayCheck
                                                                                                                Neumarkter Str. 61, München, Germany
                                                                                                                January 26, 2016
                                                                                                                ECMAScript 6 - Destructuring
                                                                                                                    hosted by CupoNation
                                                                                                                    Dingolfinger Str. 15, München, Germany

                                                                                                                    2015

                                                                                                                    November 24, 2015
                                                                                                                    ECMAScript 6 - Proxies
                                                                                                                        hosted by Next Generation Mobility
                                                                                                                        Zielstatstrasse 13, München, Germany
                                                                                                                        October 27, 2015
                                                                                                                        ECMAScript 6 - Generators
                                                                                                                            hosted by Next Generation Mobility
                                                                                                                            Zielstatstrasse 13, München, Germany