Thanks for making
ForwardJS Spring 2018 a success!

WebAPI is a term used to refer to a suite of device compatibility and access APIs that allow Web apps and content to access device hardware (such as battery status or the device vibration hardware), as well as access to data stored on the device (such as the calendar or contacts list).

Goals: Learn about working with APIs. Look into some specific APIs that are commonly used and few new ones. Create a sample app to showcase the APIs.

Specifications: This course is designed for developers who has basic understanding of HTML, CSS and JavaScript and more advanced topics as Promises and looking to learn more about the Web APIs that are used in web development.

You explored Node.js and some of its packages. Maybe you built the hello-world http server and looked into working with the file system. This workshop will be your next step.

Topics: The core Node.js concepts and API modules. The Node runtime built-in modules. V8 and other dependencies. Node's concurrency model. Libuv and the Event Loop. Working with Event Emitters. TCP/UDP networking. HTTP and HTTPS support. Readable, writable, and transform streams. Node clusters and child processes.

Level: Intermediate

Prerequisites: Good knowledge of JavaScript. Basic knowledge of the Node.js runtime.

React basically won the debate for how to build user interfaces in the DOM. Now async is the new driving force of innovation in modern JavaScript. Figuring out how to build an async architecture on React/Redux is still an open question. Learn the pros and cons of different async approaches in Redux including thunks, promises, generators / sagas, RxJS, and more.

You know your JavaScript and you looked into React.js. You understand the big concepts behind React. Maybe you built a simple application with React. This workshop will be your next step.

Topics: The different parts of the React.js library. How to write clean reusable components with modern JavaScript. The Virtual DOM. The JSX extension. The benefits of readability, reusability, and composability. React synthetic events, DOM access. Controlled components. Mounting/Updating lifecycle methods. Testing components. Higher-order components. Performance and optimization. State management and data immutability. Working with APIs. Styling. Production deployment.

Level: Intermediate

Prerequisites: Good knowledge of JavaScript. Basic knowledge of React.js.

What? Is that even possible? We're sure as hell going to try! Since many of us are self taught and/or dropouts (myself included) we lack the advantages that a formal CS education can give. This additional theory can give us useful context to make tradeoffs in implementations and architectures.

We're going to cover:

Algorithms and Big O Analysis Recursion Sorting! Bubble Insertion Merge Quick Data Structures! Stacks, Queues and Priority Queues Maps and Sets Hash Tables Array Lists Linked Lists Binary Search Trees AVL Trees Functional Programming 101 in 30 mins Map Reduce Filter Who this class is for?

Anyone who wishes they had a better understanding of computer science concepts. This includes self-taught developers, designers who learned to code, or devs just starting down the path of learning to be a good coder.

You need to know JavaScript. We won't be going over syntax and we will be going fast. The focus will be on the concepts and not on the language.

Who this class is not for?

If you look at the list of concepts we're going over and say "I know most or all of those" then this class won't be for you. You're welcome to still come but this class will focus on getting everyone up on the same understanding.

Ever been asked a dumb interview question about arcane computer science concepts that you haven’t ever learned and you question why they’re asking? We’re going to learn both how to ace those interviews and why those concepts are still useful to you!

Four more semesters of computer science! This class will cover additional concepts not covered by the first part. It is not required that you take both or even in order. So come in and learn the sorts of things they’ll ask you in technical interviews and that will help you be a better programmer.

Some things we’re going to cover:

Pathfinding Algorithms

Tree traversals

Bloom filters

Graphs

P, NP problems (like the traveling salesman)

Tries

More sorting!

And more!

Who this class is for:

Anyone who wishes they had a better understanding of computer science concepts. This includes self-taught developers, designers who learned to code, or devs just starting down the path of learning to be a good coder.

You need to know JavaScript. We won’t be going over syntax and we will be going fast. The focus will be on the concepts and not on the language.

Who this class is not for:

If you look at the list of concepts we’re going over and say “I know most or all of those” then this class won’t be for you. You’re welcome to still come but this class will focus on getting everyone up on the same understanding.

By now you almost certainly have heard of React and Redux: two libraries that took frontend development by storm. Many large companies like Netflix, Reddit, Facebook, Khan Academy, Airbnb, and more are shipping React. It's become ingrained in the frontend development community.

