The administration abundance chain, accepted for rolex replica uk its affordable accouterment and home apparatus offerings, is now peddling high-end artist accoutrement from above labels including, Chanel, uk replica watches and Zac Posen.The artist appurtenances will be awash on The Sears Marketplace through third-party vendors. The fake watches move may assume counterintuitive, but a Sears agent says it takes the administration abundance aback to its roots, which already included affairs cars.
pluralsight – Failing Forward

Browse Tag: pluralsight

Creating Web Applications with Google’s Go


Since I first heard about it, Google’s Go language ( has fascinated me. I love the idea of a fully compiled language as a way to get maximum performance. Add in the powerful, yet elegant concurrent programming model and you have a strong language. But the language designers didn’t stop there, however. They went on to actually make the language…simple. Writing Go feels a lot like writing in JavaScript (my first love), with functions as first class citizens, managed memory, and a quirky object model to boot. However, it is strongly typed and supports massive concurrency via green threads and the actor model for concurrency (aka communicating sequential processes) that erlang uses to such great effect. Additionally, a powerful, yet compact standard library makes it easy to get started building production quality applications.

Learn by Teaching

Since Go is not a blessed language with my current employer, I am always looking for excuses to work with it. Luckily, I was given the opportunity to create a course for Pluralsight that gave me the chance to show what I’ve learned and deepen that knowledge throughout the course-creation process.

The Course

In order to solidify and strengthen my understanding of the language, I decided to focus on developing the course by only using the core libraries. While I wasn’t able to do this completely (parameterized routing is not directly supported), I was surprised at how close I could get. Here is a breakdown of the course and what I cover:

Creating a Resource Server

In this module, the basic components of building a web application are explored. I start with a simple HTTP listener and grow the demo code out to serve as a full resource server, providing static files from the server.

HTML Templates

Go has a very powerful and flexible template system. So much so that a full exploration of this topic could justify a course by itself (and might someday…). In this module, I explore the basic elements of the template system that allow for simple, yet powerful templates to be used to create the view layer of the application. Among the topics covered are: data binding, branching and looping, and template composition (using templates from within other templates).

Building an Model, View, Controller (MVC) Style Application

Go’s basic library comes as a toolkit, meaning that it exposes a collection of components but doesn’t prescribe how they should be composed together. While there are many third party web-frameworks for Go, I chose to walk through the process of creating an MVC framework from scratch using, whenever possible, only core tools. As a software architect by day, I found this process extremely enjoyable and remarkably easy due to the high quality tools that come in the toolkit.

The View Layer

This module takes the lessons learned with templates and applies them to a demonstration project that was designed to simulate a real world problem (a basic e-commerce site for supplying lemonade stands). At the beginning of the module, all of the pages are served as static HTML. By the end, the pages are fully data driven, using templates and a primitive router to allow the server to dynamically manipulate the content that is served.

The Controller Layer

When creating the view layer, a primitive and poorly factored router is included in the application’s main function to handle serving different pages. In this module, a dedicated controller layer is built, complete with a front controller that serves as the router and a collection of back controllers that serve the requests.

This module is broken up into two parts. At first the controllers just serve GET requests, including parameterized routes. Since parameterized routes are not supported out of the box, the awesome “mux” package from the gorilla toolkit was called upon to fill the gap. The second part of the controller discussion deals with handling data submitted by the user, including posted HTML forms and POST requested sent using Ajax.

The Model Layer

Normally, the model layer of an application holds the specific business rules of the project. As a result, this layer typically ends up being “normal” code for the language, without any specific elements that indicate that it is part of a web application. I take advantage of this pause in the action to introduce an element that I feel is missing in many “build and app” style courses like this – testing. While I don’t go into extensive detail about how to use Go’s testing framework, the system is pretty straight forward and it doesn’t take long to create the foundation for a strong unit testing suite.

Persisting Data

The final element of a web application is loading and saving data from persistence layer, typically a database of some sort. I cover this by creating a basic system for logging a user in with an encrypted password and using that information to create a database-tracked session object to allow the user to avoid logging in each time they visit.


Overall, I was impressed with how straight forward and easy it was to create a full web application with Go. As you might expect, it is challenging to have demonstrations that are sophisticated enough to be realistic but simple enough to be easily explained. Go’s simple programming model and focused library allowed me to use a pretty high-level demonstration project, hopefully giving a good context for how you might use Go in your own projects.

If you are interested, check out the course here: and let me know what you think.

Lessons Learned from Creating my First Course for Pluralsight

Way back in July of 2014, a coworker and I decided that we would like to take a shot at becoming authors for Pluralsight. We had both used the site over the years and were impressed with the quality and breadth of the courses offered for such a reasonable rate. This site has become one of the core components of my toolbox for software development work.

In the beginning of January, my first course went live (check it out here), and so I thought I would take a few moments to reflect on how I got there.

The Audition

In order to become an author for Pluralsight, I filled out a simple form, and they contacted my to discuss what I wanted to teach about. While my interests cover a lot of ground, I had been doing a lot of design and development work with the Dojo Toolkit ( and so I decided to start there. I had to submit a short clip illustrating my teaching style and my ability to put together a cohesive presentation on a topic. I decided that I would give an talk about how to add “toast messages” to a web-application. It was simple, easy to cover in a few minutes, and something that I had done several times recently.

It turns out that Pluralsight was in the midst of leveling up their expectations for how to deliver the course material and I got caught in the middle of it. When I first encountered the site, Pluralsight’s course offerings were aimed at disseminating the knowledge from industry experts to a wide audience. This often led to courses that, while containing very good content, lacked the world-class presentation that really makes it easy for the student to absorb. As they have grown, they have become more sensitive to how best to present content. This led me to a series of “revise and resubmit” requests that forced me to raise my own standards quite a bit. While the process was personally difficult, I can never thank them enough for taking the time to teach me some awesome presentation techniques that shape every presentation I make now. If you are interested, there is one course that was key: John Papa‘s course on public speaking is excellent and I basically used his suggestions as the template for my final (and successful) audition video.

The Course

After getting approved to be an author, it was time to author something. I was introduced to my editor and he walked me through the authoring process. As you might imagine, first-time authors are given more support and oversight in order to help them be successful. I was asked to submit several course ideas and then met with one of the content vice presidents to choose one. After that, I put together a more formal course outline and started to create the course material.

The Process

To create the course, I adopted a process that loosely matches my software development flow.

Course Design

Before I started recording, I spent quite a bit of time trying to figure out exactly what I wanted to talk about. During this phase, I used a mind-mapping tool in order to structure the basic course flow that allowed me to take the high level course outline and break it down into the detailed things that I wanted to talk about. This is also the time that I created all of the demos for the course. While this won’t be true for every course, this course was based on a single demo application that evolves throughout the course, adding new elements along the way. With the strategy, I found it very helpful to have the demo application’s evolution completely nailed down before I started to record.

Course Implementation

With the course outline complete, I entered what I call my “production loop” for each module of the course. It consisted of the following steps:

1) Create slides

In this phase, I created whatever slides I needed in the module, including presentation-level animations. This phase allowed me to really get an idea of the flow of the module and how the demo would integrate into it. Of course, I was also trying to organize my thoughts and decide what I might say at different points along the presentation. When the slides were done, I would setup the presentation to automatically transition between slides every second or so. This made it easy to record the slides and slice up the video later.

I would not record audio in this phase (or the next). I try to do that once or twice, but I found that there was too much for me to keep track of and the quality really suffered. As a result, the audio was handled separately and combined later.

2) Record demo

