Author Archives: shane

Deconstructing Records

Deconstruction let us focus on the values we want to match in our patterns. We’ve shown we can deconstruct tuples, but what about records? Absolutely.

A record is a data structure with named values. Records are immutable by default. We use records in exchange of tuples. Records give better context to what data is being represented. We’ll use the Astronaut record defined below as our data representation.

type Astronaut = { Name : string; Year : int }

Suppose we want to print an appropriate message based on the astronaut’s name. We’ll do a simple greeting for all astronauts except for “Dave” and “Neil”. We can create our function with a pattern match as below.

let greeting astronaut = 
    match astronaut with
    | {Name = "Dave"} -> "I'm sorry Dave, I'm afraid I can't do that."
    | {Name = "Neil"} -> "The first person to set foot on the moon."
    | {Name = name}   -> sprintf "Hello %s." name

If you look at the patterns in the match you will note we are deconstructing the Name value from the astronaut argument. Someone reading the code can easily see we are interested in the astronaut’s name.

We could be even more specific with matching on our Astronauts by using patterns below:

let greeting astronaut = 
    match astronaut with 
    | {Name = "Dave"; Year = 2001 } 
         -> "I'm sorry Dave, I'm afraid I can't do that."
    | {Name = "Neil"}               
         -> "The first person to set foot on the moon."
    | {Name = name}                 
         -> sprintf "Hello %s." name

We’ve gone further in isolating the values we want for our patterns. The more values you add the more specific your patterns become. In the example above we have a case using the Name and Year deconstructed from the astronaut to get Hal’s response to Dave. All other astronauts named Dave will get the standard greeting.

Deconstruct OR what…

Let’s go back to matching on name only. What if our name isn’t proper case? What if Dave is actually a “dave” or “DAVE”? We may still want to match on those “Dave”s. Here is where some of the power of F#’s pattern matching starts to shine. We can write our pattern to include those other “Dave”s by combining deconstruction and the OR Pattern.

let greeting astronaut = 
    match astronaut with
    | {Name = "Dave" | "dave" | "DAVE"} 
        -> "I'm sorry Dave, I'm afraid I can't do that."
    | {Name = "Neil"} 
        -> "The first person to set foot on the moon."
    | {Name = name}   
        -> sprintf "Hello %s." name

We’ve certainly improved our pattern to include more cases of “Dave”. We can take our pattern one step further and make our patterns case insensitive. The first way will be more familiar for OOP developers. We can use the property accessor to get the Name to then lower and use the property again to print the name. The other way would be to use a pattern match in the function signature. We can do pattern matching and deconstructing in the function arguments.

let greeting astronaut = 
    match astronaut.Name.ToLower() with
    | "dave" 
        -> "I'm sorry Dave, I'm afraid I can't do that." 
    | "neil" 
        -> "The first person to set foot on the moon."
    | _      
        -> sprintf "Hello %s." astronaut.Name


let greeting' {Name=name} = 
    match name.ToLower() with
    | "dave" 
        -> "I'm sorry Dave, I'm afraid I can't do that."
    | "neil" 
        -> "The first person to set foot on the moon."
    | _      
        -> sprintf "Hello %s." name

It’s not overly common to use deconstruction in the function signature. It can lead to some ambiguity in the code. We are focusing on the values we care about, however the function signature may no longer have the same readability it did before with the astronaut value.

Summary

We’ve covered the ability to deconstruct records in our patterns. We aren’t limited to one value for deconstruction. We can match on any number of values in a record, and the number of values can vary between patterns. F# is not limited to only deconstruct records in the match with construct. Matching can be used by the function construct and in the declaration of function arguments. We can also combine deconstruction with OR to reduce the number of patterns and improve readability. It’s the ability to combine patterns which let’s the power of F# shine its expressiveness.

Beyond Constant Pattern Matching

Pattern matching is a vital aspect of functional programming. It can make our code more expressive by eliminating noise. We’ll look into a few more patterns that give us the power and flexibility to create readable match expressions.

OR Pattern

The OR pattern is used to group multiple patterns which return the same result. This can be considered a short hand for multiple patterns. A simple match expression verifying a number is below 10 and prime can be written multiple ways.

// Return value for each number
let isPrimeBelow10 = match number with
                     | 2 -> true
                     | 3 -> true
                     | 5 -> true
                     | 7 -> true
                     | _ -> false

// Using the OR pattern
let isPrimeBelow10 = match number with
                     | 2 | 3 | 5 | 7 -> true
                     | _             -> false