In this workshop, we'll go from knowing about using React to coding a whole app in it, start-to-finish. After we finish it, we'll refactor to include Redux as part of the app, so you can see how to code an app without Redux and with Redux so you can make an informed decision if you want to include it. We'll also talk about debugging techniques, best practices, and discuss other topics related to the React ecosystem. We'll even do a bit of universal rendering at the end.

This workshop assumes you have a working knowledge of ES5-era JavaScript. ES6 will be used but it will also be explained as it is used.

Elm is a typed, functional programming language that compiles to JavaScript. It's famous for ensuring robust applications, and Elm's wildly developer friendly compiler helps developers write elegant, long-lived and safe frontend code. It has recently started drawing widespread attention and is starting to position itself as something other compile-to-js languages hasn't achieved yet - a viable alternative to JavaScript.

Elm utilizes a React-like rendering system, using a tree of pure view functions, while structuring its app using the so-called Elm architecture (which the Redux architecture is loosely based on). All data is immutable, of course, and the language supports fancy features such as algebraic data types, pattern matching and type inference.

Did this pique your interest? This workshops provides a thorough explanation of syntax and semantics with comparison to JavaScript. The workshop also serves as an introduction to ML-style typed functional programming, and after this workshop you'll be able to judge for yourself whether a language like Elm could ever replace JavaScript as our go-to tool for large-scale web development.

This course will be an introduction to virtual reality development, using mobile web frameworks, based on WebVR. It will begin with introduction to using the 3D framework three.js. The course will then introduce the principles of virtual reality development, and describe how to build immersive virtual reality worlds that can be explored in the browser. The focus of the course will be Android VR devices (Google Daydream, Google Cardboard, and GearVR).

Knowledge of javascript development, and a Google Android phone development device, is required. Some knowledge of basic 3D mathematics is preferred. Some Cardboard headsets will be available for the course, but attendees should provide a mobile VR headset (e.g. Daydream, Cardboard, or GearVR) if they have one. While the focus of the course is mobile, it will be possible to take part with a laptop, and a PC headset such as a Vive or Rift.

Setting up a development environment for client-side JavaScript applications once required combining disparate tools together. Configuring Grunt/Gulp scrips, Browserify, Bower/NPM, etc, required learning all those tools and context switching. Now we have Webpack which can do all the things those tools do and a lot more. This workshop covers basic and advanced Webpack techniques to modularize your JavaScript/CSS/Sass/images/*, implementing hot module replacement, testing, Babel/ES2016, and more.

The Nintendo Entertainment System (NES) defined the look, feel, and sound of video games in the late 80's and early 90's. The NES' impressive library of games was written using 6502 assembly language, which is relatively simple when compared to assembly languages for modern processors. The MOS Technologies 6502 processor, combined with the NES' custom "Picture Processing Unit" (PPU) and optimized memory layout, allowed for an incredibly diverse range of game experiences.

Most commercial NES games were programmed by very small teams, often with only one or two members writing assembly code. Even now, developers continue to push the bounds of what the system was originally thought capable of. There have been a number of Kickstarters for original NES games, often programmed by solo developers. Learning NES development will give you a deeper understanding of how computers work at a low level. Also, it’s fun!

In this workshop, we will explore assembly development for the NES with a modern toolkit, building out a full, playable game along the way. The workshop does not assume any previous experience with assembly language or game development. All you will need is a computer and familiarity with basic programming concepts like variables, if statements, for loops, and functions. By the end of the workshop, we will have covered:

The history of the NES, including the hardware limitations and tradeoffs that led to its design

How the major components of the NES work - CPU, PPU, APU, address bus, cartridge mappers

Binary and hexadecimal numbers

6502 assembly and the ca65 assembler

Creating NES graphics from scratch with modern tools

8-bit collision detection and physics

Reading controller input

Principles of digital sound synthesis

Playing sound and music on the NES

Techniques used in popular NES games

How to write an NES emulator

Distributing your NES games for people to play on real hardware or on the Web

Kevin is a senior software engineer at Snapsheet in Chicago. He has been writing NES assembly in his free time for the last two years. He is interested in programming music, making and analyzing games, and the intersections between code and the physical world. Kevin is a frequent presenter on game development and computing history topics at conferences including Abstractions, Node.js Interactive, and Strange Loop.

@kzurawel

github.com/kzurawel