Qwerty is the default keyboard layout for most, if not all computers.* It's what is taught in schools, in the workplace and what every computer user knows. But... why Qwerty?

A brief history of the typing machine

It all started in 1829...

Sort of. The United States Patent Office lists William Austin Burt's Typographer as

the actual construction of a type writing machine for the first time in any country

which probably means

Mr. Burt paid us money to say he invented the typewriter even though some dudes in Europe made one first

or something like that but whatever**. What he invented (and got a patent for) was this:

Yes, this god-awful looking pinball wannabe*** was the first typing device. It wasn't even a typewriter in the sense that you could "type" on it. It was operated by turning a crank until the desired letter came up and then pulling a lever to imprint it onto the page. It was actually slower than handwriting the message. But back then it was technology, damnit, and complicated, slow, ridiculous processes are what nerds like us live for.

1829 - 1864

Some people invented some new versions of the typographer, all of them sucked and none are worth talking about.

All hail the Writing Ball

In 1865 a man by the name of Rasmus Malling-Hansen invented the Hansen Writing Ball. This is the first device that actually increased typing speed and, you know, actually made sense to use.

It was also the first commercially produced typewriter, though it never actually took off. The keys were aligned on a brass hemisphere and they were pushed through the ball directly onto the paper which printed the letter. The paper was attached to a cylinder that spun as you typed.

Hansen produced numerous protoypes of his machine out of porcelain to experiment with the location and arrangement of the keys. He ended up placing the most frequently used letters near the fastest writing fingers, and aligned most of the vowels on the left and consonants on the right. It was said that with this configuration and enough practice you could write up to five times that of ordinary writing. You can see a computer rendering of the functionality here:

The Hansen Writing Ball sucks, all hail the Remington No. 1

3 years after Malling-Hansen invented his Writing Ball, a man named Christopher Latham Sholes, along with help from Carlos Glidden and Sam Soule, invented the typewriter in similar fashion to what we know them as today. This machine had a lot of different inventors, constructors and funders, and suffice it to say, the story of it's invention is complicated, with a lot of ins and a lot of outs. It went something like this:

1866 - Creation

