Memory Vault is a program I’ve been working on for a little while. It’s designed to help you remember the past.

Memory Vault is a place to store videos of you talking to yourself about your day. You can have it remind you to record on a schedule, but we don’t set one up by default. You can reflect once a month or dozens of times a day. You can record yourself on the beach, in the car (eyes on the road!), or on the Hải Vân pass.

There’s no pressure to make the videos short or long, either. Videos are compressed so that they take up very little space, and the program can skip all the moments where you aren’t talking so you can take as much time as you need (I find this feature really helpful).

When you are finished, you can choose to have Memory Vault analyze the video. If you do, a written transcript of what you have said is created. You can search through it to find things you have said in the past; you can also download the transcript, which can be a pretty useful way to write emails. Memory Vault will even try to figure out what you are saying and suggest organization tags for you.

You could end up recording some pretty sensitive and embarrassing stuff in Memory Vault; you want to make sure your most sensitive thoughts aren’t being analyzed to give you hyper-customized ads. You may also end up cherishing your videos and looking back on them in the future; possibly even when you are 90 years old and smartphones are a thing of the past. Memory Vault tackles these really important problems in two ways.

First, you are in charge of storing your memories. We recommend storing them on a cloud drive like Dropbox or Google Drive, but you can store them wherever you want.

Your memories are stored in a way you can get to them — in a bunch of folders grouped by the year, month, and day. Your videos are just regular video files. You should still be able to watch them 70 years from now.

Privacy is another really important thing to think about. By default, we don’t ever need to know what you do with Memory Vault. There is no tracking software in the program, and we don’t store your data and don’t (or rather, can’t) look at it.

If you choose to analyze your videos, we will need to deal with your data. In that situation, your videos are uploaded to our servers where they are analyzed and a written transcript is generated (we do via machine). We hold onto your data for as little as possible during this process; as soon as the transcript is sent back to you, we delete everything from our servers. We don’t ask for your name and we don’t use your information for data analysis purposes. We will have a privacy policy and it won’t just be a formality.

Does this sound like something you might want to try? Memory Vault is still in development, but there is a beta version available for Mac and Windows. If you’d like to try it out, enter your email address below:

Part 3: Running an Azure Media Services Job

In Part 2, we were able to upload a video file to Azure Media Services. Now that an Asset has been created and a file has been uploaded to it, let’s run an encoding job on it.

Before we can create an encoding job, we must request an Azure Media Services media processor. AMS has many media processors, each of which can do different tasks. Some of these include:

• Video thumbnail generator
• Optical character recognition processor
• Face redactor/blurring
• Motion detection processor
• Face detector
• Hyperlapse time-lapse encoder
• Transcript/subtitles generator

The Azure Media Services media processors are described in more detail in an article from Microsoft.

Request a Media Processor

In the MediaServices class, create a method that retrieves the ID of a specified media processor:

Create a Job

In the MediaServices class, create a method that generates an encoding job:

Running a video encoder job on an asset

Now that we have the ability to request a media processor and generate a job, let’s run an encoding job on our uploaded video file from the main Program.cs file:

Congratulations! You should now have a video encoding job running on your newly uploaded asset.

Your code should now look like this.

You now have everything you need to upload video files to Azure Media Services and run a number of different encoding jobs.

Encoding Video with .NET Core and Azure Media Services — Part 3 was originally published in Jean-Marc’s Thoughts on Medium, where people are continuing the conversation by highlighting and responding to this story.

The May Long weekend loomed on the horizon, and we decided we should do something special to celebrate our three days off.

I think we did pretty good.

The Sloquet Hot Springs are a natural wonder and something of an untouched gem. The long distance from Vancouver — over 5 hours — and rough roads mean that the area doesn’t get much attention. This in turn means that the springs are remarkably natural.

The drive up from Vancouver is long, but the scenery on the way is very pretty.

Morgan getting her country girl on.

And getting into the mountains as well.

The whisky doubled as a G-force meter.

We saw a bunch of deer on the way up, including one that charged the truck kamikaze style. This one knew what was up though.

The roads up are very bumpy; an all-wheel drive car is recommended, but a lot of people make the trek in 2wd cars. A stranger’s car lost its oil pan on the way up, which sounds rough.

