Dan Wahlin

AngularJS, JavaScript, HTML5, jQuery, Node.js, ASP.NET, C#, XAML

  • New Pluralsight Course: Docker for Web Developers

    One of the most exciting technologies that I’ve researched and used over the past year is Docker. That’s a pretty bold statement, especially since I enjoy working with a lot of different technologies, so let me share a quick story about how I initially got started with Docker and and my personal journey (if you’d prefer you can jump directly to the Docker for Web Developers Course).

  • Video: Modern Web Development Interview with Channel 9

    I had the privilege to sit down with Seth Juarez from Channel 9 at the AngleBrackets conference in Las Vegas (fall 2015) and talk about modern web development and the main technologies that drive it. We talked about a lot of different topics ranging from TypeScript, Angular and Aurelia on the client-side to Node.js and ASP.NET 5 on the server-side. Seth’s a great interview host (and a super cool guy to hang out with) and I really enjoyed talking with him about modern technology in today’s world. Check out the interview below.

  • Getting Started with ES6 - Using Classes

    In a previous post I introduced how ES6 can be transpiled to ES5 using Traceur or Babel. By using transpilers you can write“modern” code and leverage features found in ES6 today while still allowing the code to run in older browsers. In this post I’m going to dive into classes which is one of the shiny new features found in ES6.

  • Video: Building a Single-Page App with Angular, TypeScript, Azure Active Directory and Office 365 APIs

    I had the opportunity to speak at the BUILD 2015 conference in San Francisco with my friend Andrew Connell and had a great time! We gave a talk on Angular, TypeScript, Azure AD and Office 365 APIs and I also gave two “Express” talks on TypeScript. It was super fun to meet new people and hang out with everyone at the conference. I even had the opportunity to check out the upcoming HoloLens device which was super cool! I was heading up an elevator to a meeting and a member of the HoloLens team approached me and asked if I had some time to do some “HoloLens Testing”. Let’s just say that I was a bit late for my meeting – I wasn’t going to pass up the opportunity to check out HoloLens in person.

  • The Role of Interfaces in TypeScript

    In my last post I talked about how classes and interfaces could be extended in the TypeScript language. By using TypeScript’s extends keyword you can easily create derived classes that inherit functionality from a base class. You can also use the extends keyword to extend existing interfaces and create new ones. In the previous post I showed an example of an ITruckOptions interface that extends IAutoOptions. An example of the interfaces is shown next:

  • Extending Classes and Interfaces using TypeScript

    imageIn a previous post I discussed the fundamentals of the TypeScript language and how it can be used to build JavaScript applications. TypeScript is all about strongly-typed variables and function parameters, encapsulation of code, and catching issues upfront as opposed to after the fact to provide more maintainable code bases. One of the great features it offers is the ability to take advantage of inheritance without having to be an expert in JavaScript prototypes, constructors, and other language features (although I certainly recommend learning about those features regardless if you use TypeScript or not).

  • Introducing the AngularU Conference

    In late 2014 my good friend Peter Kellner approach me with a big idea – an idea that immediately caught my attention. He wanted to explore collaborating on a new conference idea that would highlight Angular and other “hot” Web development topics and wondered if I’d be interested in working with him and another friend of his named Kevin Nilson (who is also a good friend now) on a full-scale conference. I’ve been involved with chairing a lot of conference tracks over the years but never been the driving force behind organizing an entire conference. While the idea was definitely exciting it was also a little scary – at least initially.

    After talking more with Peter and Kevin I decided to jump in and we’ve been working hard to put on a top-notch conference called AngularU (short for “Angular University”) that will be held in San Francisco from June 22 – 25, 2015. I’m really excited about the conference and thought I’d discuss some of the key reasons in this post.

  • Creating a TypeScript Workflow with Gulp

    TypeScript provides a lot of great functionality that lets you leverage many of the features available in ES6 today but how do you get started using it in your favorite editor? If you’re using Visual Studio or WebStorm then TypeScript support can be used directly and everything happens magically without much work on your part. But, if you’re using Sublime Text, Brackets, Atom, or another editor you’ll have to find a plugin to compile .ts files to JavaScript or create your own custom workflow.

    While several plugins exist to compile TypeScript and even provide code help as you’re writing TypeScript code in different editors, I generally prefer to use my own custom workflow. There are multiple benefits associated with going with this approach including the ability to standardize and share tasks across team members as well as being able to tie the workflow into a custom build process used in continuous integration scenarios. In this post I’ll walk through the process of creating a custom TypeScript workflow using Gulp (a JavaScript task manager). It’s a workflow setup that my friend Andrew Connell and I created when we recently converted an application to TypeScript. Throughout the post you’ll learn how to setup a file named gulpfile.js to compile TypeScript to JavaScript and also see how you can “lint” your TypeScript code to make sure it’s as clean and tidy as possible.

    Getting Started Creating a Custom TypeScript Workflow

    I talked about using Gulp to automate the process of transpiling ES6 to ES5 in a previous post. The general process shown there is going to be used here as well although I’ll be providing additional details related to TypeScript. If you’re new to Gulp, it’s a JavaScript task manager that can be used to compile .ts files to .js files, lint your TypeScript, minify and concatenate scripts, and much more. You can find additional details at http://gulpjs.com.

    Here’s a step-by-step walk-through that shows how to get started creating a TypeScript workflow with Gulp. Although there are several steps to perform, it’s a one-time setup that can be re-used across projects. If you’d prefer to use a starter project rather than walking through the steps that are provided in this post then see the project at https://github.com/DanWahlin/AngularIn20TypeScript or download the project associated with the exact steps shown in this post here.

    Creating the Application Folders and Files

    1. Create a new folder where your project code will live. You can name it anything you’d like but I’ll call it typescriptDemo in this post.
    2. Create the following folders inside of typescriptDemo:
      • src
      • src/app
      • src/js

    3. Open a command-prompt in the root of the typescriptDemo folder and run the following npm command (you’ll need to have Node.js installed) to create a file named package.json.

    4. npm init

    5. Answer the questions that are asked. For this example you can go with all of the defaults it provides. After completing the wizard a new file named package.json will be added to the root of the folder.
    6. Create the following files in the typescriptDemo folder:
      • gulpfile.js
      • gulpfile.config.js
      • tslint.json

    Installing Gulp, Gulp Modules and TSDimage

    1. Now let’s get Gulp installed globally on your machine. Open a command-prompt and run the following command:

    2. npm install gulp –g

    3. Open package.json and add the following devDependencies property into it. The location of the property in the file doesn’t really matter but I normally put it at the bottom. A sample package.json file with the dependencies already in it can be found at https://github.com/DanWahlin/AngularIn20TypeScript.

      Note: The module versions shown here will certainly change over time. You can visit http://npmjs.org to find the latest version of a given module.
    4. "devDependencies": { 
          "gulp": "^3.8.11", 
          "gulp-debug": "^2.0.1", 
          "gulp-inject": "^1.2.0", 
          "gulp-sourcemaps": "^1.5.1", 
          "gulp-tslint": "^1.4.4", 
          "gulp-typescript": "^2.5.0", 
          "gulp-rimraf": "^0.1.1" 

    5. Ensure that your command window path is at the root of the typescriptDemo folder and run the following command to install the dependencies:

      npm install

    6. The http://definitelytyped.org site provides a Node.js module named tsd that can be used to install TypeScript type definition files that are used to provide enhanced code help in various editors. Install the tsd module globally by running the following command:

      npm install tsd@next -g

    7. Run the following command:

      tsd init

    8. Open the tsd.json file that is generated in the root of typescriptDemo and change the following properties to include “tools” in the path as shown next:

      "path": "tools/typings",
      "bundle": "tools/typings/tsd.d.ts"

    9. Let’s use tsd to install a TypeScript definition file for Angular (an angular.d.ts file) and update the tsd.json file with the Angular file details as well. Run the following command:

    10. tsd install angular --save

      Note: You can install additional type definition files for other JavaScript libraries/frameworks by running the same command but changing the name from “angular” to the appropriate library/framework. See http://definitelytyped.org/tsd for a list of the type definition files that are available.

  • Getting Started with TypeScript – Classes, Types and Interfaces

    One of the big announcements at ng-conf this week was the collaborative work that the Angular and TypeScript teams have been doing. Angular 2 will leverage TypeScript heavily and you can as well in any type of JavaScript application (client-side or even server-side with Node.js). You can also use ES6 or ES5 with Angular 2 if you decide that TypeScript isn't for you. Andrew Connell and I gave a talk on TypeScript at ng-conf that you can view here if interested:

comments powered by Disqus