lefthandedgoat

Keybase proof

I hereby claim:

• I am lefthandedgoat on github.
• I am lefthandedgoat (https://keybase.io/lefthandedgoat) on keybase.
• I have a public key whose fingerprint is 2605 18F6 0853 C366 17CE D7C2 013C B074 F73F 4256

To claim this, I am signing this object:

lefthandedgoat

Off the top of my head, there are multiple parts of making your site faster.

1.  Network related stuff
2.  Server side time
3.  Client side time

The tool that will give you the quickest high level insight into some things you may be wrong is:
http://yslow.org/
It will lead you to some quick wins like, expiration headers, gzip compression, etc.
It gives you a nice score and with a few hours of work you can usually fix several of the issues.

lefthandedgoat

open canopy
open runner

start firefox

pin types.FullScreen
url "https://www.google.com/?gws_rd=ssl#q=cats"

let elems = elements ".g .r a"
elems |> List.iter (fun e -> printfn "%s || %s" e.Text (e.GetAttribute("href")))

lefthandedgoat

• People (usually no F# exposure) always want to understand what &&& is ex:
  • "Some test" &&& fun _ -> url "http://www.google.com"
  • To explain this I teach them about infix operators which also helps with them understand why you can do "#name" == "Bob" and with |>
• Its good to point out that canopy uses selenium and does not hide it at all. If you need to do something that canopy does not support, you can google for it and take the example and convert it to f#. browser is the instance of ISeleniumWebDriver
• UI Automation works really well but is a pain because its sometimes more precise that people care about. It will uncover subtle bugs that people often time don't want to research and fix =(
• A great property of F# is that the most recent definition of a function is the one that is used. This lets you 'override' core functionality with some that is better for you. ex if you dont like how displayed works, you can create your own version and put it in a module and open it after op

lefthandedgoat

type SqlPart = 
  | select of string list
  | from of string
  | where of string list
  
let execute sqlParts =
  let rec execute sqlParts sqlString =
    match sqlParts with
      | [] -> sqlString
      | part :: tail -> execute tail (sqlString + (convertPartToString part))

lefthandedgoat

;; require package managers, but we'll avoid them if at all possible
(require 'package)

(push '("melpa" . "http://melpa.milkbox.net/packages/")
      package-archives)

;;=====================================
;;plugins
;;=====================================

lefthandedgoat

module canopyExtensions

open canopy
open runner

let context name =
  canopy.runner.context name
  once (fun _ -> printfn "some common once function")
  before (fun _ -> printfn "some common before function")
  after (fun _ -> printfn "some common after function")

lefthandedgoat

//inference will make this a function with 2 int args and int as a result
let add this that = this + that

//we can use type annotations to explicitly qualify the argument's types
let add (this : int) (that : int) = this + that

//we can use type annotations to also explicitly qualify the return value's type 
let add (this : int) (that : int) : int = this + that

//f# defaults to ints inference for addition, if we want floats we can provide that

lefthandedgoat

module whatever

open runner

type DataElement = {
    formula : Formula option
}
and FormulaVariable = {
    dataElement : DataElement
}

lefthandedgoat

type foo = {
    a : string
    b : int
}


let foos = 
    [
        { a = "hello"; b = 1 }