The last 75km up is on a logging road, and the final 10km of that is on a very rough unmaintained road. The logging road is plowed in the winter, but the final 10km is left alone. We heard from people with heavy duty trucks that it’s impossible to drive more than a few feet up in the winter; expect to snowshoe or snowmobile your way up if you’re visiting in the winter.

The campsites are well laid out and very comfortable. We paid $15 per night per car, which works out to an incredible deal. For your $15 you get unlimited access to the hot springs, a campsite with fire pit, and outhouses. Some campsites even have benches and cooking grills.

We arrived at 11AM on a Saturday morning and claimed one of the last remaining campsites, but that may have been more because of the May long weekend holiday.

There’s something incredibly satisfying about swinging an axe down on a cutting block. Here’s hoping that’s not just some latent psycopatheic tendencies.

The unusually wet start to the year meant that we could make fires without any worry. We brought our own wood, but you can buy a wheelbarrow full for $15.

Alecia made a huge dent in this book over the weekend, figuratively speaking. I’m sure she also got it a little dirty.

Fred and Alecia showing us what true campfire cooking looks like.

A lot of cribbage was played. I discovered I need to learn basic addition.

There was also a lot of hanging out.

And a lot of looking at trees.

There aren’t any designated hiking trails, but the area is fun to explore and easy to navigate. There were signs are recent bear activity, so you don’t want to be a complete idiot about it.

The hot springs are fed from a series of natural streams. These are really, really, really hot. I couldn’t keep my hand under this stream for more than a second.

The hot springs themselves are really, really beautiful. The hot streams meet the freezing river below and pool into a series of natural baths. Each area is a different temperature, so you can go from chilly to charred and everything in between.

There’s very little sign of human meddling. The only foreign object is a small changing area on the edge of the pools.

Tea candles and lamps are scattered among the rocks, and the springs look magical when the stars come out and the candles are lit.

It can get pretty busy in the evening, but we never found it hard to find space. The pools clear out during the day, which makes for some pretty relaxing times.

The Sloquet hot springs are pretty incredible, and well worth the 6 hour drive. It’s hard to believe that something like this can happen naturally, but nature can be pretty amazing. I’d love to know how many generations have dipped their toes into the water after a long hard day.

Sloquet Hot Springs was originally published in Jean-Marc’s Thoughts on Medium, where people are continuing the conversation by highlighting and responding to this story.

Part 2: Uploading Videos to Azure Storage

Let’s continue from where we left off in Part 1. We now have a MediaServices class that can communicate with Azure Media Services and establish an authentication token. Now let’s upload a video to Azure.

How files are uploaded to Azure

Before we can upload a video file to Azure, we need to define an Asset, an Access Policy, and a file Locator.

Assets are collections of video, audio, image, or text files with corresponding metadata. The files attached to an Asset instance can be encoded or streamed using AMS.

Access Policies define the permissions and access timeframes for an Asset. An Access Policy with upload permissions must be defined before a file can be uploaded to an Asset.

Locators provide an entry point to access files in an Asset. Locators can be configured with Shared Access Signatures for additional permissions, such as the ability to upload a file to the locator address. Locators require a corresponding Asset and Access Policy before they can be created.

Generating an asset

Let’s start by creating the method to generate an asset:

This method takes an asset name and a storage account name and creates an Asset instance in Azure Media Services. Note that the method returns an instance of an Asset class. This can be defined with the following code:

Generating an Access Policy

Next, let’s create a method that generates an Access Policy in AMS. Insert the following method in your MediaServices class:

Generating a Locator

Finally, let’s create a Locator instance that will be used when uploading the file. Insert the following code in your MediaServices class:

This method returns an instance of a Locator class, which can be defined with the following code:

Finally, let’s tie it all together by calling these methods from the main Program.cs file:

Uploading a video to Azure Media Services

Now that we have a locator instance for an asset with an upload-enabled access policy, we can upload a file to Azure. Let’s start by creating a method that takes a file stream, an Asset instance, and a Locator instance:

Once the file has been uploaded to the locator, we must generate a file info request before the file is registered to the asset. The following code generates a file info request:

Finally, let’s tie it all together in the Program.cs file. This code demonstrates an example upload:

Your should now have a video file uploaded and registered to an asset.

Your code should now look like this.

If you are having trouble determining the state of your Azure Media Services account, you may wish to install the Azure Media Services Explorer. This tool provides a nice GUI for navigating your Azure Media Services instance.

In the next step, we will encode our newly uploaded video file.

Encoding Video with .NET Core and Azure Media Services — Part 2 was originally published in Jean-Marc’s Thoughts on Medium, where people are continuing the conversation by highlighting and responding to this story.

Part 1: Authenticating with Azure Media Services

Azure Media Services is a service that can encode video for mobile devices, generate thumbnails, and even create subtitles from audio tracks. It’s powerful and cheap, and I wanted to use it in an application.

Sadly, there is no official API for .NET Core.

In this tutorial, I will demonstrate how to create a bare-bones REST connector for Azure Media Services in C# and .NET Core 2.0. We will start by building a project that can talk to Azure Media Services.

Creating the Project

Let’s start by creating our new project. For this demonstration, we will create a simple console application, but all of the principles should work just as well in a web application.

Open Visual Studio and create a new “Console App (.NET Core)” project:

You should now have a simple project that outputs “Hello World!” to a console.

Time to spice things up a notch.

Setting up our Azure Media Services Account

Before you can even start to think about talking to Azure Media Services (or AMS, for short), you first need to create an Azure Media Services account via the Azure portal.

Once your Azure Media Services account is created, you will need to create a client id/secret pair and download the required connection information. This includes:

• Azure Active Directory tenant domain
• REST API Endpoint
• Client ID
• Client Secret

The AAD tenant domain and REST API endpoint can be found by clicking on your Azure Media Service instance from the Azure portal, then clicking on “API Access” and then “Connect to Azure Media Services API with service principal”.

You will then see your tenant domain and REST API endpoint.

You may generate a Client ID and Secret from this part of the Azure Portal. The interface is clunky and hard to follow, but Microsoft has a decent guide for how to generate the client information.

Once you have the required information, add it to the main method of your console program. This is a bad approach in practice — it is important to never hard-code sensitive data into code or commit it into a repository — but we’re going for the simplest possible solution to start.

Now that our credentials are accessible, let’s start building the REST service

Building our Azure Media Services Client

Let’s create a new class to serve as our Media Encoder Service. Create a Services folder within the Solution Explorer, then create a MediaServices class within the newly created folder.

Now let’s create a constructor that takes the configuration values and stores them internally

We will need to create an HttpClient instance that will be used to communicate with the AMS REST API. Let’s initialize that client and set the proper request headers:

Pay close attention to the request headers! The AMS API is very sensitive to these values, and any omission or altered value will likely trigger one of many fairly obtuse error messages.

The next step is to request an access token from AMS. This will allow us to authorize our subsequent requests to AMS. In the MediaServices class, create a method named “InitializeAccessTokenAsync”. The following code will request a token from AMS:

Thanks to the azure-media-services-core SDK created by Shawn Mclean for the code.

In the main Program.cs file, initialize a MediaServices instance and request an access token:

This will require converting the Main program into an asynchronous task. NET Core 2.0 supports asynchronous console-based commands, but the program’s .csproj file must explicitely specify a LangVersion of latest. Your .csproj file may look like this:

Run the project, and you should have an HttpClient that has been authorized with your access token.

Congratulations! You have created a MediaServices class and successfully authenticated with your Azure Media Services instance. At this point, your code should look something like this project.

In Part 2, we will start uploading files to Azure and creating Media Services Assets.

Encoding Video with .NET Core and Azure Media Services — Part 1 was originally published in Jean-Marc’s Thoughts on Medium, where people are continuing the conversation by highlighting and responding to this story.

Being a pigeon parent is a mixed blessing. They don’t make for great pets — at least, not without a whole lot of training. But there’s something really cool about seeing how animals raise children in the wild. So cool, in fact, that I decided to start documenting it.

Day 1

The pigeons start making preparations, shoving the tree’s soil around and gathering twigs. We name the father Baba and the mother Bubu.

Day 2

Pigeons are actually quite remarkable parents. The father and mother rotate over evenly spaced shifts, roughly 6 hours each. Parents never leave the eggs exposed; the two birds will form a sort of mini locomotive and shuffle over the eggs. Over the course of the two weeks of incubating, I only saw the eggs a handful of times.

