If you have ever wanted to code an application with Angular this is your chance. Join us for a fun filled day of learning Angular in this hands-on workshop. You will go from 0 to 60 with your Angular knowledge and be able to create our own Angular applications by the end of this workshop. We will start with a new project and continue to build up the project until we have a full application at the end.

Topics Covered

• What is Angular and the different parts that make up Angular?
• Angular CLI Overview
• Angular project layout overview
• Creating common components like headers, footers, and menus.
• Applying CSS to just a single component vs the whole site
• Creating new components (pages)
• Routing between components (pages)
• Calling an external http service
• Preparing your application for deployment
• Testing overview (if time permits and our brains aren't already full with Angular knowledge)

Pre-Requisite Knowledge:

• Html and CSS
• Understanding of how events like click work in Html/JavaScript
• TypeScript is helpful but we will cover the needed knowledge if you do not have any TypeScript experience

Pre-Work:

• Node LTS 6.x (https://nodejs.org)
• Visual Studio Code (https://code.visualstudio.com)
• Angular CLI (npm install -g @angular/cli)
• Create a new Angular project using the Angular CLI
  • Open Command Prompt or Terminal
  • Navigate to c:\ on Windows and ~/ on Osx
  • Run: mkdir projects
  • Run: cd projects
  • Run: ng new ng2ws --style scss --routing
  • Run: ng serve
  • Open browser and navigate to http://localhost:4200 and you should see the default web page for your Angular application

Amazon DynamoDB is a flexible and scalable data store that is an ideal solution for many applications. Unfortunately, not too many popular open source projects exist that provide a high level abstraction similar to libraries like mongoose or any SQL ORM. For this reason, Dynamo has found itself having a much more daunting entry barrier for smaller, faster moving projects.

In this talk, we'll take a look at how our team tackled building a flexible Node.js library that made accessing Dynamo easier. From simple extensions to the AWS API like querying items and creating tables, to creating "models" for your documents. This will be presented from the view of a quick moving startup that wrote some simple code to make understanding Dynamo a bit easier which eventually became what we think is something that tackles most use cases.

Also covered will be the advantages and disadvantages of DynamoDB both in a general sense and in the context of a web application. We will also briefly take a look at using DynamoDB streams and AWS Lambda functions to perform "servlerless" processing against your database.

Development teams are now using the exciting—and extensive—new JavaScript features available within ES6. Yet, as adoption has spread and projects have adapted, the language continues to evolve and expand under the Ecma TC39 committee. Last year, two features were quietly added for ES2016. In January, another handful of improvements were marked final for the release of ES2017.

One thing is certain: the JavaScript community is not slowing down! Investigate the new and proposed features of JavaScript. Understand the ES.Next maturity stages and the TC39 review process. And most of all, become empowered to prepare for what lies ahead.

MQTT is an extremely lightweight publish/subscribe messaging transport. It is commonly used as a machine-to-machine connectivity protocol for IoT devices, and usually runs over TCP/IP using sockets. But, recent efforts have implemented the protocol in JavaScript using web sockets, making it possible to use MQTT from within a web browser. This session will introduce the MQTT protocol, discuss various brokers, talk about messaging and Quality of Service, and provide examples of how to use Pub/Sub to enhance your web application and interact with IoT devices.

Lost in the forest of front-end build systems out there? Check out Gulp! Gulp makes it super easy to minify, concatenate, and optimize your assets in an easy piping build stream. There are only a few commands to learn, so writing complex tasks (like you would in another system) isn't a thing in Gulp. In this talk, I will walk through what Gulp is and create a working gulpfile that can be used across endless front end projects that minifies, concatenates, and optimizes assets, as well as live reloads the browser using browser-sync.

If you are going to write JavaScript applications, sooner or later you are going to have to deal with asynchronous calls. And while on the surface they may seem intimidating, there a variety of tips, tricks and techniques in JavaScript to help you deal with them. In this session, I’ll explain how the JavaScript event loop works and how to manipulate it for your own ends. I’ll cover the various way to handle async, such as callbacks, promises and async/await including what makes them different and how to decide which is best for any given situation. I’ll explain who concurrency works a little differently in JavaScript then you might be used to and some patterns to deal with it. And finally, I demonstrate how to create your own asynchronous calls and when it’s appropriate to do so. You'll see that asynchronous JavaScript is an easy and effective way to create great and responsive JavaScript applications.

JavaScript has become one of the most popular programming languages. Many of us who have been working with statically typed, OOP-orient languages like C# or Java have started working more and more in JavaScript. But while most of these developers who been using TDD in their previous language come to JavaScript, they often leave this practice behind. And it's understandable why. Developers who are familiar with unit testing in C# or Java can struggle with TDD in JavaScript. The language is different, the tooling is different, and all those cool frameworks that we use to build our applications can add complexity to the situation.

The good news is that unit testing your JavaScript is easy, and most frameworks have testability already built in! In this session, you'll see how to make sure your JavaScript is easy to test. You'll learn about the most modern testing tools that help you write tests, even for JavaScript that uses frameworks like jQuery, Angular, and React. And you'll see how TDD can help you start writing better JavaScript.

Creating a solid architecture for any system we design can be a challenging process. The frameworks we use often include some opinion about how our software should be designed but these guidelines may not always be the best for the long-term health of our application. How can we build our applications to ensure they are both maintainable and extensible in the future?

In this talk, we'll discuss how taking a feature based approach to our application architecture can help us clearly structure applications that scale well over time. Additionally, we will talk about how we can apply these concepts to both the front-end and back-end to promote a consistent mindset across the entire tech stack. All examples will be using .NET Core and React but the concepts apply well beyond these technologies.

TypeScript isn’t just a strongly-typed replacement for JavaScript – it’s a full language with lots of modern features, including a cutting-edge type system. This awesome type system is often overlooked in favor of other features such as decorators and async/await, but is one of the best reasons to use TypeScript.

In this session, Spencer will discuss the advanced type features of TypeScript, including intersection types, type guards, nullable types, type aliases, string literals, and discriminated unions. We’ll also discuss ways to take full advantage of TypeScript’s compile-time checking to ensure your code is clean and safe.

Whether you’re a seasoned React.js developer or not, this talk will show how React Native should be a serious contender for writing your next mobile application.

Starting with a basic overview of its tools and ecosystem we will discuss the awesomely well designed development experience of React Native (NO constant recompiling, Chrome-like dev tools, LIVE RELOADING!!!). We will the show how simple it is to get started by reusing components from your React web apps before finally exploring how companies optimize React to scale for large applications.

To the uninitiated, paradigms can seem daunting, difficult to understand, and even harder to apply. This talk attempts to clear up that confusion and misconception along with giving some practical advice for how different paradigms can be applied in JavaScript.

Beginning with an overview of three common programming paradigms in JavaScript, Object Oriented, Functional, and Imperative (Procedural), this talk will illustrate the differences between all three approaches. After highlighting the possible advantages and disadvantages of each, the talk will conclude with some practical examples of ways to utilize these paradigms in your own code.

React has been on your radar for some time but you don't know the best way to dive in to the ecosystem. There are so many awesome libraries but it's hard to distinguish between what's necessary and what's addressing a pain-point you don't yet have.

In this talk, we will discuss strategies for learning React and some of React's core principles. From there, we will discuss how taking a component-based view of our front-end can help us build an application architecture that scales over time. Finally, we'll discuss some important lirbaries in React ecosystem and what problems they are working to solve.

JavaScript frequently confuses developers, with its odd language rules and inconsistent approach to various aspects of the language. TypeScript is an attempt to clean up the language, simplifying it and creating a syntax easier to understand and use, but that compiles down to native JavaScript for widespread use in the browser (and anywhere else JavaScript is expected). In this session, we'll go over the syntax and semantics of TypeScript, how to use it in a Web application, why it makes the code and more.