The second version of isPrimeBelow10 is easier to reason about as it declares the patterns 2, 3, 5, and 7 are grouped to the same result. The noise of all the extra -> true has been removed. This gives the reader a visual cue about the relationships of the patterns as well as reduces duplicate code.

Guards

Guards are used to match on patterns that require more than a constant. We use the when keyword followed by an expression which evaluates to a boolean. If the guard expression evaluates to true then that pattern matches. Let’s say we want to classify a value as normal if it is within 100 to 200. That would take a lot of patterns if we used the OR pattern exclusively. It also doesn’t solve the situation if we wanted to indicate whether the value was high or low. We can use guards to accomplish our task.

let withinNormals number = match number with
                           | x when x > 200 -> High
                           | x when x < 100 -> Low
                           | _              -> Normal

We have three patterns with two of them using guards. The first pattern binds number to the label x and evaluates x > 200. If it evaluates to true, the match returns High. The second pattern does something similar, with the exception of evaluating x < 100. The final pattern is a wildcard which returns if the previous patterns are not matched.

Guards allow us to do more than just match on constants. We can expand our withinNormals to be more reusable.

let withinNormals (lowLimit, highLimit) number = 
    match number with
    | x when x > highLimit -> High
    | x when x < lowLimit  -> Low
    | _                    -> Normal

We have the same three patterns but this time we are using the arguments passed in determine the lower and upper limit. Guards let us do more than match on constant values, they give us the flexibility to create reusable patterns.

Deconstruct

Deconstruction allow the pattern to focus on what is being pattern matched. We left off Pattern Matching with Constants with a pattern matched version of Fizz Buzz. Here is the implementation again.

let printFizzBuzz number = match (number % 3, number % 5) with
                           | (0, 0) -> printfn "FizzBuzz"
                           | (0, _) -> printfn "Fizz"
                           | (_, 0) -> printfn "Buzz"
                           | _      -> printfn "%d" number

The printFizzBuzz function takes a number and creates a tuple of the results of number modulus 3 and 5. Our patterns deconstruct the tuple and match those results with constants.

We can even completely ignore values from deconstructed objects. Here we only care about the third value in the tuple. We are using the patterns to deconstruct the tuple while ignoring the first two values in the tuple. Our patterns are only focused on the values important to it.

match tupleOf3 with
| (_,_,0)            -> "0"
| (_,_,1)            -> "1"
| (_,_,x) when x < 0 -> "Negative"
| _                  -> "Larger than 1"  

Summary

The OR pattern can be used to group patterns together which have the same return value. Redundant code can be eliminated with the use of the OR pattern. Guards give match expressions the ability to compare values in patterns and not restrict us to constants. Deconstruction let patterns focus on what is being matched instead of dealing with the whole object.

Pattern Matching with Constants

Pattern matching is a staple of any functional programming language. F# has a decent pattern matching system with 16 matching patterns out of the box. You also have the ability to extend the pattern matches by using Active Patterns. Let’s start with some common pattern matches for F#.

The basic syntax for pattern matching in F# is a match with expression. The with is then followed by a vertical bar and a pattern.

match item_to_be_matched with
| pattern -> result

This is a single case pattern match. It’s not used much at all. Generally pattern matches have multiple cases. Each pattern is separated by a vertical bar. You can think of the vertical bar as being “OR”.

match item_to_be_matched with
| pattern1 -> result1
| pattern2 -> result2
.
.
.
| patternN -> resultN

Constant Pattern

Using a constant pattern is very similar to a switch statement in C#. Any type that can be defined as a constant can be used in this type of pattern.

match number with
| 0 -> "Zero"
| 1 -> "One"
| 2 -> "Two"
match role with
| "administrator" -> Administrators
| "manger"        -> Managers
| "user"          -> Users

Exhaustive vs Incomplete Patterns

A pattern match is considered exhaustive when it accounts for every possible pattern. We don’t always have to use exhaustive patterns, however we do run the risk of receiving an exception if no match is found. If you are using an editor like Visual Studio or Visual Studio Code (with Ionide-Fsharp) you will get highlighting indicating a pattern may not be accounting for every possibility. It’s preferable to use exhaustive patterns to eliminate the possibility of a match failure exception.

Visual Studio Code with Ionide-Fsharp indicating an incomplete pattern.
VSCode with Ionide-FSharp - Incomplete Match

Wildcard Pattern