Sholes, who was a printer, began creating a machine that printed page numbers in books. He began designing the machine with the help of Sam Soule in a factory in Wisconsin. They met Carlos Glidden, and when he saw what they were working on he said (I'm paraphrasing here) "Well, so, you can print numbers, so, like, why not just add some letters." My assumption here is that Sholes and Soule probably stood there for a minute with blank expressions on their faces, both feeling like idiots. But again, that's just an assumption.

They took Glidden's idea and ran with it and began creating prototypes of alphabet writing machine. The first prototype of the typewriter printed a single letter, 'W', the key for which was taken from a telegraph machine. Sufficiently satisfied that the 'W' printing machine was a success, they began working on a prototype with a full alphabet, and by the Fall of 1867 they had a working version of a typewriter.

They used this prototype to compose letters to friends, family and investors to help acquire funds to manufacture the device. How meta of them.

1868 - Patent and manufacturing

One of the men they sent a letter to was James Densmore, and he immediately purchased a 25% stake in the product having never seeing it in person nor knowing the total cost of his stake. When he did finally see the machine in 1868, he said (again, paraphrasing) "this thing sucks" and urged the 3 of them to iterate on the design.

Apparently Densmore hurt Soule and Glidden's feelings because they both left the project, leaving only Sholes and Densmore to perfect it.

Iterations and feedback

Densmore and Sholes iterated on the design, producing around 30 different variations. Most of these variations were attempts to reduce friction and increase speed. This was a huge concern of theirs because they assumed stenographers would be the main users of this machine.

They started sending prototypes out to stenographers, one of whom was named James Clephane. Clephane was very critical of the device and offered tons of feedback. Whether it was constructive or not depends on who you ask. Sholes was not a fan, and after hearing some of the criticism, he exclaimed

I am through with Clephane!

and got very angry. Densmore, however, was level headed, and saw the criticism as an important piece to a good product and told Sholes that

We had better have it now than after we begin manufacturing.

It was after Clephane's feedback that Sholes and Densmore decided to seek an expert mechanic to help them fine tune their design. They invited George Yost to their shop, and Yost thoroughly inspected the machine and offered several changes. After a few more iterations, Yost told Sholes and Densmore that they then needed precision manufacturing; he told them to take their machine to Eliphalet Remington & Sons.

Remington

Remington at that time was best known for manufacturing firearms. Their shop in New York had the best machines and equipment (well, as good as you could get in the late 1800's) and had the accuracy to manufacture parts within 1000th of an inch.

In early 1873 Sholes and Densmore took their machine to Remington and pitched it to the company. The Remingtons were so impressed with the machine that they bought the patent from Sholes and Densmore. Sholes took his money in a lump sum of $12,000****, whereas Densmore took a royalty; legend has it he made $1.5 million from it. Live and learn I guess.

Remington began manufacturing around September of 1873, and the typewriter went on sale July 1, 1874.

Remington No. 2

Remington iterated again and released an improved model, aptly named the Remington No. 2, in 1878. This machine was the first that had the ability to type upper and lowercase characters via a shift key.

QWERTY

Now seems like a good time to mention how QWERTY came to be. The original key layout that Sholes implemented was laid out like a piano, with 2 rows of keys:

 3 5 7 9 N O P Q R S T U V W X Y Z
2 4 6 8 . A B C D E F G H I J K L M

The numbers "0" and "1" were not included because "O" and "I" were deemed sufficient. Densmore suggested splitting up commonly used letters in order to improve typing speed and fix an issue they were having related to the keys jamming due to common letters being hit in succession. They iterated on the key layout and came up with the beginnings of what we now call the QWERTY layout:

  2 3 4 5 6 7 8 9 - 
   A E I . ? Y U O ,
B C D F G H J K L M
Z X W V T S R Q P N

After Remington purchased the manufacturing rights they further iterated on the design, and within a few months came up with the modern QWERTY layout. It is claimed that they finalized this layout due to the fact that you could type TYPE WRITER QUOTE from one keyboard row, which was apparently a sales pitch.

IBM

The typewriter, for the most part, stayed the same for the next 80 years or so until IBM introduced the IBM Selectric in 1961. It was an immediate hit, with total orders exceeding 80,000 by the end of the year.

The reason for the success was some smart innovation that drastically increased productivity:

At the physical heart of the Selectric typewriter’s innovation was a golf-ball-shaped type head that replaced the conventional typewriter’s basket of type bars. The design eliminated the bane of rapid typing: jammed type bars. And with no bars to jam, typists’ speed and productivity soared.

The Selectric was also modified to be one of the first keyboard interface devices to a computer. This modified version, named the IBM 2741 Terminal, plugged into the IBM System/360 and allowed much easier interaction with a computer by a much wider audience.

And that's how the keyboard was born.

The morale of this story is

we use qwerty because some dude back in the late 1800s thought it was cool that you could type TYPE WRITER QUOTE with one hand.

Notes

* Two big ones are Dvorak and Colemak, among others. ↰
** A man named Pellegrino Turri made one in Italy in 1808 which is why the patent is sort of lying. ↰
*** I imagine it with a Jurassic Park skin. ↰
**** Probably went straight to Vegas. ↰

References

[1] https://archive.org/details/leadingamericani00ilesrich/page/n375/mode/2up
[3] https://en.wikipedia.org/wiki/Christopher_Latham_Sholes
[4] https://en.wikipedia.org/wiki/QWERTY
[5] https://en.wikipedia.org/wiki/Typewriter
[6] https://www.ibm.com/ibm/history/ibm100/us/en/icons/selectric/
[7] https://en.wikipedia.org/wiki/IBM_2741
[8] https://books.google.com/books?id=WCuSUufRewoC&pg=PA222&dq=pellegrino+turri+typewriter&hl=en&sa=X&ei=84OvU4ztE8m-uATm5oCYDw&redir_esc=y#v=onepage&q=pellegrino turri typewriter&f=false

If you read my previous post, Introducing Shience: What it is and how to use it, you'll know that I was working on a C# port of Github's Scientist library.

It turns out Phil Haack of Github/Microsoft/Blogging fame is working on a port as well, which will become the official Github port once it's sufficiently implemented.

After some thought, and a brief discussion with Phil, I decided to deprecate my library and migrate my efforts over to Phil's Scientist.Net port. I didn't see a need to maintain two separate libraries that performed, for the most part, the exact same function.

So, if you're interested in performing science, or contributing to the effort, head over to https://github.com/Haacked/Scientist.net.

RIP Shience.

Shience is a .NET library for carefully refactoring critical paths. It is built on .NET Core, currently targets .NET 4.5.1 and DNX Core 5.0, and is available on Github and Nuget.

Keep in mind that it's early, and the API is subject to change.

What is a critical path?

A critical path is a section of code that is not only important, but critically important to the functionality of your application. Good examples are permission checking, transactions in bank software, or pull request merges at Github.

These sections of code are often the code that gets ignored. Not because they're not important, but rather that they're too important. If you're maintaining an application for bank transactions, you want to be absolutely sure the code that deducts money from an account calculates the deduction accurately and consistenly - no rounding errors, no overflows, no issues. The code is so critical that developers are often afraid to touch it. If no one touches it, no performance enhancements can be implemented and any previous technical debt will never be never paid off.

Why is Shience needed?

Development testing and QA are good first steps towards ensuring quality of your code, but as all developers know bugs can easily fall through. This is why unit tests are created.

And unit tests are great. They help drive the develoment process and find bugs, and help in refactorings, but they don't cover all test cases. They can't cover all test cases. And when refactoring critical code, you need to make sure there are no regressions. But how do you do that if you can't cover all test cases?

What if you could run the code side by side and compare the results? This is what Shience does, and it does it, in production, on real world data.

The Github post I linked above is a great case study on why this can be so helpful. They wanted to refactor pull request merges, but it is physically impossible to not only write enough tests to cover all cases, but test it on enough repositories to ensure no regressions were added. The ability to run both merges together, in production, on real repositories, on all requests allowed them to be 100% confident in their refactor. Which, on an application with millions of users, is a huge, huge deal.

How do I use it?

Grab the latest on Nuget, of course. The latest version is 0.0.1-beta5, but we are releasing rather quickly so by the time anyone reads this it might be out of date.

The readme has plenty of examples, but here's a quick starter.

var experiment = Science.New<bool>("my-test-code");
var result = experiment.Test(() => FirstMethod(),
                             () => SecondMethod())
                       .PublishTo((e) => Console.WriteLine(e.Matched))
                       .Execute();

Shience will run both the Test methods (the first is the control, the second is the candidate) in a random order. It will record the results in an ExperimentResult and provide that to you in the PublishTo method, and will then return the result of the control method.

When is 1.0?

I don't know, but we're moving fast. We should get to 1.0 by the time Episode 8 is out at least.

Let's Encrypt entered public beta recently. What is Let's Encrypt?

Let’s Encrypt is a free, automated, and open certificate authority (CA), run for the public’s benefit. Let’s Encrypt is a service provided by the Internet Security Research Group (ISRG).

So, basically, free https. Yay! 🙌

Here's how to set it up on Nginx.

Clone the repository

git clone https://github.com/letsencrypt/letsencrypt
cd letsencrypt

If you don't have git installed, get it using apt-get.

Obtain the certificate

Stop Nginx

sudo service nginx stop

Run the auto configuration manually

The auto configuration utility for Nginx isn't set up yet (but should be soon!) so you can't just run letsencrypt-auto, which is a bit of a bummer, but really the current steps aren't very hard. Run this:

./letsencrypt-auto --agree-dev-preview --server https://acme-v01.api.letsencrypt.org/directory auth

This starts the pretty interface that tells you to read the terms and other obligatory junk. Accept that and enter your domain(s) when it tells you to. Specify with and without www if you want to.

After completion, it will tell you where your certs are stored, which should be:

/etc/letsencrypt/live/www.yourdomain.com/

Within that directory should live some files, the 2 important ones being fullchain.pem and privkey.pem which will be used below.

Set up the certs in Nginx

Now edit your nginx config to tell it to use SSL and where the certs are. Your nginx config should either be in /etc/nginx/nginx.conf or in an external file in /etc/nginx/sites-enabled/. Mine was in sites-enabled in a file named ghost (e.g. /etc/nginx/sites-enabled/ghost).

Tell it to use port 443

Within the server block for your site, set it up to listen on port 443:

server {
    listen 443 default_server; #Used to be port 80
    listen [::]:443 default_server ipv6only=on;

    #other things
}

The ipv6 binding is optional.

Turn on SSL

Turn on SSL and tell it where your certs are located. Place this anywhere within the server block:

server {
    listen 443 default_server;
    listen [::]:443 default_server ipv6only=on;

    ssl on;
    ssl_certificate /etc/letsencrypt/live/www.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/www.yourdomain.com/privkey.pem;

    #other things
}

Set up a redirect from 80 to 443

This is optional (but totally recommended). Ensure that all users that navigate to http get thrown over to https. Set up another server block (outside of your site's server block) that listens on port 80 and redirects to 443:

server {
    #your existing server block stuff
}

server {
    listen 80;
    server_name yourdomain.com;

    location / {
        rewrite ^(.*)$ https://yourdomain.com$1 permanent;
    }
}

Save the file and exit.

Test the configuration

Unless you're 100% confident in your typing abilities (I never am) it's best to run the following command that tells Nginx to load the configuration and test it to ensure it's valid. If it's not, it will tell you why:

nginx -c /etc/nginx/nginx.conf -t

I had a missing ; so this saved me 37 seconds of trouble.

Restart Nginx

sudo service nginx start

Test your site

Navigate to https://yourdomain.com and enjoy your new security.

Questions?

Leave a comment!

Inspired by this post by Zach Holman, let's see what Windows 10 will allow us to use emoji for.

First... some history

Unicode

Most computer systems today (e.g. Windows, OSX, Android, iOS) use a thing called Unicode to represent text. Since computers work in binary, there needs to be a way to take a string of binary and convert it to letters and numbers to display on the screen. Unicode is one way to do that, and any system that uses Unicode knows that 01000001 is the capital letter A.

Emoji

An emoji is:

a small digital image or icon used to express an idea, emotion, etc., in electronic communication.

So basically these:

👔 💪 👶 🎅 💣 🍔 🚂 🎰

A few years ago some people were trying to send messages to each other and one of them was like (keep in mind I'm totally guessing here, but I'm 99% sure this is exactly how it happened)

Hey, I'm tired of typing lol. I wish I could send someone a picture of a laughing head

And so they came up with emoji. Then some more people* were like

We need to standardize this shit

and so they made a whole unicode character set just for emoji. And now anytime you're on Tinder and talking to a chick you can just send over the character U+1F4AA which is

💪

and she'll clearly be all over you because not only do you have ripped biceps but you also know how to make proper use of emoji and that's a major turn on.

Anyway...

Since all of these emoji are part of the Unicode standard it means that emoji is essentially text, and it can be typed into anywhere normal text can be typed into, which means we can now put them in lots of funny places.

The easiest way to enter emoji in Windows is to enable the Touch Keyboard. Alternatively, you could also copy the emoji text straight from the full emoji list straight from Unicode.org

Let's have some fun

Files

The NTFS file system that Windows uses stores file names in Unicode. That means we can save a file named the victory hand (✌️):

But file extensions are also unicode, so we can also save a file with 2 hands high fiving each other over the dot:

Shortcuts

Shortcuts to programs can also be emoji, so you can name your recycle bin the literal recycle symbol ♻️:

Or you can name it an octopus 🐙 which is fitting because those things are disgusting and should be thrown out.

Applications

I renamed my notepad++ app to 🍦. Now if it crashes I can yell "oh shit, my ice cream is melting!"

Start menu

You can also name a group on the start menu with emoji. I named my group "cool 💩":

User Accounts

Windows user accounts also accept emoji. Which means your account name can be the see no evil hear no evil speak no evil monkeys:

and every time you sign in you get to see your cute little monkeys:

Surprisingly, Windows couldn't care less that your account name is a picture of 3 monkeys. It even shows it as your home directory:

Passwords

You can also set your password using emoji. You can set it to something like this firework symbol so you can literally login with a bang:

But just like in OSX, it's almost impossible to enter emoji at the login screen so sadly you can't sign in with that password. My monkey account is now lost forever. 🙍

Time

You can change the time settings to use emoji. I set AM to show as 🍩 and PM to show as 🍻.

Now I'll always know whether it's socially acceptable to eat donuts or drink beer.

Computer Name

You can set your computer name using emoji. I set mine to a castle:

Now when you want to share things with your friends, you can proclaim "welcome to my kingdom":

You could also set up strict firewall rules and make moat jokes if you prefer. 🌊

💡

As you can see, Windows allows us to make use of emoji pretty much everywhere and it doesn't care. Have fun with this newfound knowledge.

* Those people were the Unicode Consortium. They decide what goes into Unicode, so thank them for all your emoji.

In MVC versions up to and include version 5, you could compile your Razor views by adding the <MvcBuildViews> attribute in the csproj file. But in ASP.NET 5 there is no more csproj file, so how we compile views for MVC 6?

Why?

If you've never compiled views and are wondering why you would, the reason is that it gets you compile-time checking. This means if you change your view model, you'll know if you broke the bindings in your view during compilation of your project. The alternative is waiting until run-time and until you view the page which could easily be overlooked. Sooner is always better.*

How?

The short answer is: Create a class that inherits from RazorPreCompileModule and place it in the {root}\compiler\preprocess** folder of your application.

namespace RazorPrecompileTest.compiler.preprocess
{
    public class RazorPreCompilation : RazorPreCompileModule
    {
    }
}

And that's it! Whenever you build your application your razor views will also be compiled and you'll get compile time checking on them. If you want to know how it works, read on...

So... how does it work?

RazorPreCompileModule

RazorPreCompileModule is an abstract class that implements the assembly neutral interface ICompileModule.

public abstract class RazorPreCompileModule : ICompileModule 

ICompileModule

public interface ICompileModule
{
    void BeforeCompile(BeforeCompileContext context);
    void AfterCompile(AfterCompileContext context);
}

ICompileModule is an interface that "allows plugging into the compilation pipeline". During compilation of your project, dnx will use Roslyn to build up an in memory assembly appended with !preprocess with the same references as your project. It will use that to look for any and all classes that implement ICompileModule and will run the BeforeCompile and AfterCompile methods for each class, before and after compilation, respectively.

*Well, most of the time

**It must be put in that directory!

Entity Framework 7 includes a new InMemory store which is fantastic for unit testing. No more mocking DbContext or doing other dumb things!

Here's how

Start by creating a new class library project using the Class Library (package) template:

Next, add the appropriate Entity Framework dependencies to your project.json:

"dependencies": {
    "EntityFramework.Core": "7.0.0-beta7",
    "EntityFramework.Commands": "7.0.0-beta7",
    "EntityFramework.InMemory": "7.0.0-beta7"
},

and dependencies to the latest xUnit runner:

"xunit": "2.1.0-rc2-build3176",
"xunit.runner.dnx": "2.1.0-beta5-build169"

and finally, add a command to your project.json for the xUnit runner:

"commands": {
    "test": "xunit.runner.dnx"
}

Because we're awesome (seriously, don't do this in a real app, I'm just doing it here because it's easy) we're going to create a DbContext inside of this test project with a Foo entity:

public class MyContext : DbContext
{
    public MyContext()
    {
    }

    public MyContext(DbContextOptions options) : base(options)
    {            
    }

    public DbSet<Foo> Foos { get; set; }
}

public class Foo
{
    public int Id { get; set; }
    public string Name { get; set; }
}

Now create a test class:

public class MyTestClass
{
    private readonly MyContext _context;

    [Fact]
    public void FoosIsEmpty()
    {
        var foos = _context.Foos;

        Assert.Empty(foos);
    }
}

In order to set up entity framework for each test, we're going to make use of the fact that xUnit creates a new instance of a test class for each test run. This means we can use the constructor to get a clean MyContext for every single test.

public class MyTestClass
{
    public MyTestClass()
    {
        var db = new DbContextOptionsBuilder();
         db.UseInMemoryDatabase();
        _context = new MyContext(db.Options);
    }
    
    //Tests
}

The UseInMemoryDatabase call is the fun part. EF will enforce all constraints and validations, however it won't persist anything to a real database and instead hold everything in memory. Which means it's fast and disposable.

You can also, if you're so inclined, set up a seed class to populate the in memory store with test data to use for each test. 👍

Update: The in memory store no longer supports constraints. (Embarrassingly, it didn't at time of this writing either, I was mistaken.) This is because constraints are solely a relational thing, and other types of stores don't enforce them. This is discussed in this Github issue, specifically this comment.

For most programmers, sleep is an afterthought. It gets in the way of coding. Of inspiration. Of progress. But sleep is an important part of your mental and physical health and is essential in keeping your body running smoothly.

Most programmers I know have some trouble sleeping, a disorder or otherwise. It stems from our obsessive nature and our drive to always be productive. We have to always be doing something. We have to finish that one last unit test. We have to finish that one last level in the new video game.*

Although it can be fun and can have a semblance of productivity, it's usually not effective, especially after doing it for a few days in a row.

We're not robots

No matter what we tell ourselves, we can't work effectively on little sleep. There have been numerous studies done on the effects of sleep deprivation on decision making, and a number of catastrophes have been attributed to lack of sleep, most alarmingly the Chernobyl disaster and the Challenger Accident. The National Center for Biotechnology Information published a manuscript reviewing the "role of human sleep and brain clocks (time-of-day variation in physiology and alertness) in the occurrence of medical and human error catastrophes". They found that sleep deprivation played a key role in the Challenger Accident:

...the recent report of the Presidential Commission on the Space Shuttle Challenger Accident did cite the contribution of human error and poor judgement related to sleep loss and shiftwork during the early morning hours. ... Certain key managers had obtained <2 h sleep the night before and had been on duty since 1:00 a.m. that morning. The report noted that "time pressure, particularly that caused by launch scrubs and turnarounds, increased the potential for sleep loss and judgment errors" and that working "excessive hours, while admirable, raises serious questions when it jeopardizes job performance, particularly when critical management decisions are at stake".

The Journal of Experimental Physchology: Applied backs this up in their article The impact of sleep deprivation on decision making: A review:

It is perhaps just a coincidence that some of the most renowned man-made disasters or near disasters concerning nuclear power plants, such as Chernobyl, Three Mile Island, Davis-Beese (Ohio), and Rancho Seco (Sacramento), all occurred in the early morning and involved human error in failing to contain otherwise controllable but unexpected and unusual mechanical or control room malfunctions. With all four, experienced control room managers misdiagnosed and failed to appreciate the extent of the fault and then embarked on courses of action that were inappropriate and continued to persevere in this way in spite of clear indications that their original assessment was wrong. Of course, it is difficult to say how much of this could have been due to SD effects on decision making and not to stress and panic. However, SD certainly played a crucial role in the fateful dawn decision to launch the Space Shuttle Challenger.

What can we do about it

So, sleep is important. Great. But how do you ensure you get enough sleep? Here are a few tips:

Stick to a sleep schedule

I think this is the single most important thing you can do to ensure quality sleep which is why I listed it first. Pick a bed time and a wake up time and stick to them as closely as you can. This helps regulate your body's internal clock (your Circadian rythym), which will help you fall asleep each night and wake up easier each morning.

Of course, life will get in the way of this sometimes, and you shouldn't tell your friends you can't grab a drink because it will throw off your circadian rythym. They'll probably look at you like you're standing on the corner of Senile Old Man St. and Crazy Lady Way. But try to avoid breaking the schedule continuously. Try to at least stick to your schedule on weekdays, which shouldn't be too hard, because, well, you have a job, right?

Shut off your electronic devices

Screens are bright and mimic daylight, and they cause our body to think we're not ready for bed. Sleep.org says using certain technology is bad immediately before bed:

Reading a work email at 9:30pm can keep you up with stress, the blue light from the screens mimics daylight and stimulates you, and you can wake up feeling tired, anxious, and depressed. That’s why you should power down devices at least 30 minutes before bedtime.

Reading email on a smartphone, watching TV or watching a movie on a tablet all stimulate us and can make it harder to fall asleep. Sleep.org recommends not using any sort of technology 30 minutes before bed, and instead to read a magazine or book. If you don't like paper copies of things, reading a book on a tablet is okay (make sure you set it to white on black instead of black on white to limit the brightness), reading on a Kindle E-Ink reader would be better.

Get exercise

It's rather common knowledge that indoor enthusiasts such as ourselves don't get enough exercise. We're not the most coordinated bunch, and a lot of times the sun burns. Exercise is another crucial component to sleep, though. As little as 10 minutes of exercise per day can improve sleep, because it reduces stress and tires you out.

Besides, exercise isn't just important to sleep, it's incredibly important in overall health for many reasons. It's imperative we all get up, start moving and keep moving.

Eat more healthily

Researchers from the Perelman School of Medicine at the University of Pennsylvania looked at how diet affects sleep and they found there is a correlation between length of sleep, calories consumed and variety in your diet. Those that slept a "normal" amount of time, defined as 7-8 hours, consumed an average number of calories. But more importantly they ate a large variety of foods:

Normal sleepers, however, showed the highest food variety in their diets, and very short sleepers had the least variation in what they ate. A varied diet tends to be a marker for good health since it includes multiple sources of nutrients.

Make sure you eat a well balanced diet, that includes some grains, some meat, and some fruits and veggies.

And make sure you lay off the Funyuns.

Have children

I'm only half joking with this one. It's well known by everyone that a newborn actually causes less sleep (I have 2 children, it's definitely true), however once they get to be 6 months or so (a year if you're unlucky) they'll start sleeping better. And what happens is they become a natural alarm - children have this incredible knack for waking up at the same time each morning, regardless of when they went to bed. So, if they always get up at 6:30am, and you, in turn, then always get up at 6:30am, then all you need to do is figure out your bed time and bam, you have your sleep schedule.

Take a sleep aid

This is something I would recommend avoiding because sleeping pills can cause drowsiness, rebound insomnia, dependency and abuse. However some people truly have insomnia and need help sleeping. If this is you, you can talk to your doctor about sleeping pills, or get an OTC aid like ZzzQuil, or get a sleep supplement such as melatonin.

So put down the keyboard and sleep

Rest your eyes, rest your body, rest your mind. You need to recharge yourself, and there's no better way to do that than sleep.

* A friend and I once tried to beat Halo on Legendary in one sitting. It took 16 hours with a few quick pee and food breaks. We finally finished at 6AM and subsequently passed out for the next 10 hours.

The term swiss army knife is thrown around a lot when discussing the SOLID principles. Dave, that class looks like a swiss army knife. We need to refactor that shit. Yeah. Whatever. You know what, how about we see how a real swiss army knife stands up against the SOLID principles, huh?! Then we'll see who needs refactoring.

Single Responsibility Principle

The Single Responsibility Principle states:

Every object should have a single responsibility, i.e. a single reason to change

When looked at in terms of software, this means that a class should only do one thing - log errors, or send email, or determine if a person's name is funny. A class that finds any irreverence in a person's name should not be worried about sending email - it should delegate that off to an email service, which will email anyone who thinks that the name Wang Liqin is funny.*

But what about the swiss army knife? Let's count it's responsibilities:

• Knife
• Flat head screwdriver
• Philips head screwdriver
• Can opener
• Nail filer
• Bottle opener**
• Scissors
• A relatively hefty item that can be used as a projectile

Look at all of those responsibilities! A screwdriver and scissors in one device?? Madness. The swiss army knife clearly violates the SRP.

Principles	Swiss Army Knife
SRP
OCP
LSP
ISP
DIP

Open-Closed Principle

The Open-Closed Principle states:

Objects should be open for extension, but closed for modification

In OOP, once a class is finalized it should not be changed (except for bug fixes, of course). The reason behind this is to ensure that existing functionality does not break when maintaining/adding to the codebase. Further functionality should be implemented using inheritance.

Let's apply the OCP to a Swiss Army Knife.

Closed for modification

There are no visible ways to open or take apart a swiss army knife. There are no screws or notches to pop open the case. It's definitely closed for modification. (Unless you hit it with a rock, but I think that's circumventing the rules.)

Open for extension

Well, we determined that there are no screws or any way visible to take apart a swiss army knife. There are no ports or cables either. But there is often a keyring on it, so you can, like, hang a spatula from it? Sure.

Principles	Swiss Army Knife
SRP
OCP
LSP
ISP
DIP

Liskov-Substitution Principle

The Liskov-Substitution Principle states:

You should be able to use any derived class in place of a parent class and it should behave in the same manner with no modification.

In software, this means there should be no custom code required when using a child class in place of the parent class.

Does the swiss army knife violate the LSP? Well, if we think of the swiss army knife as the child, it would have parents of a knife, a pair of scissors, a screwdriver, etc. You can use the swiss army knife in place of each of the parents with no modification. It might just take you a bit longer to slice that turkey with your 3 inch blade.

Principles	Swiss Army Knife
SRP
OCP
LSP
ISP
DIP

Interface Segregation Principle

The Interface Segregation Principle states:

Clients should not be forced to depend on interfaces they do not use

If you create an interface, the interface should have clearly defined functionality, and any classes implementing that interface should implement all properties/methods without any NotImplementedExceptions or fake return values. The goal is to get rid of monster interfaces and create interfaces with directly related functionality.

The swiss army knife does not implement any interfaces (it's a freakin knife, yoh).

Principles	Swiss Army Knife
SRP
OCP
LSP
ISP
DIP

Dependency Inversion Principle

The Dependency Inversion Principle states:

Classes should depend on abstractions for their dependencies

Common terms used when discussing the DIP are Dependency Injection and Inversion of Control. Basically, they say that classes should rely on interfaces or abstract classes for any outside dependencies they need, and not instantiate concrete objects themselves.

What dependencies does a swiss army knife have? Well, two main ones are an operator and a sharpener.

It definitely does not instantiate it's own operator, and it definitely relies on abstractions because it doesn't care of a person or a dog or a tree is using it. It also doesn't care if it's being sharpened with a $1,000 wet stone or on a rock you grabbed out of the river.

Principles	Swiss Army Knife
SRP
OCP
LSP
ISP
DIP

Conclusion

The swiss army knife did pretty well, scoring a 3/5. Think twice before calling my classes swiss army knifes, because I call that a passing grade.

* Which should be everyone.

** The most important, if you ask me.

HTML, by it's design, is incredibly liberal in what it accepts. Which is kind of cool, but sometimes it's definitely not and it bites you. And it can bite you in many ways, including the character encoding used on a page. (I.e. ascii vs unicode vs whatever. Read this if you want to learn more (and you should)).

There are a few ways to declare the encoding of a web page, as specified by the w3c:

To sum up, conforming user agents must observe the following priorities when determining a document's character encoding (from highest priority to lowest):

1. An HTTP "charset" parameter in a "Content-Type" field.

2. A META declaration with "http-equiv" set to "Content-Type" and a value set for "charset".
3. The charset attribute set on an element that designates an external resource.

In addition to this list of priorities, the user agent may use heuristics and user settings. For example, many user agents use a heuristic to distinguish the various encodings used for Japanese text. Also, user agents typically have a user-definable, local default character encoding which they apply in the absence of other indicators.

That last paragraph is the fun part. If no encoding is specified in any of the 3 ways listed, the user agent (Chrome, IE, etc) can attempt to figure it out itself.

Wait, so how can this bite you?

I ran into an interesting situation earlier. Powershell uses UTF-16 internally (it's based on .NET, you know, and .NET uses UTF-16 on its strings), and when you pipe output to a file, it defaults to that encoding:

"<html><body><div>Here's a div</div></body></html>" > index.html #I'm UTF-16!

Hey look, we created a webpage. When opening that file in the browser, the browser doesn't see a charset header or a META declaration so it decides to determine the encoding itself and it figures out that, hey, this is utf-16. You can see this by opening the browser developer tools and running:

> document.characterSet
    "UTF-16LE"

Neat. And the page displays correctly and all is well.

But let's say we want to add an external script because we like javascript and we're good programmers, damnit, so we separate our concerns and don't add inline scripts. So we edit our index.html file and add a script tag, specifically getting RequireJS from a CDN:

<html>
<head>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.1.16/require.min.js"></script>
</head>
<body>
    <div>
        Here's a div
    </div>
</body>
</html>

And now we have RequireJs! Wait. What? We don't?

If you open the index file now, you'll see Here's a div but if you open the dev tools, you'll get a

Uncaught SyntaxError: Unexpected token ILLEGAL

error. And if you open the requireJs file, you'll see a bunch of chinese characters.

Whyyyyyyyy

The RequireJs file, from the CDN, is encoded in windows-1252. But since we didn't specify a charset for the script file, the browser assumed it was the same as the html file, and brought it in as UTF-16. It interpreted all of the bytes as UTF-16 and you get all of those crazy characters. Specifying a charset fixes the problem, because the browser knows how to interpret the incoming file:

<script charset="windows-1252" src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.1.16/require.min.js"></script>

Do I care?

In most cases, this won't be a problem. Most everywhere uses UTF-8 now, and in the HTML5 spec, the w3c says:

Authors should use UTF-8.

Authoring tools should default to using UTF-8 for newly-created documents.

In other cases (which should be few and far between) set a charset and be on your way.

I just migrated from Wordpress to Ghost, for probably the same reason as most people - I got tired of the mass of crazy that Wordpress has become. I just want to write shit, and Wordpress was almost getting in the way of that.

The migration process was ridiculously easy thanks to both Ghost and Digital Ocean - I clicked a few buttons, waited 50 seconds and had a new Ghost installation. I exported my posts from Wordpress, imported them into Ghost and, boom, done.

Well, basically.

Those dang slugs

Wordpress, by default, sets up URLs in the form of http://yourblog.com/yyyy/MM/dd/kinda-nice-post-title. Ghost, by default, uses the form http://yourblog.com/kinda-nice-post-title. I like the Ghost way better, but that meant all links to my posts would be broken.

Let's write some rewrites

The best way to get around this is to set up 301 redirects , so that not only do the old links automatically get redirected to the new links, search engines like Google know it's a permanent redirect and therefore forget the old url and use the new one.

Most instances of Ghost are running under nginx, which is an open source web host, and it has a rewrite module (ngx_http_rewrite_module) installed by default that helps us here.

Configuration files

Nginx uses json formatted .conf files for it's configuration settings. There are 2 files we're going to look at: nginx.conf and [your site name] The main file is nginx.conf and it lives in /etc/nginx/. That file has a bunch of settings that apply to all sites. The [your site name] file has settings that apply to only your site, and it lives in /etc/nginx/sites-enabled/*. The nginx.conf file includes this line:

include /etc/nginx/sites-enabled/*;

that imports the site settings into the main file.

We'll be editing the [your site name] file, since these rewrites will probably only apply to your site. From here on out, I'll use ghost instead of [your site name] since that's what my site is called.

(Ir)Regular expressions

The rewrite module uses regular expressions to match urls, and we'll use one that matches /yyyy/MM/dd/pretty-url and rewrite it to only /pretty-url. The regex is:

\d{4}/\d{2}/\d{2}/(.*)$

This basically says "if the url starts with 4 digits, and then has a slash and 2 digits, and then has another slash and 2 other digits, grab everything after that."

To apply this, edit your site configuration file using vim:

vim /etc/nginx/sites-enabled/ghost

You'll see a server node, and inside of that a location node. In the location node, add the following rule:

rewrite "\d{4}/\d{2}/\d{2}/(.*)$" /$1 permanent;

So your file should look something like this:

server {
    #some stuff
    location / {
        #some stuff
        rewrite "\d{4}/\d{2}/\d{2}/(.*)$" /$1 permanent;
    }
}

That says "if the url matches this regular expression, rewrite the last bit (the (.*)$) as just /$1, where $1 is the capturing group. And do it permanently, as a 301 redirect.

Save the file, and restart nginx:

sudo service nginx restart

Now hit an old url and watch the magic happen.

* Kind of. It actually lives in /etc/nginx/sites-available and is symbolically linked to sites-enabled.