The preparation of the slides really helped me get my head around what I wanted to tell the student during that module. I would them record the demo or demos that were going to be used in the module. I would take a few minutes and prepare a “demo script”; this script listed what I wanted to do and in what order. This helped me avoid skipping steps which would require (painful) rework. If multiple demos were required for the module, I would still create them all at once. This allowed me to stay in the same place mentally (writing code and demoing results) rather than constantly context switching.

As a final part of this step, I would combine the two video feeds (slides and demo) into the order that I wanted for production.

3) Write script

Through the first two steps, I would think a lot about what I wanted to say, but I wouldn’t record anything. This allowed me to alter the direction of the slides or demo as I felt it needed, with no fear about having to re-record audio. With the video now in its production-intent order, I would watch through it and write the script for what I wanted to say throughout the slides and demo. This is also the part of the process where I would put the clip-boundaries that make up the different pieces of a module. In addition to breaking the work down for me, this also served as a nice quality check. Since I was watching the video to create the script, I was hyper-focused on what was going on. This allowed me to find many errors in the video and correct them.

4) Record audio

After the script was done, it was time to record audio. I would do this with only my script and recording software open. I had a pretty good idea of what the video would be showing (since I already had that), but I didn’t want the distraction of watching it while trying to read my script. I recorded the audio in a different application than the video (see the tools section below) to allow me to use the best tools I could for that work. I found this technique to be really productive for me because I could record an audio clip and rough edit it without worrying about resyncing the video to the audio. When a clip was recorded and edited, I would save it out as a separate file.