The first few weeks are pretty boring, so let’s skip to the interesting bit…

Day 11

The babies are born! Life changes remarkably for the parents from this point onwards. Baby pigeons have bottomless stomachs, and these parents have two mouths to feed.

While the children are young, the parents continue the same approach of sitting on top of them. They’ll soon become big enough that the parent’s can no longer cover them.

Day 12

Pigeons feed their children by regurgitating food into their childrens’ mouths. It doesn’t look like a whole lot of fun — there’s only space for one beak in the parents mouths, so both babies are constantly fighting each other for the priviledge. It’s not an issue at first, but when the kids get older the parents will start to snap back.

Now that the children are born, there’s slightly less urgency to the shift changes.

Day 13

It’s now been nearly three weeks since the tree’s had any water, but I don’t want to flood the soil and freak out the kids. I decide to try melting ice. It’s kinda effective.

Day 14

Concerned with how quickly the babies are growing — and how the parents cant seem to keep up with the demand — I put out some crackers. This only lasts for a couple of days before I realize that the parents know what they’re doing and don’t need my help.

Day 16

The babies are finally big enough that the parents can’t feed them enough through shifts. That, or they’re getting sick of the whole parenting thing. They start leaving the babies alone for small periods of time.

Day 17

The babies are growing bigger day-by-day. The yellow fuzz that completely covered them at the start is starting to make way for spines. These will eventually turn into full-blown feathers.

Day 18

The babies are so big they can no longer be completely covered by the parents. The spines start to get puffs of feathers on them. The parents are starting to leave the kids alone for longer and longer periods of time. Every time a seagull swoops by the window, I hold my breath and hope it doesn’t spot the babies.

Day 20

Disaster! A seagull spots the babies and goes in for the attack. I manage to shoo it away in the nick of time, but it keeps coming back for more. I put together a cardboard sanctuary — just big enough for the parents to squeeze through, but small enough that seagulls don’t have space.

The parents don’t know what to do about this new setup at first, but they figure it out soon enough.

Day 21

The pigeons are really starting to develop a coat now. They’re also big enough that their poop really starts to pile up.

Day 25

The babies really go for it during feeding. As cool as it must be to raise kids, the feeding part doesn’t seem fun.

Day 26

The babies are starting to look like actual pigeons now. It wont be too long before they start stretching their wings.

Day 28

Bebe and Dreamliner are now stretching their wings and moving around a ton. They’re also starting to develop personalities.

The bigger one is Dreamliner. He’s always been the more dominant of the two, and his extra work at clawing food out of mom and dad is really starting to show.

Day 31

The balcony is starting to look a lot like a recycling bin. I’m constantly adding new layers of cardboard in an effort to prevent the floor from looking like a Jackson Pollock painting.

The pigeons may be going to town on the balcony, but they’re starting to look awfully mature. The yellow strands of hair that have been with them from the very beginning are nearly completely covered by feathers.

Day 32

The last full day of filming. The pigeons still have a ways to go, but they’re starting to get too big for the bulky timelapse setup to work properly. They’re also — understandably — quite afraid of the strange man that keeps fiddling around near them every day.

Day 35

The babies are nearly adult size by now. The parents have long given up the idea of sitting in the same tree. They tuck up a few feet away, out of sight of the babies so they can get some peace and quiet.

Day 41

The bi-hourly feeding cycle. Pigeon dentists must be awfully busy.

Day 42

Bebe cautiously checking his boundaries. As the pigeons grew bigger, they seemed to grow less afraid of my presence.

Day 44

The day before the first flight. Dreamliner (the one on the right) comes back once to tell us he’s all right, but then he’s off to live his own life. Bebe (on the left) and the parents still come back every once in a while, but the family seems to have found some other place to live their life. And that’s all right with me.

All in all, it was a pretty remarkable experience. Pigeons are actually fascinating animals, and watching the devotion to their kids made me appreciate what my parents did for me. They didn’t even have to throw up in my mouth.

My Front Row Seat to Pigeon Parenting was originally published in Jean-Marc’s Thoughts on Medium, where people are continuing the conversation by highlighting and responding to this story.