The wildcard pattern is used as a catch all pattern. This is denoted by an underscore or a generic label in the pattern. Use of an underscore informs the next developer the value is of no importance. The wildcard pattern is very much like the default clause of a switch statement in C#. This will take any incomplete pattern and make it exhaustive. We can make the isZero function exhaustive by adding the wildcard pattern.

let isZero number = match number with
                    | 0 -> true
                    | _ -> false
let greeting name = match name with
                    | "hal" -> printfn "I'm afraid I can't do that Dave"
                    | _     -> printfn "Hello %s" name

You do have to be careful when using the wildcard. If a business requirement changes and you forget to add the new pattern, the wildcard will happily swallow the match thus leaving you with some unintended results.

Summary

Pattern matching with constants is very similar to the C# switch construct. This is where the similarities end until C# 7. As I mentioned at the beginning of this post, F# has 16 different patterns. We’ll be getting into more of those patterns in future posts. Here is a FizzBuzz implementation using the constant pattern match with Tuple deconstruction. Exciting things are on the way.

let printFizzBuzz number = match (number % 3, number % 5) with
                           | (0, 0) -> printfn "FizzBuzz"
                           | (0, _) -> printfn "Fizz"
                           | (_, 0) -> printfn "Buzz"
                           | _      -> printfn "%d" number

F# Prototyping with Visual Studio Code

I’ve been using Visual Studio Code (VSCode) for the majority of my F# development since December 2016. I have to admit it has become my prototyping tool of choice. Visual Studio Code is a nice lightweight IDE, if you can call it an IDE. It’s more of a text editor with a great set of extensions. VSCode loads very quickly which makes it excellent for testing out those single shot ideas. VSCode is a cross platform editor which contributes to its ease of use. You get relatively the same feel on Windows, Mac OSx, or linux. Visual Studio Code, with a few extensions, has become my main editor for prototyping in F#.

If you haven’t looked at VSCode before, you can get it at https://code.visualstudio.com/.

The very first thing I do after installing VSCode is getting the Ionide-fsharp extension. You can install the extension by going to View -> Extensions in the menu. In the extensions window, enter ionide-fsharp in the search box. The extension should show in the results window with an install button.

Ionide-Fsharp will give you access to F# Interactive (F#’s REPL) from within VSCode. You also get a wide range of benefits such as syntax highlighting, codelens for function types, hover tooltips, and more. When it comes to prototyping though, having immediate feedback of a REPL is the best tool one could have.

I add some custom keybindings in VSCode for interacting with the REPL. My preferred shortcuts are as follows:

  • Ctrl+i – Starts / restarts the REPL
  • Ctrl+’ – Sends the current line from the editor to the REPL for evaluation
  • Ctrl+; – Sends the selection of code from the editor to the REPL

You can modify the keybindings by going into (Mac) Code -> Preferences -> Keyboard Shortcuts or (Windows) File -> Preferences -> Keyboard Shortcuts and adding the code snippet below:

    { "key": "ctrl+;",                "command": "fsi.SendSelection",
                                     "when": "editorTextFocus" },
    { "key": "ctrl+'",                "command": "fsi.SendLine",
                                     "when": "editorTextFocus" },
    { "key": "ctrl+i",                "command": "fsi.Start",
                                     "when": "editorTextFocus" }

Visual Studio Code and Ionide-Fsharp have truly changed how I prototype ideas. I can load the editor, start the REPL, and begin testing my ideas in mere seconds. This makes VSCode enjoyable and efficient for F# prototyping.

Currying and Applying Arguments