At the end of this process, my audio was basically production ready. I knew (within a few seconds) the final length of the module by adding up the length of the different clips. I also knew where I wanted the clip boundaries, since they aligned with the audio clips on a one-to-one basis.

5) Sync audio and video

At this point, I have all of the production audio and video, but they are completely out of sync. Due to how the previous steps have left the project, this is pretty easy to correct. At the end of recording the audio, those clips represent the production intent of the course. This meant that most of the editing involved simply altering the video to align with the audio. I would generally use three techniques – freezing the video on a frame, speeding up a section of the video (for large blocks of coding that don’t require a lot of explanation), or deleting a section of video and adding a transition (for ‘auto-completing’ a block of code).

This phase is also where I added the call-outs to the video – visual elements that are overlaid in order to bring the students attention to a specific part of the screen that I am talking about. I normally did this as I synced up a section, not as a second-pass after the synchronizing was done.

6) Final review and course metadata

At this point, the module is production-intent. I would always listen to the clips one more time in order to make sure that everything works together. Specifically, I would check for blank frames (where the video feed has a gap) or missed clip boundaries (the last frame from the previous clip is accidently moved to the first frame of the next causing a ‘flash’ in the beginning of the video).

Finally, I would package up the demo code, create the quiz questions, and complete some files that Pluralsight uses to wire the course into their site infrastructure. With that done, it was time to submit the course to my editor for review.

The Review

After a module was submitted, Pluralsight submitted it to a multi-step internal review process. Sometimes, despite my best efforts, issues would creep into the module that were not up to their standards. After the review was complete, I received feedback on the good and the bad in the module. Also, if any corrections were required, I would be informed about what had to be addressed.

The Tools

Mind Mapping – Mindmup

I have used several mind mapping tools over the years, but I have become completely addicted to always being able to access my data. I looked around and found mindmup to be an excellent web-based mind-mapping tool that allowed me to store my files directly on Google Drive. It can also run disconnected (as a Chrome App) so I could work on it, even if I didn’t have internet access.

Notes – OneNote

I’ve used Evernote quite a bit in the past, but I have recently moved to OneDrive as my cloud storage provider of choice. Since OneNote ties in seamlessly to OneDrive through its web-application, this became my goto choice. I used OneNote to record all of my high level ideas, scripts, and feedback so that I had all of it in one place that I could access from anywhere.

Storage – OneDrive

Pluralsight recommends the use of PowerPoint or Keynote for creating presentations. Since I am a Windows user and Microsoft has made it so economical to get OneDrive and Office together, I went that route. All of my course material is stored on OneDrive so that I get free backups and universal accessiblity.

Video Recording and Editing – Camtasia

Camtasia aims to be a one stop shop for recording, editing and producing video. I found it to be a very good at that, I was not thrilled by its audio editing capabilities. Most of this has to do with the fact that I tended to end up editing audio in the context of my video, which caused my problems. I ended up using another tool for audio editing and importing the complete audio clips into Camtasia for synching and editing.

Audio Recording and Editing – Audacity

Open source projects often amaze me and Audacity is one of them. I ended up using it as my goto tool for recording and editing the audio. Not only did it let me focus in on the audio (without the distraction of the video), but it also contains a wide-array of post-processing tools that allowed me to clean up many audio problems without forcing me to re-record. Given all of the power that it offers, I found it really easy to make many edits (inserting re-recorded clips, deleting sections, etc).

Images – Fotolia

Fotolia is an excellent source for images when creating presentations. One of the challenges that John Papa gives in his public speaking course is to resist the urge to create presentations that are composed of slide after slide of bulleted lists. High-quality images can go a long way toware making content easier to understand by the student. While I did use some of the free images made available through PowerPoint’s clipart, I found that spending a few dollars at Fotolia would allow me to find an image that exactly captured the sense that I was trying to convey on a slide.


Overall, I had an absolute blast creating this course and I look forward to creating many others for Pluralsight. If you think you have something interesting to talk about, feel free to reach out to them and start the authoring process. If you have any questions, feel free to reach out to them, or tweet me and I’ll do my best to help.

If you want to see the course, or any of the other courses I have published, check out my author page on Pluralsight.