Build and Deploy Static Sites with Hugo

Most web sites don’t have data that changes, so why power them with a database and take the performance hit? In this talk we’ll explore static site generation using Hugo, an open-source static site generator. You’ll learn how to make a master layout for all pages, and how to use Markdown to create your content pages quickly.

Then we’ll explore how to deploy the site we made to production. We’ll automate the entire process. When you’re done, you’ll be able to build and deploy static web sites quickly with minimal tooling.

Crypto What? Grokking the Blockchain

With all the buzz online and in the media about cryptocurrencies/blockchain, it’s hard to dig through fragmented articles and fanatical blogs to get to the nuts and bolts of what this technology is, how it works, and what it proposes to do. Come to find out, it promises much more than just KryptoKitties.

Join me as we take a look at this technology, mainly from a developer’s view, and really see what all the hype is about. We’ll start off with some theory on tokenized systems and game theory, trust, what a blockchain is, decentralized systems, along with some history and details on the most well known blockchain, Bitcoin.

We’ll then move into some short, basic C# examples of the cryptographic side of blockchains that reinforce the idea of trust through immutable integrity, such as hashing, HMACS, and Digital Signatures. We’ll also discuss storing transactions in blocks and the two most popular consensus algorithms, Proof of Work versus Proof of Stake.

With this foundation, we will then look at some of the blockchain platforms, such as Ethereum, that take these ideas further. We’ll go through some of the basics of Ethereum such as how it differs from Bitcoin, smart contracts, ERC20 tokens, and DAOs (Decentralized Autonomous Organizations).

We’ll finish off with some very good use cases for the technology outside of cryptocurrencies, some additional resources I’ve curated, along with a short question/answer session. You’ll really be able to impress all your skinny jean friends at the local vape shop after this session!

Digital Go

Go is a game played by two players on a 9x9, 13x13, or 19x19 board, in which the goal is to surround more territory than the opponent. It was invented over 2,500 years ago and was utilized as a strategy exercise by Generals.

Today we bring Go to the 21st century by constructing a prototype 9x9 grid with the Attiny85. The Attiny85 sends a reading of the board to the PC – which broadcasts a live-view of the board over the web. Taking into consideration that the chip is not 100% Arduino compatible, we will explore a development environment without the use of an IDE. The Attiny85 has only an 8MHz processor, 8K flash, and 512 bytes of memory, so every bit is essential.

Finding your MVP with User Story Mapping

Have you ever found yourself staring at your backlog, wondering what is truly important? Do you struggle running a meeting to talk about new features for a product, and are not quite certain where to begin the conversation?

User Story Mapping is one technique you can add to your tool belt that allows you to take a step back and get a higher-level overview of your project, while facilitating brainstorming and providing you a better sense of your projects priorities.

In this session, you’ll be briefly introduced to the concept of user story mapping before diving in head first into an interactive exercise where you get to try it out for yourself. You’ll document the steps in a project, and then strip it down to the bare essentials or Minimum Viable Product (MVP).

Developing Scalable Infrastructure on a Budget

Walk through the process of moving from a working application on your local machine to a running Kubernetes instance leveraging Docker and Google Cloud. Starting with how to “Docker-ize” an application and then publish the Docker image where it can be accessed using our Kubernetes cluster.

Goals

Create a production-ready Docker image from an existing application Deploy a Docker image to a Docker Registry Create and configure a Kubernetes cluster Deploy a Docker image onto the newly created Kubernetes cluster Demonstrate how to connect two Kubernetes services to one-another by deploying a database within our Kubernetes cluster.

Specifications

We will take one of three different pre-created applications. Each application will contain different language/database approaches that can be ran within a Kubernetes environment and will have 3 pieces: application, database, and Nginx proxy. Depending on the interest of the group we will choose one of the pre-built options and begin configuring it to run within the Kubernetes environment.

Milestones

Docker

After taking a general overview of Docker and Kubernetes, we will start creating our Docker assets that we will later run on our Kubernetes cluster. Based on the language preference of the group, we will start with one of the applications demonstrating the basics of creating a Docker configuration to build and run the application. Once the application is able to be run locally as a Docker container, we will deploy the Docker image to a publicly accessible Docker registry.

(Note: the Docker image will make a good catch-up point for anyone that’s fallen behind and is looking for a “reset” button.)

Kubernetes

We will cover the different options for hosting a Kubernetes cluster; both for local development and production services. Utilizing Docker for Mac, Docker for Windows, or kubeadm for Linux when building and running our applications on our development machines. Once we’re ready to move to production-ready, we will discuss some of the popular options for running Kubernetes at scale.

Now that we have a Kubernetes cluster created, we will begin utilizing the Docker assets that we developed within the first segment to run all services required to run our application. This will include the requirements for persisting data from the Kubernetes services to a location on our local disk, configuring the DNS and exposing firewall ports to allow us to properly route traffic through our Nginx instance. Once we have a fully functional Kubernetes service running on our local machines, we can discuss some of the options for using the same configuration files to deploy a cloud-based Kubernetes environment.

Bonus Material

Pending how much time remains, we can cover the remaining two applications and discuss some of the other offers for interacting with a Kubernetes cluster: helm, Heptio, and Istio.

Bonus Bonus Material

Describe and/or implement the Continuous Integration pipelines for build, test, and deploy to our Kubernetes cluster based on a Github hook.

Distributed Sytems in Go with gRPC

Welcome

Chapter Duration: 10m

This module covers general information about your instructor and course materials.

Getting Started

Chapter Duration: 10m

This module covers general environment setup and other resource related information needed to complete the courses contained within.

Introduction To Go Web Development

Chapter Duration: 30m Hands On Exercises: 1 Shared Lab, 1 student lab

This module will cover some basic concepts of web development in Go. We'll cover how to create handlers, set up routing, and launch a basic web server.

Testing Web Applications

Chapter Duration: 1h Hands On Exercises: 2 Shared Labs, 2 student labs

In the standard library there are two mechanisms for us to use to test web applications.

Unit Style Testing

Integration Style Testing

These are not their "official" names, but I believe they do a good job of describing the styles of testing.

In this module, we'll cover both styles of testing and how to use thb.

Install And Configure Protobuf

Chapter Duration: 30m Hands On Exercises: 1 Shared Lab

Installing all the tools you need to make protocol buffers work can be challenging. This chapter lays out in detail the steps needed to properly install and configure your development environment for protocol buffers. It also includes specific steps for each operating system when necessary.

Afternoon Break

Chapter Duration: 15m

Afternoon Tea/Coffee Break.

Protocol Buffers

Chapter Duration: 1h30m Hands On Exercises: 1 Shared Lab, 2 Student Labs

Protocol buffers are Google's language-neutral, platform-neutral, extensible mechanism for serializing structured data – think XML, but smaller, faster, and simpler.

In this module, we will cover how to create and use protocol buffers, as well as how to extend thb.

Introduction To GRPC

Chapter Duration: 2h Hands On Exercises: 1 Shared Lab, 2 Student Labs

gRPC is a modern open source high performance RPC framework that can run in any environment. In this module we will cover the basic concepts used in gRPC, as well as create some simple RPC calls using protocol buffers and implement them with gRPC. We'll also cover how to create specific errors and codes with gRPC.

Finalize

Chapter Duration: 10m

This module covers where to get more support on Go, recommends books and videos, and list contact information for our instructors.