Wow, what a beautiful tool.

I wish I could bottle what it is I love about Dropbox Paper and carry it with me; that would be a hell of a formula.

A lot of it comes down to the typography; it’s a word editor, after all. Something about the type invites you to write; you want to fill the screen up with content just so you can see what it looks like.

How do they do it? Well, let’s start with the basic bits:

font-family: AtlasGrotesk-editor-rtl, AtlasGrotesk-editor, -apple-system, BlinkMacSystemFont, “Segoe UI”, Roboto, Oxygen, Ubuntu, Cantarell, “Open Sans”, “Helvetica Neue”, sans-serif;
font-size: 16px;
line-height: 26px;
color: #1b2733;

Atlas Grotesk is a beautiful font, and the off-black color and spacing give make it feel airy and a little less serious.

What surprises me most are the little tweaks, like this one:

font-variant-ligatures: no-common-ligatures;

This rule was intentionally added, but the difference with it enabled is minute. I suspect a lot of the beauty comes from a series of minor changes. Changes such as smoothing:

-webkit-tap-highlight-color: rgba(0,0,0,0);
-webkit-font-smoothing: antialiased;

Some people really don’t like it when you override the font smoothing. I personally think it’s an improvement.

I’d be lying if I said it feels like a night and day difference, but it does feel better when set to antialiased.

The whole design is sprinkled with small touches like this. Every piece of the tool feels like it had a lot of thought and care put into it.

My biggest takeaway? Minor tweaks add up.

How does Dropbox Paper have such pretty text? was originally published in Jean-Marc’s Thoughts on Medium, where people are continuing the conversation by highlighting and responding to this story.

It can always be a little annoying getting a fresh new work environment running. This guide is my attempt to keep track of how to get running as quickly as possible.

We’ll be using Vagrant, so these instructions should work with pretty much every development environment out there. I’m running this on a PC at the moment, but the same guide should work with Mac or Linux environments as well.

1. Setting up Vagrant

Start by downloading and installing the latest version of Vagrant. Installation should be pretty straightforward, and at the end you should have access to the vagrant command from the CLI.

The default approach is to initialize a bare-bones version of ubuntu and to build it up from there. The way to do this as of now is with the following two commands:

$ vagrant init hashicorp/precise64
$ vagrant up

We’ll be doing things a little differently because of Postgres. While it would be totally doable to install Postgres manually after initializing a barebones version of Ubuntu, the following configuration speeds things up considerably

# Clone the repository:
$ git clone https://github.com/jackdb/pg-app-dev-vm myapp

# Remove the .git, README, and LICENSE files:
$ cd myapp
$ rm -rf .git README.md LICENSE
$ vagrant up

You’ll likely want to make a few tweaks to the provided Vagrantfile after everything is set up. After calling…

$ vagrant halt

… I went ahead and changed the following two lines

# Disable original shared folder 
# config.vm.share_folder "bootstrap", "/mnt/bootstrap", ".", :create => true

# Set up new share, mapping vagrant folder to ~ within environment
config.vm.share_folder "home", "/home/vagrant", ".", :create => true

# Disable PostgreSQL Server port forwarding
# config.vm.forward_port 5432, 15432

# Enable web server port forwarding
config.vm.forward_port 8000, 8000

2. Setting up Postgres

Now that Postgres is set up, let’s go about creating a new database and account for it:

$ sudo su - postgres
$ psql
# CREATE USER app_local WITH PASSWORD 'app_local';
# CREATE DATABASE db_local;
# GRANT ALL PRIVILEGES ON DATABASE db_local TO app_local;

3. Setting up the Python environment

The next step is to install Virtualenv, which simplifies the process of managing Python libraries significantly. Start by installing the required packages

sudo apt-get install python-pip python-dev build-essential

Once this is in place, we can go about installing virtualenv

sudo pip install virtualenv virtualenvwrapper

We should update pip to the latest version prior to setting up our virtualenv environment

sudo pip install --upgrade pip

In order to use virtualenvwrapper, we need to modify our bashrc file. Make sure to keep a copy in case anything goes wrong:

printf '\n%s\n%s\n%s' '# virtualenv' 'export WORKON_HOME=~/virtualenvs' \
'source /usr/local/bin/virtualenvwrapper.sh' >> ~/.bashrc
source ~/.bashrc
mkdir -p $WORKON_HOME

Now we can set up our virtualenv:

mkvirtualenv venv --always-copy
workon venv

The — always-copy flag solves an issue with vagrant.

4. Final Steps

You’re pretty much good to go at this point. I went ahead and cloned my project into the home directory (which should be whatever folder you set up the Vagrant environment in). I then ran a pip install -r requirements.txt command from within the virtual environment.

I had to install a few dependencies before I could get a successful pip install, namely because of my postgres connection library. These package got everything working:

sudo apt-get install libpq-dev libncurses5-dev

My particular build also called for a redis server, which I was able to set up in one line:

sudo apt-get install redis-server

To keep things as simple as possible, I keep all my development environment variables in my ~/.bashrc file. This has obvious limitations, but because I am devoting this entire Vagrant environment to one project it shouldn’t cause any issues for me. Here’s what the tail end of my .bashrc file looks like:

workon venv
export DATABASE_URL=postgres://app_local:app_local@localhost/db_local
export REDIS_URL=redis://127.0.0.1:6379/0
export DEBUG=True

I tend to use Heroku Local or Foreman to handle environment variables when I’m doing anything more complicated.

If you’re dealing with any `npm` packages, you may need to run some extra steps. The version of node that comes with Ubuntu 12.04 is very outdated, so the first step is updating to a stable new version of node.

sudo apt-get purge nodejs npm
curl -sL https://deb.nodesource.com/setup_4.x | sudo bash -

If you’re installing node modules into a shared vagrant folder, you will likely run into the same issue as seen with the virtualenv install. To solve this, make sure to use the --no-bin-link argument

npm install — no-bin-link

Conclusion

That was pretty easy! As you can see, it should take less than an hour to get a complete end-to-end environment set up.

I’d like to thank Exponential.io and Postgres for their helpful guides.

Setting up a Python and Postgres development environment using Vagrant was originally published in Jean-Marc’s Thoughts on Medium, where people are continuing the conversation by highlighting and responding to this story.

If you’re like me, you’ve probably mainly thought about building websites in English. This has been my de-facto approach until recently, when I started travelling the world. I suddenly realized that the world doesn’t just operate in English. It’s not even an especially popular language:

If you only offer your content in English, you risk never being seen by the vast majority of the world. Even if the majority of a foreign country speaks good English — as is the case in the case of Barcelona, where I am currently writing this — it’s likely that Google will prioritize you way below local language websites. My employer — Sokanu — publishes incredible career guides for people looking to find a new career, and yet our pages don’t even show up in Spain despite ranking highly in North America.

This is all well and good, but translations aren’t free. There’s a huge cost behind getting your content into different languages (although Duolingo is trying to change that). Thankfully, technology is coming to the rescue. Google Translate has made huge strides over the past year, and is getting better all the time. Thanks to public APIs, content can now be automatically translated across dozens of languages as soon as it is created. This isn’t ideal, of course, but it serves as a great first step. Once a baseline is established, it’s far easier to go in and manually translate content in order of priority.

I’ll be spending the next couple of days putting this idea into practice, and I’ll try blogging about the process.

So, what’s unique about me?

I could write about my weird fascination with fountain pens. About falling asleep to chess. About my theory that falling asleep to chess would make me a better chess player, and my disappointment when I realized it didn’t.

I could write about my background with computers. About the person who taught me how to write my first program. About being a nerd in university. About getting my first job. About watching a startup grow. About switching from full-time to freelance, and then back to full-time again.

I could write about the way I’ve decided to interact with people. About finding mutually-beneficial arrangements. About getting the things you want to have without being a dick.

I could write about my hobbies. Write about photography. Write about going on hikes. About skiing. About joining the ski patrol. About experiencing the first major accident. About how the second was different.

I could write about my life. About living out of a backpack. About travelling alone. About projects I’m working on and trips I’m undertaking. About discovering that I’m a morning person, and how that is changing my life. About my favorite place on the planet. About the move from Toronto to Vancouver. About my biggest mistakes so far, and my best accomplishments. About stories that really stick with me.

I guess we’re all pretty unique.