I gave a talk called Some(‘F#’) is Better Than None at Winnipeg Code Camp on January 28, 2017. The talk was catered toward developers who have never looked at F# or those who never considered F# as being a useful prototyping tool.

During the talk I made a brief mention to currying and partial application. After the talk I received a great question along the lines of: if every function only takes one argument, how is it we are able to pass multiple arguments to a function?

Currying

Currying is the process of transforming a function which takes multiple arguments into a sequence of functions where each new function takes only one argument. If we were to write the function:

let addThreeNumbers x y z = x + y + z

This function looks like it takes three arguments, however the signature of addThreeNumbers is converted to int -> int -> int -> int. We can read the function signature as: addThreeNumbers has type of int goes to int goes to int goes to int. The last type in the signature denotes the return type of the function.

Applying arguments

Using the addThreeNumbers function we defined earlier, we can call the function as:

addThreeNumbers 1 2 3

Since we are passing in the full number of arguments the function evaluates immediately giving us the result of 6.

As we are passing in arguments, the function applies what it can with the arguments given. Each time we add an argument it peels off the leading type ->, eventually reaching the point where there is nothing left to apply which then evaluates the result.

// int -> int -> int -> int
let addThreeNumbers x y z = x + y + z

let result = addThreeNumbers 1 2 3
// can be thought of as
let result' = (((addThreeNumbers 1) 2) 3)

// You can also apply the arguments in steps and create 
// intermediate functions.

// addTwoNumbersWith1 :: int -> int -> int
let addTwoNumbersWith1 = addThreeNumbers 1

// addOneNumberWith1and2 :: int -> int
let addOneNumberWith1and2 = addTwoNumbersWith1 2

// six :: int
let six = addOneNumberWith1and2 3

Currying and partial application are very powerful features. Currying is the process of transforming a function which takes multiple arguments into a sequence of functions which take one parameter. Applying arguments to a curried function peels off a function from the sequence. This allows you to build reusable functions.

Advent of Code 2016: Things I’ve Learned

I’ve been engaged in the Advent of Code 2016. Attempting to improve upon my solutions from 2015. I have improved a lot since last year. However, as of Day 8 there are some things that I have notably learned. Well, some things I’ve forgotten and learned again. Here are the highlights so far:

Seq.chunkBySize

This was added in F# 4.0. This function allows you to partition your collection into arrays of a size of your choosing.
For example:

[1 .. 6] |> Seq.chunkBySize 2;;  // seq [[|1; 2|]; [|3; 4|]; [|5; 6|]]
[1 .. 6] |> Seq.chunkBySize 3;;  // seq [[|1; 2; 3|]; [|4; 5; 6|]]

There is a caveat, if the number of items in the collection is not equally divisible by the chunk size, the last array will have fewer items.

[1 .. 6] |> Seq.chunkBySize 5;;  // seq [[|1; 2; 3; 4; 5|]; [|6|]]

Slicing

This one I seem to forget is available. I always start with a for or a skip |> take and then I remember. It can make your code a lot easier to read.

Spoilers for day 8

I am using a mutable 2D array for day 8. There was a similar problem last year and I chose to go fully immutable and got destroyed by Garbage Collection. Mutability we go! The problem called for shifting pixels (which wrap) on a display. I decided to get the current row of pixels starting at origin (I define the origin as being the length of the array minus the amount we are shifting). I then could apply the shifted row to the mutable 2D array.

My initial implementation:

member this.RotateRow (y,shift) =
  let origin = width - shift
  seq { for i in {origin .. width - 1} do
          yield display.[i, y]
        for i in {0 .. origin - 1} do
          yield display.[i, y] } 
  |> applyShift

It’s not terribly bad. We get the items from shift origin to the end of the array followed by items from the start of the array to origin. We can do better with slicing.

Slicing an array or list is a matter of using the indexer after the label.

let l1 = [1 .. 100];;
l1.[6 .. 10];; // [7; 8; 9; 10; 11]
l1.[7 .. 11];; 
l1.[.. 10];;   // [1; 2; 3; 4; 5; 6; 7; 8; 9; 10; 11]
l1.[95 ..];;   // [96; 97; 98; 99; 100]

Did you notice I said indexer? Yes, slice takes the items via their position in the collection. This is something you will need to be aware of. If you want the first ten items using slice you would use [..9], as the tenth item is in position nine.

Updating my original solution using slices instead of for constructs has made my solution more concise and readable.

member this.RotateRow (y,shift) =
  let origin = width - shift
  seq { yield display.[origin .., y]
        yield display.[.. origin - 1, y] } 
  |> applyShift

By using slices I removed the need to calculate the end of the array. This eliminated the chance of an off by one error. <insert bad off by 2 joke here>

Seq.windowed

Seq.windowed is handy when you need to look for specific patterns in a collection. This function works by taking a collection and creating a sliding window of arrays with the length you specify.

Some examples of course:

let l1 = [1 .. 5];;
l1 |> Seq.windowed 2;; // seq [[|1; 2|]; [|2; 3|]; [|3; 4|]; [|4; 5|]
l1 |> Seq.windowed 3;; // seq [[|1; 2; 3|]; [|2; 3; 4|]; [|3; 4; 5|]
l1 |> Seq.windowed 4;; // seq [[|1; 2; 3; 4|]; [|2; 3; 4; 5|]]
l1 |> Seq.windowed 6;; // seq [] 

If you try to get windows larger than the size of the collection, you end up with an empty collection.

Seq.chunkBySize, slicing, and Seq.windowed are my three most notable take aways from the first 8 days of Advent of Code 2016.

ASP.Net Encode Token

TL;DR – In ASP.Net MVC use the HttpServerUtility.UrlTokenEncode() and HttpServerUtility.UrlTokenDecode() for encoding and decoding tokens/keys with unprintable characters.

Every so often we use a throw away token for generating a link. An example of this would be a link to reset a password. You don’t want to send the password to your user in an email (you should never send a password to a user in an email). Instead, you create a link with a token they can click on to create a new password. Encoding the token is straight forward, however I always seem to forget the utility to use.

I always seem to go down this progression:

    • Base64 – Convert.ToBase64String()
      • Nope. This has issues with ?token= query params due to the potential `=` signs at the end.
    • Encoded using HttpUtility.UrlEncode()
      • Nope. UrlEncode does not handle unprintable characters, when you try to decode it you get the wrong results.
    • Encoded using HttpServerUtility.UrlTokenEncode()
      • YES. That’s the one we need.

Having to use the UrlTokenEncode has been fairly rare, which is why I can’t remember it immediately. The default IdentityProvider has the email reset feature built in with the encoding/decoding happening automatically. Knowing the UrlTokenEncode comes in handy when creating links for QR Codes or other purposes.

Setting up Gulp for compiling SASS in Visual Studio 2015

I’ve been meaning to use gulp for compiling sass files in Visual Studio for a while. Using gulp instead of a Visual Studio extension gives the advantage of not always having to be in visual studio. I’ve used gulp in other projects where it was already setup and working, but have never set it up myself. I figured it was time for that to change.

Step 1: Install nodejs if you haven’t already. This gives access to the Node Package Manager (NPM). You can download nodejs using the link below.
https://nodejs.org/en/download/

Step 2; Add the variable NODE_PATH with a value of %AppData%\npm\node_modules. If it’s already in your environment, then you don’t need to do anything. This will give you access to globally installed packages from the command line without having to type the full path.

Step 3: Install gulp using NPM. In a command window or PowerShell type the command below and press enter.
npm install -g gulp
NPM will start installing gulp globally for your system, as denoted by the -g flag.

Step 4: Start up Visual Studio 2015 and create a new project or open an existing project.

Step 5: Add two new files in Visual Studio called “NPM Configuration File” and “Gulp Configuration File”.

  • package.json – NPM Configuration File
  • gulpfile.js – Gulp Configuration File

Note: If the templates aren’t available in Visual Studio you can create a normal json and a js file, and name them package.json and gulpfile.js.

Step 6: Modify the package.json file so it looks like the configuration below. You can change the values as you like, but the important part is the devDependencies section.

{
  "name": "ASP.NET",
  "version": "1.0.0",
  "description": "",
  "main": "gulpfile.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "",
  "devDependencies": {
    "gulp": "^3.9.1",
    "gulp-plumber": "1.0.1",
    "gulp-autoprefixer": "^2.0.0",
    "gulp-sass": "2.0.4"
  }
 }

Step 7: In the solution explorer of Visual Studio, right click on the package.json file and select Restore Packages. This will download the dependencies we set up in step 7.

Note: Now would be a good time to say if you are using version control, it would be wise to add an exclusion for the node_modules directory.

Step 8: Let’s now update the gulpfile.js to compile our scss file.

var gulp         = require('gulp');
var sass         = require('gulp-sass');
var plumber      = require('gulp-plumber');
var autoprefixer = require('gulp-autoprefixer');

gulp.task("styles", function () {
  // We start with the main scss file (site.scss) and include all others from there.
  return gulp.src(["content/scss/site.scss", "content/scss/*.css"])
             .pipe(plumber())
             .pipe(sass())
             .on('error', function(err) {
                 console.error(err.message);
                 this.emit('end');
             })
             .pipe(autoprefixer("last 1 version", { cascade: true }))
             // The destination directory to output the compiled css.
             .pipe(gulp.dest("content/"));
});

gulp.task("default",["styles"]);

Step 9: At this point, it’s now just a matter of creating the content/scss/ directory and creating your sass styles.

Note: When you want to compile your css, open the “Task Runner Explorer” by right clicking the gulpfile.js in the “Solution Explorer” pane, or in the menu click on “View” -> “Other Windows” -> “Task Runner Explorer”. After doing that you should see our two tasks of “default” and “styles”. You can double click either one to compile your new files.

If you want to get really crazy, you can create a task that will watch your content/scss/ directory for changes and have them be automatically compiled.

Getting Out of the Fold

I did the Advent of Code albeit after the fact. It’s been awhile since I’ve looked at my solutions, I thought it would be good to go back and refactor. This is turning out to be a very good exercise and an indicator of how far I’ve come as a functional programmer.

In my early functional days, learning fold was the pinnacle of accomplishments. Fold can be a difficult function to learn for someone coming from strictly Object Oriented. Fold is a higher order function that takes three parameters. Higher order function is a fancy name for a function that takes another function as a parameter. The three parameters for fold are as follows, a function (known as a folder), an initial state, and a collection of elements. The signature for fold in F# is below, along with a very simple example.

Seq.fold : ('State -> 'T -> 'State) -> 'State -> seq<'T> -> 'State
Seq.fold (fun acc x -> acc + x) 0 [1; 2; 3]

My example? The folder is a function that takes two integers and adds them together. The initial state is zero, and a list that contains the integers 1, 2, and 3. That wasn’t so bad right?

More experienced developers say “That’s not a great example. We already have Seq.sum.” Absolutely, and that’s where I am going. I found I used fold in a lot of cases where there was a much better function.

Spoilers of Advent of Code Day 3

The advent of code day 3 is a perfect example of my use of fold as being a golden hammer. Day 3’s problem is a delivery person is given directions consisting of “<",">“,”v”,”^”. An example of directions could be “^^vv<><>“. That delivery person then delivers packages to the houses at each stop, some houses receive more than one package. What is the number of houses that get packages?

My initial solution using the golden fold.

let move (x,y) = function
    | '^' -> (x, y + 1)
    | 'v' -> (x, y - 1)
    | '<' -> (x - 1, y)
    | '>' -> (x + 1, y)
    | _   -> (x, y)

let countHouses dirs = 
    dirs |> Seq.fold (fun (p,(s : (int * int) Set)) d -> 
            let p' = move p d
            (p', (s.Add p'))) ((0,0), Set.ofList [(0,0)])
    |> fun (_, s) -> s |> Seq.length

The code works, but it’s not all that readable. The state is a tuple containing the current position and a set of houses visited. The folder deconstructs the tuple, moves to the new house, and adds it to the set. The final result of the fold is deconstructed and the set of houses is counted.

Let’s look at how I refactored the solution. This is after some time away from my initial solution.

let countHouses dirs = dirs |> Seq.scan move (0,0) |> Seq.distinct
                       |> Seq.length

Seq.scan is a higher order function that returns a sequence of the intermediate results. It turns out scan is exactly what I needed. You can see scan results in a much nicer solution than fold does.

Fold is a very useful and powerful function, especially when you are getting started. However, it shouldn’t be your go to function for everything. As you gain more experience you learn there are more specific functions that result in code that is a lot easier to reason about. Don’t stop learning when you get into the fold.

Surface Pro 3 Lockup on boot

tl;dr – Disabling Windows Spotlight seems to have resolved my Surface Pro 3’s lockup on boot issue. (Your results may vary)

I’ve had a Surface Pro 3 since September of 2015. Let’s just say it was a rocky start. Out of the box the machine blue screened on boot. I did a hard reset and was able to get in to use it. I went through the usual steps of doing updates, and things seemed to be going smoothly.

The next day I tried to do some reading on it however the Surface Pro 3 wouldn’t boot. It got stuck on the Surface screen without the spinning indicator. Again I had to do another hard reset. A little research revealed it was a common issue with no real solution. It was disappointing to say the least.

The system would lock up every third to fifth time I would try to use it. I tried factory resetting the device and still it didn’t want to boot consistently.

I then read somewhere that there were potential driver issues with the network card. Whether or not that was true I don’t know. What I did know was every time I hard reset the machine (and it successfully boot) the lock screen background image would flash and reset to the original. This got me thinking of something to try.

I went into All Settings (by swiping in from the right) -> Personalisation -> Lock Screen. Once there I changed the Background from Windows Spotlight to being a static picture. The Surface Pro 3 has not locked up on me since I made that change. It’s been booting consistently without any issues. I’m a happy user now.

Whether or not the fix was disabling Windows Spotlight I can’t be sure. It may be coincidence. At this point, I don’t care. It works.