Through the Interface

Money designed with AutoCAD

I'm currently in Boston for an internal technical summit where I'll be presenting sessions on Kinect Fusion and Leap Motion (which will the sessions I've submitted - and will hopefully get accepted - for AU 2013). I arrived a day early and rented a bicycle from the hotel, taking the opportunity to cycle through the MIT and Harvard campuses (both of which are in Cambridge, where the summit is taking place) and then on to downtown Boston. It was really great being back in Boston after probably five years - it's still one of my favourite cities in the US.

I received this through the post, last week. A $5 bill from Doug Bell. It was designed for the recent American Numismatic Association’s National Money Show in New Orleans. Doug used the application I developed for him in conjunction with AutoCAD to design the guilloché pattern in the note’s background:

For the next event it seems Doug’s planning not only to design his notes using AutoCAD, but to use it to plot the pattern more directly onto the notes themselves. I look forward to seeing the results!

Show me the money!

Or otherwise named “Creating an AutoCAD jig to dynamically display a guilloché pattern using F#”. But then why pass up the chance for a Jerry Maguire reference? :-)

Anyway, to continue on from last week’s post, Doug – who had presented the original challenge – went on to suggest that I give it the same treatment as Spiro. Basically to implement a jig to display the guilloche pattern dynamically as you input the various options.

I understand the difficulty in understanding the nature of the geometry being created in the previous version… the fact that I’d named the original variables R, r, p, Q, m and n (as per the equation in the post that inspired this app) probably didn’t help with the understandability of the app, all things considered. It was certainly easier to name the various parameters in that way rather than work out more human-friendly labels.

This time around, though, I found additional help from this site, which includes a very cool Flash-based guilloché configurator. And as it also provided source code, I was able to connect some of the exposed UI elements with the underlying formula.

Which has given rise to this version of the app, with an additional GUIJIG command to complement GUILLOCHE. We’re also now storing the previous selections – whether via the jig- or the prompt-based version – so there’s an accompanying GUIDEF command to reset these default values should they become confused or confusing (and that’s quite easy to do with this app).

So here’s the updated F# code. Bear in mind this is still very much in the experimental stage, so expect quirks. If you have some ideas on how to improve it (such as an alternative name for the “Wiggle” parameter :-) then please let me know.

module Guillocher.Commands

 

open Autodesk.AutoCAD.ApplicationServices.Core

open Autodesk.AutoCAD.Runtime

open Autodesk.AutoCAD.DatabaseServices

open Autodesk.AutoCAD.EditorInput

open Autodesk.AutoCAD.Geometry

open System

 

// Save our various default values in mutable state

 

let mutable _R = 50.0

let mutable _r = -0.2

let mutable _p = 25.0

let mutable _Q = 3.0

let mutable _m = 1.0

let mutable _n = 6.0

let mutable _segs = 300

let mutable _perfSegs = 1000

 

// User prompting helper functions

 

let getIntegerWithDefault (ed : Editor) msg min max def =

  let pio = new PromptIntegerOptions(msg)

  pio.LowerLimit <- min

  pio.UpperLimit <- max

  pio.DefaultValue <- def

  pio.UseDefaultValue <- true

 

  let pir = ed.GetInteger(pio)

  if pir.Status = PromptStatus.OK then

    Some(pir.Value)

  else

    None

 

let getDoubleWithDefault (ed : Editor) msg neg zero def =

  let pdo = new PromptDoubleOptions(msg)

  pdo.AllowNegative <- neg

  pdo.AllowZero <- zero

  pdo.DefaultValue <- def

  pdo.UseDefaultValue <- true

 

  let pdr = ed.GetDouble(pdo)

  if pdr.Status = PromptStatus.OK then

    Some(pdr.Value)

  else

    None

 

// Get the various values we need from the user for this command

 

let getGuillocheInput ed =

  let R = getDoubleWithDefault ed "\nR" true false _R

  if R = None then

    None

  else

    let r = getDoubleWithDefault ed "\nr" true false _r

    if r = None then

      None

    else

      let p = getDoubleWithDefault ed "\np" true false _p

      if p = None then

        None

      else

        let Q = getDoubleWithDefault ed "\nQ" true true _Q

        if Q = None then

          None

        else

          let m = getDoubleWithDefault ed "\nm" true false _m

          if m = None then

            None

          else

            let n = getDoubleWithDefault ed "\nn" true false _n

            if n = None then

              None

            else

              let segs =

                getIntegerWithDefault

                  ed "\nNumber of control points" 500 32767 _segs

              if segs = None then

                None

              else

                let ppr = ed.GetPoint("\nSelect center point")

                if ppr.Status = PromptStatus.OK then

 

                  // Set the selected values as our new defaults

                  // (stored in mutable global state)

 

                  _R <- R.Value

                  _r <- r.Value

                  _p <- p.Value

                  _Q <- Q.Value

                  _m <- m.Value

                  _n <- n.Value

                  _segs <- segs.Value

 

                  // Return these to the calling function for it to

                  // create the guilloche

 

                  Some(R, r, p, Q, m, n, segs, ppr.Value)

                else

                  None

 

let pointsOnGuilloche (cen : Point3d)  R r p Q m n segs =

  [|

    let period = Math.PI * 2.0;

    for theta in 0.0..period/(float segs)..period do

 

      let rr = R + r

      let rp = r + p

      let rror = rr / r

      let mth = m * theta

      let nth = n * theta

      let k = rror * mth

      let x =

        rr * Math.Cos(mth) + rp * Math.Cos(k) + Q * Math.Cos(nth)

      let y =

        rr * Math.Sin(mth) - rp * Math.Sin(k) + Q * Math.Sin(nth)

 

      yield cen + new Vector3d(x, y, 0.0)

  |]

 

// Different modes of acquisition for our jig

 

type AcquireMode =

  | RADIUS

  | MAJOR

  | MINOR

  | MULTIPLIER

  | WIGGLE

 

type GuillocheJig() as this = class

  inherit DrawJig()

 

  // Our mutable member state

 

  let mutable (_sp : Spline) = new Spline()

  let mutable _cen = Point3d.Origin

  let mutable _norm = Vector3d.ZAxis

  let mutable _locp = _p

  let mutable _locR = _R

  let mutable _locr = _r

  let mutable _locQ = _Q

  let mutable _locm = _m

  let mutable _mode = RADIUS

 

  // Calculate some ratios, so that we keep proportions

  // as we jig the initial values

 

  let _rOverP = _r / _p

  let _ROverP = _R / _p

  let _rOverR = _r / _R

 

  member x.StartJig(ed : Editor, pt) =

 

    // Set our center and start with the radius

 

    _cen <- pt

    _mode <- RADIUS

    _norm <- ed.CurrentUserCoordinateSystem.CoordinateSystem3d.Zaxis

 

    let stat = ed.Drag(this)

    if stat.Status = PromptStatus.OK then

 

      // Next we get the major ripple

 

      _mode <- MAJOR

      let stat = ed.Drag(this)

      if stat.Status = PromptStatus.OK then

 

        // Next the minor ripple

 

        _mode <- MINOR

        let stat = ed.Drag(this)       

        if stat.Status = PromptStatus.OK then

 

          // Next the angle multiplier

 

          _mode <- MULTIPLIER

          let stat = ed.Drag(this)       

          if stat.Status = PromptStatus.OK then

 

            // Next the wiggle

 

            _mode <- WIGGLE

            ed.Drag(this)

          else

            stat

        else

          stat

      else

        stat

    else

      stat

 

  // Helper function to acquire a distance and return

  // the appropriate status

 

  member private x.GetDist (prompts : JigPrompts)

    (opts : JigPromptDistanceOptions) oldVal =

 

    opts.DefaultValue <- oldVal

    let res = prompts.AcquireDistance(opts)

    if res.Status <> PromptStatus.OK then

      (SamplerStatus.Cancel, 0.0)

    else

      if oldVal = res.Value then

        (SamplerStatus.NoChange, 0.0)

      else

        (SamplerStatus.OK, res.Value)

 

  // Our Sampler function to acquire the various distances

 

  override x.Sampler prompts =

 

    // We're just acquiring distances

 

    let jo = new JigPromptDistanceOptions()

    jo.BasePoint <- _cen

    jo.Cursor <- CursorType.RubberBand

    jo.UseBasePoint <- true

    jo.UserInputControls <-

      UserInputControls.NoZeroResponseAccepted

 

    // Then we have slightly different behavior depending

    // on the info we're acquiring

 

    match _mode with

 

    // p...

 

    | RADIUS ->

      jo.Message <- "\nRadius"

      let (stat, res) = x.GetDist prompts jo _locp

      if stat = SamplerStatus.OK then

        _locp <- res

      stat

 

    // R...

 

    | MAJOR ->

      jo.Message <- "\nMajor ripple"

      let (stat, res) = x.GetDist prompts jo _locR

      if stat = SamplerStatus.OK then

        _locR <- res

      stat

 

    // r...

 

    | MINOR ->

      jo.Message <- "\nMinor ripple"

      let (stat, res) = x.GetDist prompts jo _locr

      if stat = SamplerStatus.OK then

        _locr <- res

      stat

 

    // m...

 

    | MULTIPLIER ->

      jo.Message <- "\nAngle multiplier"

      let (stat, res) = x.GetDist prompts jo _locm

      if stat = SamplerStatus.OK then

        _locm <- res

      stat

 

    // Q...

 

    | WIGGLE ->

      jo.Message <- "\nWiggle"

      let (stat, res) = x.GetDist prompts jo _locQ

      if stat = SamplerStatus.OK then

        _locQ <- res

      stat

 

  // Our WorldDraw function to display the guilloche and

  // the related temporary graphics

 

  override x.WorldDraw

    (draw : Autodesk.AutoCAD.GraphicsInterface.WorldDraw) =

 

    // We'll actually only draw a green circle for our radius

 

    if _mode = RADIUS then

      let col = draw.SubEntityTraits.Color

      draw.SubEntityTraits.Color <- (int16 3)

      draw.Geometry.Circle(_cen, _locp, _norm) |> ignore

      draw.SubEntityTraits.Color <- col

 

    // Check the RegenAbort flag...

    // If it's set then we drop out of the function

 

    if not draw.RegenAbort then   

 

      // Generate the spline with low accuracy

      // (fewer control points == quicker)

 

      match _mode with

 

      | RADIUS ->

 

        // Make sure we don't have a p of 0

 

        if _locp = 0.0 then _locp <- 0.001

 

        x.Generate

          (_locp * _ROverP, _locp * _rOverP, _locp,

            _locQ, _locm, _n, _segs)

 

      | MAJOR ->

 

        x.Generate

          (_locR, _locR * _rOverR, _locp, _locQ, _locm, _n, _segs)

 

      | _ ->

 

        x.Generate(_locR, _locr, _locp, _locQ, _locm, _n, _segs)

 

      if not draw.RegenAbort then

        draw.Geometry.Draw(_sp) |> ignore

 

    true

 

  // Set the global defaults based on the last set of successful

  // input values

 

  member x.SetDefaults() =

    _R <- _locR

    _p <- _locp

    _r <- _locr

    _Q <- _locQ

    _m <- _locm

 

  // Generate a more accurate spline

 

  member x.Perfect() =

 

    x.Generate(_R, _r, _p, _Q, _m, _n, _perfSegs)

 

  // Generate a spline

 

  member x.Generate(R, r, p, Q, m, n, num) =

 

    // Generate control points based on the accuracy

 

    let pts = pointsOnGuilloche _cen R r p Q m n num

 

    if _sp <> null then

      _sp.Dispose()

 

    _sp <- new Spline(new Point3dCollection(pts), 1, 0.)

 

  // Accessor for the entity

 

  member x.GetEntity() = _sp

 

  // Let the caller clean-up when cancelling

 

  member x.CleanUp() = _sp.Dispose()

 

end

 

// Our jig-based command

 

[<CommandMethod("GUIJIG")>]

let guillochejig() =

 

  // Let's get the usual helpful AutoCAD objects

 

  let doc = Application.DocumentManager.MdiActiveDocument

  let ed = doc.Editor

  let db = doc.Database

 

  // Prompt the user for the center of the spiro

 

  let cenRes = ed.GetPoint("\nSelect center point: ")

 

  if cenRes.Status = PromptStatus.OK then

 

    let cen = cenRes.Value

 

    // Create the spline and run the jig

 

    let jig = new GuillocheJig()

    let res = jig.StartJig(ed, cen)

 

    if res.Status = PromptStatus.OK then

 

      // Perfect the spline created, smoothing it up

 

      jig.SetDefaults()

      jig.Perfect()

 

      use tr = db.TransactionManager.StartTransaction()

 

      // Get appropriately-typed BlockTable and BTRs

 

      let bt =

        tr.GetObject(db.BlockTableId,OpenMode.ForRead)

          :?> BlockTable

 

      let ms =

        tr.GetObject

          (bt.[BlockTableRecord.ModelSpace], OpenMode.ForWrite)

            :?> BlockTableRecord

 

      // Add our spline to the modelspace

 

      let sp = jig.GetEntity()

      let id = ms.AppendEntity(sp)

      tr.AddNewlyCreatedDBObject(sp, true)

 

      tr.Commit()

 

    else

 

      jig.CleanUp()

 

// Set the values back to the program defaults

 

[<CommandMethod("GUIDEFS")>]

let resetGuillocheDefaults() =

  _R <- 50.0

  _r <- -0.2

  _p <- 25.0

  _Q <- 3.0

  _m <- 1.0

  _n <- 6.0

 

[<CommandMethod("GUILLOCHE")>]

let guilloche() =

 

  // Let's get the usual helpful AutoCAD objects

 

  let doc = Application.DocumentManager.MdiActiveDocument

  let ed = doc.Editor

  let db = doc.Database

 

  // First we need some user input

 

  match getGuillocheInput ed with

  | None -> ()

  | Some(R, r, p, Q, m, n, segs, cen) ->

 

    // Next we get a sampling of points along the Guilloche geometry

 

    let pts =

      pointsOnGuilloche

        Point3d.Origin

        R.Value r.Value p.Value Q.Value m.Value n.Value segs.Value

 

    // Use the points as control points on a spline

 

    let sp = new Spline(new Point3dCollection(pts), 1, 0.)

 

    // Move the geometry to the selected point

 

    sp.TransformBy(Matrix3d.Displacement(cen.GetAsVector()))

 

    // Use a transaction to add our spline to the model-space

 

    use tr = db.TransactionManager.StartTransaction()

 

    // Get appropriately-typed BlockTableRecord

 

    let btr =

      tr.GetObject(db.CurrentSpaceId, OpenMode.ForWrite)

        :?> BlockTableRecord

 

    // Add our curve to the model-space

 

    let id = btr.AppendEntity(sp)

    tr.AddNewlyCreatedDBObject(sp, true)

 

    // Commit the transaction

 

    tr.Commit()

Here’s an example guilloché pattern being created via GUIJIG. You’re going to have a tough time creating a specific pattern that you’re aiming for, but it’s worth persevering – every so often you strike gold. :-)

Doug also mentioned filling a certain area with a pattern. In this case, I just drew a rectangular polyline using RECTANG and then used TRIM to remove the parts of the spline outside of it. It took a few crossing window selections, but it got there eventually.

Printing your own money with AutoCAD

Here’s a fun one to finish up the week. And no, it isn’t a belated April Fool’s gag. ;-) I should probably say right away that you won’t be printing money after reading this blog post, but you might know more about some of the security measures used by those who do.

A couple of weeks ago, I received an email from Doug Bell at PaperMoneyWorld.net:

I have tried your Spiro for AutoCAD and I enjoy it very much. I would like to challenge you to another function I would like to see that is related to the spirograph. I’d like to see what is called a geometric lathe. I have seen this for a Mac but it doesn't convert to any type of AutoCAD format. Here is a link that will give you more info on it. Thank you.

And with that, Doug introduced me to the fascinating world of guilloché and its use in preventing counterfeiting. (Doug’s interest was due to some posts I’d written on creating Spirograph-like patterns using AutoCAD, which culminated in the Spiro Plugin of the Month and Autodesk Exchange app.)

Before going further with this, I did check in with Doug to make sure I wasn’t becoming an unwitting accomplice in an illegal operation to forge banknotes. Sure enough, Doug confirmed it was related to his hobby (although in this case it seems “passion” is a better description) of collecting military money and creating currency to be used at the festivals he attends with fellow enthusiasts. Doug intends to use a plotted guilloché background to make his own currency more authentic.

That was good enough for me (although it meant I was doing it for fun rather than a suitcase of dodgy dollar bills ;-).

The good news is that the typical guilloché pattern used in security printing is indeed very close to those generated by a Spirograph, both are hypotrochoids. And as the basic mathematical formula – for at least one family of guilloché – was provided in Aegir Hallmundr’s excellent blog post (which Doug had sent through in his email), it was pretty easy to modify the existing F# code to create them.

I did make a few changes to the approach, this time around: rather than creating a jig, I opted for prompting the user via the command-line (and not even updating  the defaults to reflect the previous choices). I also decided to create a Spline rather than a Polyline, as that would reduce the size (on disk) of the resulting geometry and lead to a smoother fit (as the intention is actually to plot these, after all).

Here’s the F# code. It’ll be straightforward to convert to C#, in case (let me know if anyone has an interest in a C# version and I’ll crank one out):

module Guillocher.Commands

 

open Autodesk.AutoCAD.ApplicationServices.Core

open Autodesk.AutoCAD.Runtime

open Autodesk.AutoCAD.DatabaseServices

open Autodesk.AutoCAD.EditorInput

open Autodesk.AutoCAD.Geometry

open System

 

// User prompting helper functions

 

let getIntegerWithDefault (ed : Editor) msg min max def =

  let pio = new PromptIntegerOptions(msg)

  pio.LowerLimit <- min

  pio.UpperLimit <- max

  pio.DefaultValue <- def

  pio.UseDefaultValue <- true

 

  let pir = ed.GetInteger(pio)

  if pir.Status = PromptStatus.OK then

    Some(pir.Value)

  else

    None

 

let getDoubleWithDefault (ed : Editor) msg neg zero def =

  let pdo = new PromptDoubleOptions(msg)

  pdo.AllowNegative <- neg

  pdo.AllowZero <- zero

  pdo.DefaultValue <- def

  pdo.UseDefaultValue <- true

 

  let pdr = ed.GetDouble(pdo)

  if pdr.Status = PromptStatus.OK then

    Some(pdr.Value)

  else

    None

 

// Get the various values we need from the user for this command

 

let getGuillocheInput ed =

  let R = getDoubleWithDefault ed "\nR" true false 50.0

  if R = None then

    None

  else

    let r = getDoubleWithDefault ed "\nr" true false -0.2

    if r = None then

      None

    else

      let p = getDoubleWithDefault ed "\np" true false 25.0

      if p = None then

        None

      else

        let Q = getDoubleWithDefault ed "\nQ" true true 3.0

        if Q = None then

          None

        else

          let m = getDoubleWithDefault ed "\nm" true false 1.0

          if m = None then

            None

          else

            let n = getDoubleWithDefault ed "\nn" true false 6.0

            if n = None then

              None

            else

              let segs =

                getIntegerWithDefault

                  ed "\nNumber of control points" 500 32767 3000

              if segs = None then

                None

              else

                let ppr = ed.GetPoint("\nSelect center point")

                if ppr.Status = PromptStatus.OK then

                  Some(R, r, p, Q, m, n, segs, ppr.Value)

                else

                  None

 

let pointsOnGuilloche R r p Q m n segs =

  [|

    let period = Math.PI * 2.0;

    for theta in 0.0..period/(float segs)..period do

 

      let rr = R + r

      let rp = r + p

      let rror = rr / r

      let mth = m * theta

      let nth = n * theta

      let k = rror * mth

      let x =

        rr * Math.Cos(mth) + rp * Math.Cos(k) + Q * Math.Cos(nth)

      let y =

        rr * Math.Sin(mth) - rp * Math.Sin(k) + Q * Math.Sin(nth)

 

      yield new Point3d(x, y, 0.0)

  |]

 

[<CommandMethod("GUILLOCHE")>]

let guilloche() =

 

  // Let's get the usual helpful AutoCAD objects

 

  let doc =

    Application.DocumentManager.MdiActiveDocument

  let ed = doc.Editor

  let db = doc.Database

 

  // First we need some user input

 

  match getGuillocheInput ed with

  | None -> ()

  | Some(R, r, p, Q, m, n, segs, cen) ->

 

    // Next we get a sampling of points along the Guilloche geometry

 

    let pts =

      pointsOnGuilloche

        R.Value r.Value p.Value Q.Value m.Value n.Value segs.Value

 

    // Use the points as control points on a spline

 

    let sp = new Spline(new Point3dCollection(pts), 1, 0.0)

 

    // Move the geometry to the selected point

 

    sp.TransformBy(Matrix3d.Displacement(cen.GetAsVector()))

 

    // Use a transaction to add our polyline to the model-space

 

    use tr = db.TransactionManager.StartTransaction()

 

    // Get appropriately-typed BlockTableRecord

 

    let btr =

      tr.GetObject(db.CurrentSpaceId, OpenMode.ForWrite)

        :?> BlockTableRecord

 

    // Add our curve to the model-space

 

    let id = btr.AppendEntity(sp)

    tr.AddNewlyCreatedDBObject(sp, true)

 

    // Commit the transaction

 

    tr.Commit()

For further fun, I went ahead and created an equivalent version in DesignScript, for anyone using that (there’s an updated version of the tech preview on Labs, still AutoCAD 2013-based).

import("ProtoGeometry.dll");

import("Math.dll");

 

R = 50;

r = -0.2;

p = 25;

Q = 3;

m = 1;

n = 6;

segs = 3000;

theta = 0..360..360/segs;

 

def guilloche(th)

{

    rr = R + r;

    rp = r + p;

    rror = rr / r;

    mth = m * th;

    nth = n * th;

    k = rror * mth;

    x = rr * Math.Cos(mth) + rp * Math.Cos(k) + Q * Math.Cos(nth);

    y = rr * Math.Sin(mth) - rp * Math.Sin(k) + Q * Math.Sin(nth);

    pt = Point.ByCoordinates(x, y, 0);

    return = pt;

}

 

spline = BSplineCurve.ByPoints(guilloche(theta));

Here it is inside the DesignScript editor:

So that’s about it – in case you’re interested, here’s the resultant DWG with this particular pattern (the one created via the F# code using the default arguments).

AU 2012 Handout: Moving code to the cloud – it’s easier than you think – Part 1

After posting the handout for my Wednesday class, now it’s time to start the one for Tuesday's - CP1914 - Moving Code to the Cloud: It's Easier Than You Think (I have a lot else going on on Tuesday, but this is the only class on that day for which I needed to prepare material). Attendance for both classes is looking fairly good: there are currently 138 attendees registered for the Cloud session and 62 registered for the one on WinRT.

Why all this talk of the cloud?

The software industry is steadily adopting a model commonly referred to as “cloud computing”. For many software developers, this will not appear to be anything very new: many have worked with centralized computing resources in the past – in the mainframe era – but that’s not to say that this shift isn’t valid.

So let’s step back and look briefly at how the industry has evolved over recent decades. The mainframe era gave way to personal computing: Autodesk was one of many software companies that identified this trend and rode the wave to become a successfully business. The initial releases of AutoCAD were far from being really useable, in many ways, but it was clear that Moore’s Law – which indicated that the number of transistors on chips would double every 18-24 months – would hold long enough for the various pieces of the puzzle to provide the necessary performance from a personal computer before very long.

Nothing lasts forever, especially if it’s an exponential law. Moore’s Law as we know it has hit a bit of a barrier in recent years: we’re no longer seeing CPU clock speed doubling, for instance, as we’re hitting certain physical laws that prevent this from happening. This article from Herb Sutter does a great job of explaining this in detail.

That said, technology continues to evolve: rather than chips doubling in speed, we’re seeing the number of cores doubling, and the overall computing power that’s available to us via the cloud continuing to grow, too. For more information on this shift, see Herb’s sequel to the above article.

Ultimately, for software developers to continue to see performance gains (and cost efficiencies) software is having to be architected to work in a more distributed manner, with much of its processing performed on the cloud. This work distribution is being made possible via improvements in infrastructure – it’s very common for people to have redundant methods of accessing the Internet, for instance, whether wired or wirelessly – and the cost of centralized resources are continuing to drop as performance between major hosting providers turns computing resources into a commodity (and some would say utility).

At the same time as we’re seeing some kind of plateauing in performance of local, sequential software execution (although note the emphasis on sequential: parallelizing code can still bring performance gains from multi-core systems), we’re seeing a rise in the availability of lower-powered, mobile devices. As we enter the post-PC era, it’s increasingly the desire to be able to access centralized computing resources from devices that are little more than “dumb” terminals (although the modern smartphone contains more computing power than existed on the planet on the day many of their users was born).

And the world is becoming truly heterogeneous in terms of computing devices: over time software developers will decreasingly target specific operating systems, having core algorithms executing centrally. There may still be some amount of native code targeting various supported devices, but even that is likely to reduced as true cross-platform execution improves (whether via toolkits or HTML5).

Moving code to the cloud can make sense

[You may want to skip this section if you remember reading this post.]

So why would you move product functionality to the cloud? Here are some reasons:

• Performance
  • If you have a problem you can easily chunk up and parallelize – rendering is a great example of this, as we’ve seen with Project Neon(which it seems is now known as Autodesk 360 Rendering) – then the cloud can provide significant value. Renting 1 CPU for 10,000 seconds is (more or less) the same cost as buying 10,000 CPUs for 1 second.
• Scalability
  • With cloud services you pay for what you use, which should scale linearly with your company’s income (or benefits) from hosting functionality in that way. Dynamic provisioning allows companies to spin up servers to manage usage spikes, too, which allows infrastructure to be made available “just in time” rather than “just in case”.
• Reliability
  • You often hear about measurements such as “five nines” uptime, which means 99.999% availability (or about 5 minutes of downtime per year). Some providers are no doubt proving better than others at meeting their availability SLAs, but the fact remains: having a local system or server die generally creates more significant downtime than those suffered by the outages suffered by cloud providers. And that should only get better, over time.
• Low cost
  • As cloud services get increasingly commoditized – and Microsoft, Google and Amazon are competing fiercely in the cloud space, driving costs down further – using the cloud is becoming increasingly cost-effective.

That’s a bit about the “why”, here’s the “when”…

• Computation intensive
  • If you have serious number crunching going on locally in your desktop apps – which either ties up resources that could be used differently or stops your apps running on lower-spec hardware – then the cloud is likely to look attractive. I mentioned we use make the cloud available for rendering, but we’re doing the same with simulation and analysis, too.
• Collaboration
  • Imagine implementing the collaboration features of AutoCAD WS without the cloud…
• Frequent change
  • If you have applications that go through rapid release cycles, then update deployment/patching is likely to be a challenge for you. Hosting capabilities on the cloud – appropriately versioned when you make breaking interface changes, of course – can certainly help address this.
• Large data sets
  • The ideal scenario is clearly that data is co-located with the processing capability that needs to access it. Much of this data is currently stored on local systems – which makes harnessing the cloud a challenge – but as data shifts to be hosted there (for lots of very good reasons), this starts to become more compelling.
  • Another example: let’s say you have an application that relies on a local database of pricing information. Making sure this database is up-to-date can be a royal pain: it’s little surprise, then, that a number of the early adopters of cloud technology in the design space relate to pricing applications.

These were the main benefits that have been presented to ADN members during DevDays. There are few additional benefits that I’d like to add…

• Customer intimacy
  • Delivering software as a service can increase the intimacy you have with customers – and with partners, if you’re providing a platform. You have very good knowledge of how your technology is being used – and this has a “Big Brother” flip-side that people often struggle with, as you clearly have to trust your technology provider – which can allow you to provide better service and even anticipate customer needs.
• Technology abstraction
  • You may have some atypical code that you’d like the user to not have to worry about: let’s say you have some legacy product functionality implemented using Fortran or COBOL that you’d rather not have to provide a local runtime to support. Hiding it behind a web service reduces the complexity in deploying the application and can provide a much cleaner installation/deployment/usage capability.
• Device support
  • This is probably obvious (as many of the preceding points will have been to some of you, I expect), but web services are accessible from all modern programming languages on any internet-enabled device. Web services are a great way to more quickly support a variety of usages of your application’s capabilities on a variety of devices.

Today’s Example

We’re going to take an example that hits on a few of these topics: we have a core algorithm – implemented in F#, which some might questionably classify as arcane ;-) – that we want to move behind a cloud-hosted web-service and use from a number of different devices.

The algorithm generates Apollonian Gaskets – a 2D fractal, which places as many circles as it can within the “whitespace” inside a circle – and Apollonian Packings – the 3D equivalent which obvious deals with spheres.

We’re going to have fun using this service to generate some interesting 3D visualizations on a variety of platforms.

Choosing a cloud hosting provider

Autodesk is a very heavy user of Amazon Web Services, which might indicate it would be a good, long-term choice for users and developers to adopt (as co-location with data is of benefit, as we’ve seen).

That said, there are lots of factors that contribute to this kind of decision.

The early popularity of AWS was due in large part to its focus on providing Infrastructure-as-a-Service (IaaS): they made it really easy for companies with their own servers to move them across to be hosted centrally. Many companies shifted from on-premise servers (or perhaps their own data-centers) to centrally hosted and managed servers.

Microsoft’s approach has been to deliver highly integrated Platform-as-a-Service (PaaS) offerings: they abstract away the physical machine, focusing on the “roles” that you deploy to the cloud. Microsoft is now starting to deliver via an IaaS model, just as Amazon is providing more by way of PaaS from their side.

In our particular example, we’re going to make use of Windows Azure. That’s not to say it’s better for everyone – it’s just what I’ve chosen to use for this project as the integration with Visual Studio is first-class and I have free hosting provided via my MSDN subscription.

If you’re interested in AWS, I recommend looking at some of the guides on ADN’s Cloud & Mobile DevBlog.

Another option is Google App Engine, which provides an even higher level of abstraction that Azure. It seems to be an excellent system for highly granular, scalable tasks (without even having the underlying concept of physical machines in the picture). If interested in learning more about Google App Engine, I recommend attending tomorrow’s 8am class by my colleague (and manager), Ravi Krishnaswamy:

CP2568 – PaaSt the Desktop: Implementing Cloud-Based Productivity Solutions with the AutoCAD® ObjectARX® API

Architecting for the cloud

There are lots of decisions to be made when considering moving application functionality to the cloud.

Not least of which is “what is your core business logic?” meaning the algorithms that are application- and device-independent. The algorithms that moving away from your core implementation increases your flexibility and platform independence.

You also need to consider the data that needs to be transferred between the client and the cloud: both in terms of the arguments that need to be sent to your cloud-based “function” and the results that need to be brought back down to earth afterwards. Ideally you’d be working with data that’s already hosted in the cloud – and this is likely to happen more and more, over time – but that’s not necessarily where we are today.

You should also think about whether there are optimizations to be made around repeated data: should you be making use of cloud-hosted database storage (which is very cheap when compared with compute resources) or some kind of caching service? In our case we’re going to re-calculate the data, each time, but we could very easily implement a cache of the “unit” results and then multiply those for specifically requested radii.

Another important question is whether offline working needs to be supported: does a local version of the algorithm – or a cache of local data – need to be maintained in order to enable this?

An increasingly easy decision, amongst others that are quite tricky, is how to expose your web-services. These days the commonly accepted approach is to expose RESTful services, which means the transport protocol for data is standard HTTP and (most commonly) any results will be encoded in JSON – JavaScript Object Notation. JSON isn’t actually a required part of REST – it’s also possible for RESTful services to return XML, for instance – but it has become the de-facto approach that is most favored by API consumers.

The previous “standard” was SOAP – Simple Object Access Protocol. SOAP has gradually ceded ground to REST, as it required more effort to create XML envelopes containing the data to transmit to the web-service, and is generally more verbose and requires more bandwidth.

A common requirement is around authentication: you probably want to be able to monitor and control access to your web-services. This is not going to be covered in this class, but you may want to look at OAuth-compatible toolkits such as DotNetOpenAuth, which comes pre-integrated with AS.NET 4.5.

How you end up exposing your RESTful web-services will depend on your choice of technology stack (although these days it should be simple to do so from which choice you make). The Microsoft stack – which would often involve ASP.NET at some level, irrespective of whether you host on AWS or Azure – certainly abstracts away a lot of the messiness with exposing web-services, but comes with a certain execution overhead. If you really want to get “close to the metal” then you might also want to consider a Linux environment: not only do you end up with lower execution overhead but the cost associated with Linux instances can be very interesting. And as we know, the actual implementation of the web-service should be largely irrelevant to the consumer.

For today’s example we’re going to go with Microsoft and choose its ASP.NET MVC 4 Web API. This is a great way to expose web-sites with associated web-services, and seems to be the product of choice for people using the Microsoft stack to expose web-services, these days. WCF, the Windows Communication Framework, provides some very interesting capabilities – especially when needing to marshal more complex data-types to and from web-services – but our requirement is relatively simple and the Web API seems the best fit. The ADN DevBlog mentioned earlier provides some good information on using WCF.

Considering cloud costs

One of the key benefits of the cloud is its ability to scale as you provision more resources to deliver your web-services. The counterpoint is that if you over-estimate the resources required to do this, your costs will be proportionally higher than they need to be.

Companies making heavy use of the cloud tend to invest in tools they can use to scale up and down automatically based on usage. This is not a topic that we’ll cover today, but it’s worth pointing out that getting this right is important for any significant cloud-based deployment.

There are some general things you can do to keep costs in check: consider looking for ways to reduce your instance sizes – dropping from a small to an extra-small instance size can bring significant costs benefits (adding some caching or online database storage might be a way to enable this, helping reduce the processing load).

Online calculators are available to help you determine up-front costs associated with provisioning resources, here are the calculators for Azure and AWS. Be sure to monitor actual costs (and optimize provisioning based on real usage, ideally), to make sure they are in line with projections.

The Problem

Now let’s go back to today’s “problem”. We want to move our business logic – the core F# algorithm used to generate 2D and 3D Apollonian fractals – behind a cloud-based web-service. The original implementation for the 3D packing algorithm was provided in C++ by a Professor of Mathematics at the prestigious ETH in Zurich, but I chosen to migrate the code to F# to see how it looked (and having the code in a language that isn’t necessarily easy to get working on OS X, iOS and Android demonstrates the “technology abstraction” point from an earlier slide nicely.

As mentioned earlier, we’re not going to worry about authenticating users of our web-service: it’s a topic that would probably deserve a class of its own. We’re going to expose a simple, unsecured web-service (at least in terms of the need for authentication to make use of it).

Once it’s up, you’ll be able to query the geometry defining 2D Apollonian Gaskets using the “circles” API:

• http://apollonian.cloudapp.net/api/circles/2/2 (returns circle definitions via JSON)

And 3D Apollonian Packings using the “spheres” API:

• http://apollonian.cloudapp.net/api/spheres/2/2 (returns sphere definitions via JSON)

Building a simple web-service

We’re going to use the ASP.NET MVC 4 Web API to expose our web-service. MVC – standing for the common “Model View Controller” architectural pattern, which is used to separate model data from UI and interactions – is Microsoft’s technology of choice for defining and hosting web-sites and -services on top of ASP.NET.

We don’t care a great deal about the web-site – we’re much more interested in the web-services – but we’ll go ahead and create one, anyway.

While Windows Azure apparently now supports .NET 4.5, we’re going to stick with .NET 4.0 (at the time of writing this new capability had only just been announced). We’re going to install an F#-aware project template into VS2012 and make use of that to create our Web API project.

Once published to Azure, the code will be hosted and executed on Windows Server 2008 (although this is really a detail – this is not something we should have to worry about at all).

We’ll start by getting our project template installed. We can select it via the “Extensions and Updates” manager on the VS 2012 Tools menu, searching for “F# C# MVC 4”.

Once installed, we can launch a project of this type and select “WebApi Project”:

Visual Studio will go ahead and create our basic project from the template. We can launch the default web-site via the debugger:

To test the default implementation of the web-service, try appending the following suffix to the URL:

/api/values

At this point the browser will ask us whether we want to save or open the results from the web-service. Opening the results in Notepad should show them to be ["value1","value2"].

There are a few changes we’ll make to the project to get it working as we want it.
Firstly, we should change the .NET Framework target to 4.0 from 4.5 for both the contained projects.

Then some changes to the web-site project (ApollonianPackingWebApi).

• We want to copy across some files from the “ToCopy” folder:
  Site.css into the Content folder
• Three images into the Images folder (two of which need adding to the project)
• Index.cshtml into the Views -> Home folder
• crossdomain.xml into the root folder

Now running the project should look very different (although the .CSS change doesn’t always get picked up if running locally – the background of the “Welcome” area should be orange, but often looks blue before it makes it up to Azure).

There are still some changes needed to allow our service to support “cross domain scripting” (which for us primarily means being callable from client-side HTML5/JavaScript code). The first step was to add the crossdomain.xml file but we also need to open Web.config and add these elements:

Inside <configuration><system.web>:

    <customErrors mode="Off" />

Inside <configuration><system.webServer>:

    <httpProtocol>

      <customHeaders>

        <add name="Access-Control-Allow-Origin" value="*" />

      </customHeaders>

    </httpProtocol>

And then we should expand the serialization limit beyond the default to make sure it’s large enough for our largest JSON string:

  <system.web.extensions>

    <scripting>

      <webServices>

        <jsonSerialization maxJsonLength="500000">         

        </jsonSerialization>

      </webServices>

    </scripting>

  </system.web.extensions>

We can then update the web-services project (ApollonianPackingWebAppApi).

Copy across the various files into the root project folder:

Global.fs will update the existing file. Here are its contents:

namespace FsWeb

 

open System

open System.Web

open System.Web.Mvc

open System.Web.Routing

open System.Web.Http

open System.Data.Entity

open System.Web.Optimization

open System.Linq

open System.Collections.Generic

open Newtonsoft.Json

open Newtonsoft.Json.Serialization

 

type OrderedContractResolver() =

  inherit DefaultContractResolver()

  override x.CreateProperties(tp, ms) =

    (base.CreateProperties(tp, ms).OrderBy

      (fun(p) -> p.PropertyName)).ToList() :> IList<JsonProperty>

 

type BundleConfig() =

  static member RegisterBundles (bundles:BundleCollection) =

    bundles.Add

      (ScriptBundle("~/bundles/jquery").Include

        ("~/Scripts/jquery-1.*"))

    bundles.Add

      (ScriptBundle("~/bundles/jqueryui").Include

        ("~/Scripts/jquery-ui*"))

    bundles.Add(ScriptBundle("~/bundles/jqueryval").Include

      ("~/Scripts/jquery.unobtrusive*",

       "~/Scripts/jquery.validate*"))           

    bundles.Add(ScriptBundle("~/bundles/modernizr").Include

      ("~/Scripts/modernizr-*"))

    bundles.Add(StyleBundle("~/Content/css").Include

      ("~/Content/*.css"))

    bundles.Add

      (StyleBundle("~/Content/themes/base/css").Include

        ("~/Content/themes/base/jquery.ui.core.css",

          "~/Content/themes/base/jquery.ui.resizable.css",

          "~/Content/themes/base/jquery.ui.selectable.css",

          "~/Content/themes/base/jquery.ui.accordion.css",

          "~/Content/themes/base/jquery.ui.autocomplete.css",

          "~/Content/themes/base/jquery.ui.button.css",

          "~/Content/themes/base/jquery.ui.dialog.css",

          "~/Content/themes/base/jquery.ui.slider.css",

          "~/Content/themes/base/jquery.ui.tabs.css",

          "~/Content/themes/base/jquery.ui.datepicker.css",

          "~/Content/themes/base/jquery.ui.progressbar.css",

          "~/Content/themes/base/jquery.ui.theme.css"))

 

type Route =

  { controller : string

    action : string

    rad : UrlParameter

    steps : UrlParameter }

 

type ApiRoute =

  { rad : obj

    steps : obj }

 

type Global() =

  inherit System.Web.HttpApplication()

 

  static member RegisterGlobalFilters

    (filters:GlobalFilterCollection) =

      filters.Add(new HandleErrorAttribute())

 

  static member RegisterRoutes(routes:RouteCollection) =

    routes.IgnoreRoute("{resource}.axd/{*pathInfo}")

 

    routes.MapHttpRoute(

      "DefaultApi",

      "api/{controller}/{rad}/{steps}",

      { rad = RouteParameter.Optional

        steps = RouteParameter.Optional }) |> ignore

 

    routes.MapRoute(

      "Default",

      "{controller}/{action}/{rad}/{steps}",

      { controller = "Home"

        action = "Index"

        rad = UrlParameter.Optional

        steps = UrlParameter.Optional } )

 

  member this.Start() =

 

    // Only support JSON, not XML

 

    let cfg = GlobalConfiguration.Configuration

    cfg.Formatters.Remove(cfg.Formatters.XmlFormatter) |> ignore

 

    // Order the JSON fields alphabetically

 

    let stg = new JsonSerializerSettings()

    stg.ContractResolver <-

      new OrderedContractResolver() :> IContractResolver

    cfg.Formatters.JsonFormatter.SerializerSettings <- stg

 

    AreaRegistration.RegisterAllAreas()

    Global.RegisterRoutes RouteTable.Routes |> ignore

    Global.RegisterGlobalFilters GlobalFilters.Filters

    BundleConfig.RegisterBundles BundleTable.Bundles

The other four files need to be added to the project. Two of them, CirclePackingFull.fs and SpherePackingInversion.fs, are copied directly from the previous AutoCAD-hosted version of the application. The other two, CirclesController.fs and SpheresController.fs, implement the logic to pass the API requests through to our core algorithm implementations.

Here’s CirclesController.cs:

namespace FsWeb.Controllers

 

open System

open System.Web.Http

 

type Circle (X, Y, C, L) =

  member this.X = X

  member this.Y = Y

  member this.C = C

  member this.L = L

 

type CirclesController() =

  inherit ApiController()   

 

  // GET /api/values/rad/steps

 

  member x.Get(rad:double, steps:int) =

    CirclePackingFullFs.Packer.ApollonianGasket rad steps |>

      List.map

        (fun ((a,b,c),d) ->

          new Circle

            (Math.Round(a, 4),

             Math.Round(b, 4),

             Math.Round(c, 4), d)) |>

      List.toSeq

And here’s SpheresController.cs:

namespace FsWeb.Controllers

 

open System

open System.Web.Http

 

type Sphere (X, Y, Z, R, L) =

  member this.X = X

  member this.Y = Y

  member this.Z = Z

  member this.R = R

  member this.L = L

 

type SpheresController() =

  inherit ApiController()   

 

  // GET /api/values/rad/steps

 

  member x.Get(rad:double, steps:int) =

    SpherePackingInversionFs.Packer.ApollonianGasket

      steps 0.01 false |>

      List.map

        (fun ((a,b,c,d),e) ->

          new Sphere

            (Math.Round(a * rad, 4),

             Math.Round(b * rad, 4),

             Math.Round(c * rad, 4),

             Math.Round(d * rad, 4),

             e))

         |> List.toSeq

You can safely remove ValuesController.fs from the project (deleting it from disk, should you so wish).

To test our web-site and -service, we first want to launch it in a browser (most easily via the debugger):

With the web-site loaded, we can then add these URL suffices into the browser to test the two APIs:

• /api/circles/2/2
• /api/spheres/2/2

The first number in each of these URLs specifies the desired radius of the outer circle/sphere to be packed while the second tells the recursion level: how “deep” the fractal should go.

Here are the results of the first of these calls. It should be easy enough to see how the JSON file contains a list of circle definitions, each with X, Y, Curvature and Level values:

[{"C":1.0774,"L":2,"X":2,"Y":3.0718},{"C":1.0774,"L":2,"X":2.9282,"Y":1.4641},{"C":1.0774,"L":2,"X":1.0718,"Y":1.4641},{"C":6.9641,"L":1,"X":2,"Y":2},{"C":17.1603,"L":0,"X":2.1748,"Y":2.1009},{"C":17.1603,"L":0,"X":2,"Y":1.7981},{"C":17.1603,"L":0,"X":1.8252,"Y":2.1009},{"C":2.2321,"L":0,"X":3.3441,"Y":2.776},{"C":2.2321,"L":0,"X":2,"Y":0.448},{"C":2.2321,"L":0,"X":0.6559,"Y":2.776}]

Assuming both web-service calls return valid JSON files, we are now ready to publish to Azure.

Which we will look at in the next post. :-)

Cloud & mobile series summary

As we reach the end of this long series of posts on moving code to the cloud – and a look at ways to use the functionality from a wide variety of applications, many of them on mobile devices – I felt it was worth putting together a quick summary post to reinforce the overall message (which may have been a bit lost in the sheer volume of information).

Firstly, here are the posts in this series, including those looking at the original creation of the “desktop” application functionality:

Creating the core desktop functionality

• Circle packing in AutoCAD: creating an Apollonian gasket using F# – Part 1
• Circle packing in AutoCAD: creating an Apollonian gasket using F# – Part 2
• Sphere packing in AutoCAD: creating an Apollonian packing using F# – Part 1
• Sphere packing in AutoCAD: creating an Apollonian packing using F# – Part 2

Moving it to the cloud

• Moving to the Cloud
• Exposing a RESTful web service for use inside AutoCAD using the ASP.NET Web API – Part 1
• Exposing a RESTful web service for use inside AutoCAD using the ASP.NET Web API – Part 2
• Architecting for the Cloud
• Consuming data from a RESTful web-service inside AutoCAD using .NET
• Hosting our ASP.NET Web API project on Windows Azure – Part 1
• Hosting our ASP.NET Web API project on Windows Azure – Part 2
• Using Windows Azure Caching with our ASP.NET Web API project

Using the web-service from various clients

• AutoCAD
  • Calling a cloud-based web-service from AutoCAD using .NET
• Unity3D
  • Calling a web-service from a Unity3D scene
• Android
  • Creating a 3D viewer for our Apollonian service using Android – Part 1
  • Creating a 3D viewer for our Apollonian service using Android – Part 2
  • Creating a 3D viewer for our Apollonian service using Android – Part 3
• iOS
  • Creating a 3D viewer for our Apollonian service using iOS – Part 1
  • Creating a 3D viewer for our Apollonian service using iOS – Part 2
  • Creating a 3D viewer for our Apollonian service using iOS – Part 3
• HTML5/WebGL
  • Creating a 3D viewer for our Apollonian service using HTML5 – Part 1
  • Creating a 3D viewer for our Apollonian service using HTML5 – Part 2
  • Creating a 3D viewer for our Apollonian service using HTML5 – Part 3
• WinRT
  • Creating a 3D viewer for our Apollonian service using WinRT – Part 1
  • Creating a 3D viewer for our Apollonian service using WinRT – Part 2

Here are the client application projects I’ve posted for Android, iOS & WinRT.

Perhaps it’s time to say a few words about the experience I had with each of these environments…

• Unity3D was great and would certainly allow you to create a 3D app that could be used in any of the other environments (with the possible exception of WinRT for now, at least). I’d definitely consider this again to create a cross-platform 3D app.
• Android surprised me: I really liked the language (Java), the chosen 3D framework (Rajawali) and the development tool (Eclipse).
• WebGL & Three.js proved to be both easy to use and extremely powerful. Definitely an area to watch as WebGL gets more browser support, especially on mobile platforms.
• iOS was very strange for me, but didn’t prove to be so awful to develop for: while I found the Objective-C syntax to be quite jarring and the Xcode tool to be both confusing and somewhat unstable, the capabilities of the platform and its primary language were quite mature: you can do quite a lot with relatively few lines of (admittedly pretty weird-looking ;-) code. I found iSGL3D reasonably good, although I was ultimately disappointed with the results I was personally able to get from it.
• WinRT was fairly familiar – given my history with .NET – although the lack of a higher-level framework (with a simple sphere primitive, for instance) meant I struggled more with this than I’d have thought. I hope/expect that to be addressed by somebody at some point: while SharpDX allowed me to at least use C# to create a Metro-style Direct3D app, I really would have benefited from a higher abstraction layer to code against.

And to conclude…

This series was really intended to demonstrate that there are significant benefits in making core algorithms cloud-based, not only from an architectural perspective, but from the broad range of applications it enables you to provide to your customers in the long term. And also that this technology really isn’t hard: most of the client apps took a day or two to develop and none took more than a week.

I’ve chosen to deal with graphical data in this series of posts – mainly to make them more visually interesting – but it’s arguably even more compelling to broaden the reach of associated, non-graphical design data using this kind of approach.

Hopefully some of you have followed along with these posts, and derive at least some benefit from seeing similar code working in a variety of languages on a variety of technology stacks. It’s certainly been a fun one to work on: diving so deeply into the respective technologies has at times been challenging but highly educational. :-)

photo credit: blakespot via photo pin cc

Update:

For a further visualization of this data in an augmented reality application, see these posts:

• Using SLAM-based Augmented Reality to visualize 3D geometry
• An augmented reality view of an Apollonian packing using PointCloud Browser
• A gamification experiment: Apollonian Obliteration

Using Windows Azure Caching with our ASP.NET Web API project

As mentioned in the last post, while working on deploying our web-site and its related services to Windows Azure, I started to chew on the economics of Azure hosting. This is especially relevant as I start to see my free 3-month subscription’s resources being burned through by all of you checking them the links in the last post. ;-)

Here’s what I found… “extra small” instances are a mere sixth of the cost of “small” instances (not taking into account the 6-month pre-purchase discount on small instances, admittedly), which got me thinking: if I can reduce the resources needed for each instance, perhaps using a central caching service, then that would make financial sense.

For example: say we chose two small instances per month. According to the Azure pricing calculator, that would cost $180 per month (or $143.98 with the 20% reduction for a 6-month plan). If we could scale down to using 2 extra small VM instances, that would cost $30 per month. Of course we’d need to add the cost of the caching service (which currently runs at $45 per month for 128MB, which is more than enough for our needs, size-wise), but it still works out well, cost-wise. And also makes it really cheap for us to scale upwards, depending on usage, as one cache could server multiple VM instances.

So let’s look at what our web-services are currently doing, to see what opportunities we have for performance optimization.

As mentioned previously, the service currently does a lot of repeated operations, which isn’t optimal. Every time it gets a request to generate the 2D Apollonian gasket or 3D Apollonian packing for a given radius and recursion level, it calculates the results again. And actually the results for different radii – but the same recursion level – are basically the same: it’s really just a matter of multiplying the unit result (i.e. for a radius of 1.0) by the specific radius passed in (which means adjusting the X, Y, Z and radius values accordingly).

Assuming we only want to support 10 “levels” for both circles and spheres, that means we could effectively store 20 records (with those for the higher recursion levels getting quite big, of course) in a cache, and then very rarely need to call into our CPU-consuming, core F# algorithms. Which hopefully means we can then scale back the size of our VM instances, as suggested earlier.

I briefly mentioned two optimization approaches, in this previous post: memoization and caching.

Memoization is a technique that stores the results of pure function calls and reuses them where needed. This F# snippet (based on this academic paper) does this very well for the Fibonacci sequence, for instance. This would actually give some pretty cool benefits, especially as we have recursive operations that are highly repetitive in our code, but on the other hand would not give us benefits across server instances (and this is certainly something to consider if your application ends up scaling, over time).

Enter caching… while this doesn’t give us the internal efficiencies of memoization – meaning within the execution pass needed to generate the results for a single request – caching would allow us to store the results for a given request and simply not have to generate them again the next time they were needed. And if we implemented caching – which really does seem to make sense, given our desire to provide a scalable service – we would ultimately only see any benefits from memoization in the pass needed to populate the cache, anyway.

So let’s go ahead and implement caching for our service…

Caching in Windows Azure is really easy to implement. The main steps to follow can be found in this very straightforward set of instructions [update: with the new distributed caching capability this link now points to something else… these instructions show how I set up caching for this service]. I won’t repeat these steps, here – as the provided documentation is really good – but I will make a few comments before we take a look at the client-side changes to make use of this cache.

The caching service is not currently available in all Azure data-center locations:

It’s for this reason I ended up choosing Western Europe to host my service, in the last post, as at least I knew the caching service would be co-locatable with it.

It’s also worth mentioning that if you’re using the caching service from your local ASP.NET service – which still works, but doesn’t make as much sense, as there’s communication overhead – then you may hit a different category of errors than you would when deployed in the cloud.

For instance, during integration of the caching service into my code, I regularly hit a DataCacheException exception. This error can occur when you have large – in excess of 8 MB – records in your cache (which I know isn’t the case, as our level 10 circles results take up about 4.3 MB in a text file, and so shouldn’t hit the limit, even allowing for some inflation when in memory), but can also occur when you get a communication timeout (>15s). This was almost certainly the case with my local web-service attempting to save to the central cache, but went away (I believe!) when everything was hosted on Azure.

I should also point out that I’ve now gone ahead and reduced the footprint of the JSON returned by our service (something I mentioned in an update to the last post): I never really liked having “Curvature” as a field name for every circle – and “Radius” for every sphere – so I reduced them to a single character (“C” and “R”, respectively). Which brings the data transferred down by a not-inconsiderable amount (~8% for spheres and ~14% for circles), so it was worth doing if at the expense of human-readability of the JSON output.

Now for the code to make use of our caching service… hopefully it’s reasonably obvious – even in F# – what was needed to use the service from a client (even if that client is inside our own services’ code :-) perspective. I've added some comments to help explain what’s going on.

Here’s the adjusted CircleController.fs file:

namespace FsWeb.Controllers

 

open System

open System.Net

open System.Web.Http

open Microsoft.ApplicationServer.Caching

 

// A more compact profile for our data: we've shortened the field

// names to keep the data store/transmitted down

 

type Circle (X, Y, C, L) =

  member this.x = X

  member this.y = Y

  member this.k = C

  member this.l = L

 

type CirclesController() =

  inherit ApiController()

 

  // Get the cache - this is currently called for each request,

  // it would be better to place this somewhere where it's called

  // only once

 

  let cacheFactory = new DataCacheFactory()

  let cache = cacheFactory.GetDefaultCache()

 

  // A function to help scale our unit result by a given radius

  // (for circles we need to divide - rather than multiply - the

  // curvature value)

 

  let circleOfRad rad ((a:float, b:float, c:float), d:int) =

    new Circle(a * rad, b * rad, c / rad, d)

 

  // Use a unique prefix to help us identify the "circles" results

  // in our cache (as it's shared across the two services)

 

  let cacheId steps = "Circles" + steps.ToString();

 

  // GET /api/circles/rad/steps

 

  member x.Get(rad:double, steps:int) =

 

    // We'll now reject calls for recursion levels above 10

 

    if steps > 10 then

      raise (new HttpResponseException(HttpStatusCode.BadRequest))

    else

 

      // If the cache doesn't contain the unit results we need,

      // generate the

 

      let cached = cache.Get(cacheId steps)

      if cached = null then

        let results =

          CirclePackingFullFs.Packer.ApollonianGasket 1.0 steps

        try

 

          // And then attempt to add them into the cache, with

          // an expiration time of two weeks hence. Note that we

          // serialize an array: serializing an F# list quickly

          // results in a stack overflow exception

 

          cache.Add(

            cacheId steps,

            results |> List.toArray,

            TimeSpan.FromDays(14.)) |> ignore

        with

          | _ -> ()

 

        // Return the results, scaled by our radius

 

        results |> List.map (circleOfRad rad) |> List.toSeq

      else

 

        // If the cache contained the required unit results, cast

        // them to the right format and map our scaling function

 

        cached :?> (((float * float * float) * int) array) |>

          Array.map (circleOfRad rad) |> Array.toSeq

And here’s the analogous – and very similar – SpheresController.fs:

namespace FsWeb.Controllers

 

open System

open System.Net

open System.Web.Http

open Microsoft.ApplicationServer.Caching

 

// A more compact profile for our data: we've shortened the field

// names to keep the data store/transmitted down

 

type Sphere (X, Y, Z, R, L) =

  member this.x = X

  member this.y = Y

  member this.z = Z

  member this.r = R

  member this.l = L

 

type SpheresController() =

  inherit ApiController()   

 

  // Get the cache - this is currently called for each request,

  // it would be better to place this somewhere where it's called

  // only once

 

  let cacheFactory = new DataCacheFactory()

  let cache = cacheFactory.GetDefaultCache()

 

  // A function to help scale our unit result by a given radius

 

  let sphereOfRad rad ((a:float, b:float, c:float, d:float), e:int) =

    new Sphere(a * rad, b * rad, c * rad, d * rad, e)

 

  // Use a unique prefix to help us identify the "spheres" results

  // in our cache (as it's shared across the two services)

 

  let cacheId steps = "Spheres" + steps.ToString();

 

  // GET /api/spheres/rad/steps

 

  member x.Get(rad:double, steps:int) =

 

    // We'll now reject calls for recursion levels above 10

 

    if steps > 10 then

      raise (new HttpResponseException(HttpStatusCode.BadRequest))

    else

 

      // If the cache doesn't contain the unit results we need,

      // generate them

 

      let cached = cache.Get(cacheId steps)

      if cached = null then

        let results =

          SpherePackingInversionFs.Packer.ApollonianGasket

            steps 0.01 false

        try

 

          // And then attempt to add them into the cache, with

          // an expiration time of two weeks hence. Note that we

          // serialize an array: serializing an F# list quickly

          // results in a stack overflow exception

 

          cache.Add(

            cacheId steps,

            results |> List.toArray,

            TimeSpan.FromDays(14.)) |> ignore

        with

          | _ -> ()

 

        // Return the results, scaled by our radius

 

        results |> List.map (sphereOfRad rad) |> List.toSeq

      else

 

        // If the cache contained the required unit results, cast

        // them to the right format and map our scaling function

 

        cached :?> (((float * float * float * float) * int) array) |>

          Array.map (sphereOfRad rad) |> Array.toSeq

We’re choosing to cache our results for 2 weeks: the default is 48 hours, but I decided to extend that. We could also have extended that further, but for now I decided to keep it lower, as that way if I make errors during development the unnecessary entries will go away before too long. :-)

Let’s take a look at the cache usage (via my new favourite online tool, the Windows Azure Management Portal):

We’re up at about 40 MB: well below our 128 MB quota, and I suspect that’s about twice as big as it needs to be (when I changed the JSON format I also changed the cache prefix identifier, which will have led to the cache getting repopulated when actually it wasn’t needed: we’re not actually storing the JSON in the cache, but an array of F# tuples which then get mapped to JSON after retrieval… so the cache should be back down at around 20 MB in a couple of weeks’ time :-).

A very quick comment on whether this was all worth the effort, or not. I honestly believe so. While I haven’t undergone extensive performance benchmarking of the before and after state, I’ve seen the performance remain quite adequate (this may vary geographically, but spinning up instances in other data-centers would help that).

In this particular case where we have a fairly limited set of outcomes that are used repeatedly to generate results for the service, it makes good sense to implement caching, in this way. And the economics will certainly be favourable should we choose to scale the service upwards, adding additional extra-small VM instances over time to cope with increased demand.

Over the next couple of posts in this series, we’ll look at consuming the data in different ways. We’ll start with the classic AutoCAD client, and then have some real fun looking at a client developed using a game engine. :-)

Update

Thanks to prompting from Michael, I went ahead and rounded off the decimals being returned to the caller to 4 decimal places. It was a simple matter of swapping the circleOfRad and sphereOfRad functions for these implementations:

  let circleOfRad rad ((a:float, b:float, c:float), d:int) =

    new Circle(

      Math.Round(a * rad, 4),

      Math.Round(b * rad, 4),

      Math.Round(c / rad, 4),

      d)

and

  let sphereOfRad rad ((a:float, b:float, c:float, d:float), e:int) =

    new Sphere(

      Math.Round(a * rad, 4),

      Math.Round(b * rad, 4),

      Math.Round(c * rad, 4),

      Math.Round(d * rad, 4),

      e)

Which led to a further reduction of 40-50% in the JSON download. :-)

Hosting our ASP.NET Web API project on Windows Azure – Part 1

Having built our local ASP.NET Web API project and consumed its data inside AutoCAD, we’re now ready to deploy our web-service to the cloud. In this first part, we’ll look at some background information on Azure, in particular, and then get ready for the publishing process, which we’ll complete in the next post in the series.

Choosing a provider

As is obvious from the title, for these posts we’re going to use Windows Azure. Alternatives such as Amazon Web Services (AWS) provide IaaS (Infrastructure-as-a-Service) capabilities related to hosting ASP.NET – you basically get the ability to deploy Windows Servers in the cloud you can connect to and host your application on – but what’s interesting about Windows Azure is a tighter integration, something known as PaaS (Platform-as-a-Service). If you’re interested in understanding the difference between IaaS, PaaS and SaaS, then this should help.

On the subject of hosting providers… I found this debate to be very interesting, with proponents of both Azure and AWS fighting their respective corners. I suspect that for this audience – as it was the case for me – the arguments in favour of Azure tend to be more compelling, as we’re working closely with the .NET stack. On the other hand, Autodesk is currently a significant user of AWS. Over time I can imagine that the benefits of tighter integration – co-location of compute and storage resources being of particular importance – might lead to our developers and customers choosing to host their own services alongside ours, but we’re a long way from this being a significant issue, and I expect there to continue to be changes in the cloud-hosting landscape over the coming few years.

Background information

To get started with Azure, I recommend a few background resources. For those of you somewhat familiar with ASP.NET, this set of articles will probably be of use. I also sat through this introductory jump-start video, but didn’t make it to its brethren – it was mostly extolling the benefits of cloud computing in general.

If you’re going to watch one video on Windows Azure, this is it. Scott Guthrie does a fantastic job of keeping it simple and to the point: he creates an ASP.NET MVC app and deploys it on Azure in around 4 minutes.

We’re basically going to follow the same process as Scott did – which is a big reason for using VS2010 to build our ASP.NET MVC 4 project, as there currently isn’t a Windows Azure SDK for .NET that integrates with VS11 – but we’ll also be adding a few steps of our own to help us further down the line.

Before we look at getting our project deployed on Windows Azure, a quick disclaimer: I’m largely learning this as I go. While I’ve used IIS and ASP, back in the day, I haven’t recently used ASP.NET, and working with the cloud is altogether new for me. But that should also encourage people that you don’t need to know the ins and outs of AWS or Azure to get started with this stuff – it’s surprisingly easy.

Now for those steps that will save us some headaches, later on:

In the main Web.config file in the ApollonianPackingWebApi project, inside the <system.web> element, we’re going to add the following setting:

<customErrors mode="Off"/>

This allows any web-service errors to be passed through to the browser on the client, rather than us needing to open a Remote Desktop session on the server in order to get the error locally via a browser there.

This change helped me to understand the reason the application didn’t work when initially deployed to Azure: I needed to make sure F# was available to the project. While we clearly have a reference to FSharp.Core.dll in our F# library, we also need a reference to it – with CopyLocal set to True – in our primary C# project. A tricky one to track down, but I can see why it needs to happen.

Getting started with Azure

To get the integration between VS2010 and the Azure tools, you’re going to need to install the latest Windows Azure SDK for .NET, which I did myself via the Web Platform Installer.

This should provide you with the ability to – just as Scott did in the video – right-click the main C# project in our solution and select “Add Windows Azure Deployment Project”. It’s that easy to get the deployment project in place. :-)

Via this project, it’s possible to choose the number and size of the instances available to your application’s load-balancer:

Now that we’ve prepared our deployment settings, in the next post we’ll go ahead and publish the project to Windows Azure.

Architecting for the Cloud

After introducing the (apparently somewhat charged, judging from the comments) topic of moving application functionality to the cloud, and then looking at the steps of creating and implementing an ASP.NET Web API project, we’re now going to take a brief step back before looking at how we can effectively make use of the data provided by these web-services inside AutoCAD.

If you’re looking to assign blame (not that any is needed ;-), it’s Scott McFarlane’s fault we’re taking this brief backwards step: Scott raised the excellent point – which really needs addressing sooner rather than later in this series – that, aside from the technical issue of creating and hosting a web-service, it’s really important to start with the right architecture in terms of separating your application’s business logic from the AutoCAD-specific code. While it’s hard to give more than general pointers in this area – as applications vary greatly – we’ll at least look at the specific example we’re covering in this series: moving core F# algorithms to the cloud that will return data to be used to generate AutoCAD geometry.

Business logic separation

Scott has a great deal of experience in this process, and I’ve been lucky enough to hear him talk about the benefits of a clean separation between business logic and platform-specific code at AU, over the years. While the devil is clearly in the detail, we can (and feel free to jump in with comments, Scott et al. :-) boil the process down to separating core algorithms so that they don’t have a dependency on specific platform capabilities. For instance, you may have an algorithm that needs to create geometry inside AutoCAD, but you can either collect the data you need from the separated algorithm (which is almost a requirement if hosting on the cloud – more on this later) or implement some kind of call-back capability, so that your platform-centric code can be called as appropriate by the core algorithm.

AutoCAD itself is a pretty good example of a product that was gone through this process with respect to its own dependent platform(s): after having become a Windows-only product over the course of many releases, it took significant re-architecture to strip out AutoCAD’s Windows-specific code during the project known internally as “The Big Split”. We now have a clean codebase shared across Windows and Mac versions of AutoCAD with platform-specific modules for each.

Now I’m not specifically encouraging you to depend less on AutoCAD as a platform – why on earth would I do that? ;-) – but this approach should help you integrate more cleanly with future versions of AutoCAD along with other platforms that are important to your business.

It also has additional benefits, as Scott has highlighted: it certainly makes algorithms easier to unit-test (very important if you’re adopting Agile processes such as test-driven development) and, of course, to move to the cloud.

AutoCAD components in the cloud

You may want to use some core AutoCAD-related component on the server – such as RealDWG – but this will change the shape of your application and the work needed to implement it: if you’re able to live without having a product-specific dependency in your web-service implementation, you’ll ultimately benefit from greater flexibility.

That said, there are lots of good reasons for using RealDWG in the cloud. You clearly don’t want heavyweight files transferred between the client and server, if it can be avoided: as the cloud-based platforms available to us become more rich, I expect we’ll see more and more all being done up there. In the meantime it’s worth taking a measured approach to data transfer.

Let’s take our example web-service: we pass two arguments to it, as part of the URL (the radius of the outer circle/sphere and the “level” or number of recursion steps to take). So it’s very lightweight in that respect. We could have used RealDWG to create a DWG containing our data on the server – effectively using .DWG as the data transport – but that would have been overkill, even with the large number of entities we’re potentially talking about. Se we choose to return JSON with a reasonably small (although it could be made smaller by abbreviating the field names) footprint.

If you choose to go down the route of integrating RealDWG, I recommend this AU session from a good friend and colleague of mine – as well as an accomplished AU speaker – Albert Szilvasy:

CP231-1 – Using RealDWG™ in the Cloud

While we’re on the subject, you might want to check out this more recent session of Albert’s:

CP5163 – Moving from Desktop to Cloud

Sadly neither of these sessions were recorded, but the material should be of interest, at the very least. Be warned: the latter session is a little more future-oriented, and doesn’t necessarily reflect product capability that is either available today or in development.

What F# brings to the table

Part of the reason I chose F# in the first place for this project was that I find functional programming encourages good architectural practice: it encourages programmers to generate “pure” functions that do not modify things like the drawing database directly (these are known as “side effects”), but that return data which can then be used to do so. So from the start I wanted a clear separation of my core algorithm (my business logic) from my AutoCAD-centric code. It was therefore relatively easy to take that code and move it behind a web-service, as the code didn’t work directly with AutoCAD APIs, at all.

The original code returns a list of tuples – a core F# data-type that many of you will know from LISP – which is super-handy for returning sets of similar-looking data when you don’t want the overhead of implementing types or classes. Unfortunately these look pretty ugly when returned via JSON, so I decided to map them to lists of a temporary type I created for both Circles and Spheres. This has the advantage of having named properties (rather than m_Item1 etc.), making the JSON output easier to work with.

A side note on optimising the web-service’s behaviour: as we’ve implemented them as “pure” functions, our algorithm will always return the same results for the same arguments. This means it lends itself to some kind of memoization, so that we simply remember the results for arguments that have been used before – which could probably be implemented via some kind of caching mechanism in our web-service. I didn’t go down this path, though: I’ll leave that as a possible future exercise, as it seems an interesting challenge.

OK, I think that’s where I’m going to leave it, for today. In the next post we will take a look at consuming JSON data inside AutoCAD – honest! :-)

Exposing a RESTful web service for use inside AutoCAD using the ASP.NET Web API – Part 2

In the last post, we looked at the core technology we’re going to use to expose our web-service, along with the basic project set-up. In today’s post, we’re going to flesh out this project and see the web-service in action.

At this point, I should point out that I've switched back across for VS2010 for the purposes of this post (and its immediate successors), as it really will simplify the eventual integration with Windows Azure.

Before we dive into the implementation of our web-service, here are a few words on what we’re after…

We want to implement two web-service APIs:

1. One that will provide the circles representing an Apollonian gasket (in 2D)
2. One that will provide the spheres representing an Apollonian packing (in 3D)

Both of these services will take a radius (for the enclosing circle/sphere) and a “level” (i.e. the number of times we should recurse to create our fractal geometry).

They should be accessible via a simple URL – as we’re talking REST rather than SOAP – for example, with a provisional domain name:

http://myapollonianservice.com/circles/5/3 should return the circles enclosed in an outer circle of radius 5, recursing through 3 levels.

http://myapollonianservice.com/spheres/10/4 should return the spheres enclosed in an outer sphere of radius 10, recursing through 4 levels.

The results should be returned as JSON containing the circle/sphere definitions. These will simply be records containing fields for the center (X, Y, [Z] and radius (or curvature, for circles), and also the “level” of each circle/sphere, so we can colorise appropriately).

Let’s take a look at the structure of our boilerplate solution…

There are two projects: a C# project called ApollonianPackingWebApi that acts as the main entry-point into our code, but is very shallow. It exists to call through into the F# project, ApollonianPackingWebAppApi, where our application logic is all defined.

It’s the code in this latter project that we care about, particularly that contained in two files: Global.fs and ValuesControllers.fs file.

The standard Global.fs contains the below code which defines the way the REST API’s URL structure translates into calls into the project’s code:

namespace FsWeb

 

open System

open System.Web

open System.Web.Mvc

open System.Web.Routing

open System.Web.Http

open System.Data.Entity

 

type Route = { controller : string

               action : string

               id : UrlParameter }

 

type MapHttpRouteSettings = { id : obj }

 

type Global() =

  inherit System.Web.HttpApplication()

 

  static member RegisterGlobalFilters(filters:GlobalFilterCollection) =

    filters.Add(new HandleErrorAttribute())

 

  static member RegisterRoutes(routes:RouteCollection) =

    routes.IgnoreRoute("{resource}.axd/{*pathInfo}")

 

    routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", {id = RouteParameter.Optional}) |> ignore

 

    routes.MapRoute("Default",

                    "{controller}/{action}/{id}",

                    { controller = "Home"; action = "Index"

                      id = UrlParameter.Optional } )

 

  member this.Start() =

    AreaRegistration.RegisterAllAreas()

 

    Global.RegisterGlobalFilters(GlobalFilters.Filters)

    Global.RegisterRoutes(RouteTable.Routes)

The actual “intelligence” of the app is contained in ValuesControllers.fs:

namespace FsWeb.Controllers

 

open System.Web

open System.Web.Mvc

open System.Net.Http

open System.Web.Http

 

type ValuesController() =

  inherit ApiController()

 

  // GET /api/values

  member x.Get() = [| "value1"; "value2" |] |> Array.toSeq

  // GET /api/values/5

  member x.Get (id:int) = "value"

  // POST /api/values

  member x.Post (value:string) = ()

  // PUT /api/values/5

  member x.Put (id:int) (value:string) = ()

  // DELETE /api/values/5

  member x.Delete (id:int) = ()

This should be familiar if you’ve spent time looking at the introductory blog post I pointed to, last time.

Now for the changes we want to make… Let’s start with Globals.fs, which is being adjusted to have “rad” and “steps” parameters registered for our API controller(s).

namespace FsWeb

 

open System.Web.Mvc

open System.Web.Routing

open System.Web.Http

 

type Route =

  { controller : string

    action : string

    rad : UrlParameter

    steps : UrlParameter }

 

type MapHttpRouteSettings =

  { rad : obj

    steps : obj }

 

type Global() =

  inherit System.Web.HttpApplication()

 

  static member RegisterGlobalFilters(gfc:GlobalFilterCollection) =

    gfc.Add(new HandleErrorAttribute())

 

  static member RegisterRoutes(rc:RouteCollection) =

    rc.IgnoreRoute("{resource}.axd/{*pathInfo}")

 

    rc.MapHttpRoute(

      "DefaultApi",

      "api/{controller}/{rad}/{steps}",

      { rad = RouteParameter.Optional

        steps = RouteParameter.Optional }) |> ignore

 

    rc.MapRoute(

      "Default",

      "{controller}/{action}/{rad}/{steps}",

      { controller = "Home"

        action = "Index"

        rad = UrlParameter.Optional

        steps = UrlParameter.Optional } )

 

  member this.Start() =

    AreaRegistration.RegisterAllAreas()

 

    Global.RegisterGlobalFilters(GlobalFilters.Filters)

    Global.RegisterRoutes(RouteTable.Routes)

 

The ValuesController.fs file is actually being replaced with two files: CirclesController.fs and SpheresController.fs.

Here’s CirclesController.cs, which simply calls into the CirclePackingFull.fs file copied directly from our previous project (where the code ran directly inside AutoCAD):

namespace FsWeb.Controllers

 

open System.Web.Http

 

type Circle (X, Y, Curvature, Level) =

  member this.x = X

  member this.y = Y

  member this.k = Curvature

  member this.l = Level

 

type CirclesController() =

  inherit ApiController()   

 

  // GET /api/values/rad/steps

  member x.Get(rad:double, steps:int) =

    CirclePackingFullFs.Packer.ApollonianGasket rad steps |>

      List.map (fun ((a,b,c),d) -> new Circle(a,b,c,d)) |>

      List.toSeq

 

And here’s SpheresController.fs, which calls into the analogous SpherePackingInversion.fs file (the code from this post):

namespace FsWeb.Controllers

 

open System.Web.Http

 

type Sphere (X, Y, Z, Radius, Level) =

  member this.x = X

  member this.y = Y

  member this.z = Z

  member this.r = Radius

  member this.l = Level

 

type SpheresController() =

  inherit ApiController()   

 

  // GET /api/values/rad/steps

  member x.Get(rad:double, steps:int) =

    SpherePackingInversionFs.Packer.ApollonianGasket steps 0.01 false

      |>

      List.map

        (fun ((a,b,c,d),e) -> new Sphere(a*rad,b*rad,c*rad,d*rad,e))

        |>

        List.toSeq

Now it should just be a matter of building the app and starting Internet Explorer from the debugger, which shows the default web-page provided in the boilerplate project:

To test our APIs, we can extend the URL shown in the address bar to try them both:

http://localhost:64114/api/circles/5/3

and

http://localhost:64114/api/spheres/10/4

Here is the JSON data – returned as plain text from the API – for the first call:

[{"Curvature":0.43094010767585034,"Level":3,"X":5,"Y":7.6794919243112272},{"Curvature":0.43094010767585034,"Level":3,"X":7.3205080756887728,"Y":3.6602540378443873},{"Curvature":0.43094010767585034,"Level":3,"X":2.6794919243112272,"Y":3.6602540378443873},{"Curvature":2.7856406460551022,"Level":2,"X":4.9999999999999991,"Y":5},{"Curvature":6.8641016151377556,"Level":1,"X":5.4370564668483263,"Y":5.2523346687859487},{"Curvature":12.66632301492381,"Level":0,"X":5.6315960828232612,"Y":5.3646521684371233},{"Curvature":19.730424630061563,"Level":0,"X":5.4054651711758446,"Y":5.0585238564313482},{"Curvature":19.730424630061563,"Level":0,"X":5.2534157319849024,"Y":5.321881210372414},{"Curvature":6.8641016151377556,"Level":1,"X":4.9999999999999991,"Y":4.4953306624281035},{"Curvature":12.66632301492381,"Level":0,"X":4.9999999999999982,"Y":4.2706956631257533},{"Curvature":19.730424630061563,"Level":0,"X":4.8479505608090578,"Y":4.6195949331962387},{"Curvature":19.730424630061563,"Level":0,"X":5.15204943919094,"Y":4.6195949331962387},{"Curvature":6.8641016151377556,"Level":1,"X":4.5629435331516728,"Y":5.2523346687859487},{"Curvature":12.66632301492381,"Level":0,"X":4.3684039171767388,"Y":5.3646521684371242},{"Curvature":19.730424630061563,"Level":0,"X":4.7465842680150976,"Y":5.3218812103724131},{"Curvature":19.730424630061563,"Level":0,"X":4.5945348288241563,"Y":5.0585238564313491},{"Curvature":0.8928203230275511,"Level":1,"X":8.3601385660969356,"Y":6.93997690565051},{"Curvature":3.7094010767585033,"Level":0,"X":7.156682395474709,"Y":6.2451611615838516},{"Curvature":1.8165807537309524,"Level":0,"X":9.4038779908734238,"Y":5.6356450358772605},{"Curvature":1.8165807537309524,"Level":0,"X":7.7524237442958892,"Y":8.496047697324931},{"Curvature":0.8928203230275511,"Level":1,"X":4.9999999999999982,"Y":1.1200461886989812},{"Curvature":3.7094010767585033,"Level":0,"X":5,"Y":2.509677676832299},{"Curvature":1.8165807537309524,"Level":0,"X":3.3485457534224632,"Y":0.86830726679781078},{"Curvature":1.8165807537309524,"Level":0,"X":6.6514542465775328,"Y":0.86830726679781056},{"Curvature":0.8928203230275511,"Level":1,"X":1.6398614339030615,"Y":6.9399769056505116},{"Curvature":1.8165807537309524,"Level":0,"X":2.2475762557041086,"Y":8.4960476973249328},{"Curvature":3.7094010767585033,"Level":0,"X":2.8433176045252893,"Y":6.2451611615838525},{"Curvature":1.8165807537309524,"Level":0,"X":0.59612200912657454,"Y":5.6356450358772623}]

And here’s the JSON for the second:

[{"Level":2,"Radius":1.0102051443364382,"X":0,"Y":0,"Z":0},{"Level":3,"Radius":0.89897948556635621,"X":1.9070234711746936,"Y":-1.9070234711746936,"Z":-1.9070234711746936},{"Level":4,"Radius":0.73674517520435534,"X":-1.5628725281804123,"Y":1.5628725281804123,"Z":-4.6886175845412374},{"Level":5,"Radius":0.28271609708738882,"X":-0.599731408203261,"Y":0.599731408203261,"Z":-1.7991942246097827},{"Level":5,"Radius":0.67576886917362144,"X":0,"Y":0,"Z":-5.7340889988891917},{"Level":5,"Radius":0.54135422270335332,"X":-5.7419286284627038,"Y":-3.4451571770776228,"Z":1.1483857256925409},{"Level":5,"Radius":0.54135422270335332,"X":3.4451571770776228,"Y":5.7419286284627038,"Z":1.1483857256925409},{"Level":4,"Radius":0.73674517520435534,"X":-1.5628725281804123,"Y":-4.6886175845412374,"Z":1.5628725281804123},{"Level":5,"Radius":0.28271609708738882,"X":-0.599731408203261,"Y":-1.7991942246097827,"Z":0.599731408203261},{"Level":5,"Radius":0.67576886917362144,"X":0,"Y":-5.7340889988891917,"Z":0},{"Level":5,"Radius":0.54135422270335332,"X":-5.7419286284627038,"Y":1.1483857256925409,"Z":-3.4451571770776228},{"Level":5,"Radius":0.54135422270335332,"X":3.4451571770776228,"Y":1.1483857256925409,"Z":5.7419286284627038},{"Level":4,"Radius":0.73674517520435534,"X":4.6886175845412374,"Y":1.5628725281804123,"Z":1.5628725281804123},{"Level":5,"Radius":0.28271609708738882,"X":1.7991942246097827,"Y":0.599731408203261,"Z":0.599731408203261},{"Level":5,"Radius":0.67576886917362144,"X":5.7340889988891917,"Y":0,"Z":0},{"Level":5,"Radius":0.54135422270335332,"X":-1.1483857256925409,"Y":5.7419286284627038,"Z":-3.4451571770776228},{"Level":5,"Radius":0.54135422270335332,"X":-1.1483857256925409,"Y":-3.4451571770776228,"Z":5.7419286284627038},{"Level":3,"Radius":0.89897948556635621,"X":-1.9070234711746936,"Y":1.9070234711746936,"Z":-1.9070234711746936},{"Level":4,"Radius":0.73674517520435534,"X":1.5628725281804123,"Y":-1.5628725281804123,"Z":-4.6886175845412374},{"Level":5,"Radius":0.28271609708738882,"X":0.599731408203261,"Y":-0.599731408203261,"Z":-1.7991942246097827},{"Level":5,"Radius":0.54135422270335332,"X":-3.4451571770776228,"Y":-5.7419286284627038,"Z":1.1483857256925409},{"Level":5,"Radius":0.54135422270335332,"X":5.7419286284627038,"Y":3.4451571770776228,"Z":1.1483857256925409},{"Level":4,"Radius":0.73674517520435534,"X":-4.6886175845412374,"Y":-1.5628725281804123,"Z":1.5628725281804123},{"Level":5,"Radius":0.28271609708738882,"X":-1.7991942246097827,"Y":-0.599731408203261,"Z":0.599731408203261},{"Level":5,"Radius":0.54135422270335332,"X":1.1483857256925409,"Y":-5.7419286284627038,"Z":-3.4451571770776228},{"Level":5,"Radius":0.67576886917362144,"X":-5.7340889988891917,"Y":0,"Z":0},{"Level":5,"Radius":0.54135422270335332,"X":1.1483857256925409,"Y":3.4451571770776228,"Z":5.7419286284627038},{"Level":4,"Radius":0.73674517520435534,"X":1.5628725281804123,"Y":4.6886175845412374,"Z":1.5628725281804123},{"Level":5,"Radius":0.28271609708738882,"X":0.599731408203261,"Y":1.7991942246097827,"Z":0.599731408203261},{"Level":5,"Radius":0.54135422270335332,"X":5.7419286284627038,"Y":-1.1483857256925409,"Z":-3.4451571770776228},{"Level":5,"Radius":0.67576886917362144,"X":0,"Y":5.7340889988891917,"Z":0},{"Level":5,"Radius":0.54135422270335332,"X":-3.4451571770776228,"Y":-1.1483857256925409,"Z":5.7419286284627038},{"Level":3,"Radius":0.89897948556635621,"X":-1.9070234711746936,"Y":-1.9070234711746936,"Z":1.9070234711746936},{"Level":4,"Radius":0.73674517520435534,"X":1.5628725281804123,"Y":-4.6886175845412374,"Z":-1.5628725281804123},{"Level":5,"Radius":0.28271609708738882,"X":0.599731408203261,"Y":-1.7991942246097827,"Z":-0.599731408203261},{"Level":5,"Radius":0.54135422270335332,"X":-3.4451571770776228,"Y":1.1483857256925409,"Z":-5.7419286284627038},{"Level":5,"Radius":0.54135422270335332,"X":5.7419286284627038,"Y":1.1483857256925409,"Z":3.4451571770776228},{"Level":4,"Radius":0.73674517520435534,"X":-4.6886175845412374,"Y":1.5628725281804123,"Z":-1.5628725281804123},{"Level":5,"Radius":0.28271609708738882,"X":-1.7991942246097827,"Y":0.599731408203261,"Z":-0.599731408203261},{"Level":5,"Radius":0.54135422270335332,"X":1.1483857256925409,"Y":-3.4451571770776228,"Z":-5.7419286284627038},{"Level":5,"Radius":0.54135422270335332,"X":1.1483857256925409,"Y":5.7419286284627038,"Z":3.4451571770776228},{"Level":4,"Radius":0.73674517520435534,"X":1.5628725281804123,"Y":1.5628725281804123,"Z":4.6886175845412374},{"Level":5,"Radius":0.28271609708738882,"X":0.599731408203261,"Y":0.599731408203261,"Z":1.7991942246097827},{"Level":5,"Radius":0.54135422270335332,"X":5.7419286284627038,"Y":-3.4451571770776228,"Z":-1.1483857256925409},{"Level":5,"Radius":0.54135422270335332,"X":-3.4451571770776228,"Y":5.7419286284627038,"Z":-1.1483857256925409},{"Level":5,"Radius":0.67576886917362144,"X":0,"Y":0,"Z":5.7340889988891917},{"Level":3,"Radius":0.89897948556635621,"X":1.9070234711746936,"Y":1.9070234711746936,"Z":1.9070234711746936},{"Level":4,"Radius":0.73674517520435534,"X":4.6886175845412374,"Y":-1.5628725281804123,"Z":-1.5628725281804123},{"Level":5,"Radius":0.28271609708738882,"X":1.7991942246097827,"Y":-0.599731408203261,"Z":-0.599731408203261},{"Level":5,"Radius":0.54135422270335332,"X":-1.1483857256925409,"Y":3.4451571770776228,"Z":-5.7419286284627038},{"Level":5,"Radius":0.54135422270335332,"X":-1.1483857256925409,"Y":-5.7419286284627038,"Z":3.4451571770776228},{"Level":4,"Radius":0.73674517520435534,"X":-1.5628725281804123,"Y":4.6886175845412374,"Z":-1.5628725281804123},{"Level":5,"Radius":0.28271609708738882,"X":-0.599731408203261,"Y":1.7991942246097827,"Z":-0.599731408203261},{"Level":5,"Radius":0.54135422270335332,"X":3.4451571770776228,"Y":-1.1483857256925409,"Z":-5.7419286284627038},{"Level":5,"Radius":0.54135422270335332,"X":-5.7419286284627038,"Y":-1.1483857256925409,"Z":3.4451571770776228},{"Level":4,"Radius":0.73674517520435534,"X":-1.5628725281804123,"Y":-1.5628725281804123,"Z":4.6886175845412374},{"Level":5,"Radius":0.28271609708738882,"X":-0.599731408203261,"Y":-0.599731408203261,"Z":1.7991942246097827},{"Level":5,"Radius":0.54135422270335332,"X":3.4451571770776228,"Y":-5.7419286284627038,"Z":-1.1483857256925409},{"Level":5,"Radius":0.54135422270335332,"X":-5.7419286284627038,"Y":3.4451571770776228,"Z":-1.1483857256925409},{"Level":1,"Radius":4.4948974278317806,"X":-3.1783724519578227,"Y":3.1783724519578227,"Z":3.1783724519578227},{"Level":2,"Radius":2.8989794855663567,"X":4.09977610552932,"Y":-4.09977610552932,"Z":-4.09977610552932},{"Level":3,"Radius":0.69693845669906873,"X":0.98561981760319706,"Y":-0.98561981760319706,"Z":-0.98561981760319706},{"Level":4,"Radius":0.59531041938993878,"X":-1.6837921378465335,"Y":1.6837921378465335,"Z":-3.367584275693067},{"Level":5,"Radius":0.361050735467887,"X":-1.0212056936069329,"Y":1.0212056936069329,"Z":-2.0424113872138658},{"Level":5,"Radius":0.51954937761543474,"X":0.73475377614624837,"Y":-0.73475377614624837,"Z":-5.1432764330237379},{"Level":5,"Radius":0.46089451836521378,"X":-5.2144262295640074,"Y":-2.6072131147820037,"Z":1.3036065573910018},{"Level":5,"Radius":0.46089451836521378,"X":2.6072131147820037,"Y":5.2144262295640074,"Z":1.3036065573910018},{"Level":4,"Radius":0.59531041938993878,"X":-1.6837921378465335,"Y":-3.367584275693067,"Z":1.6837921378465335},{"Level":5,"Radius":0.361050735467887,"X":-1.0212056936069329,"Y":-2.0424113872138658,"Z":1.0212056936069329},{"Level":5,"Radius":0.51954937761543474,"X":0.73475377614624837,"Y":-5.1432764330237379,"Z":-0.73475377614624837},{"Level":5,"Radius":0.46089451836521378,"X":-5.2144262295640074,"Y":1.3036065573910018,"Z":-2.6072131147820037},{"Level":5,"Radius":0.46089451836521378,"X":2.6072131147820037,"Y":1.3036065573910018,"Z":5.2144262295640074},{"Level":4,"Radius":0.59531041938993878,"X":3.367584275693067,"Y":1.6837921378465335,"Z":1.6837921378465335},{"Level":5,"Radius":0.361050735467887,"X":2.0424113872138658,"Y":1.0212056936069329,"Z":1.0212056936069329},{"Level":5,"Radius":0.51954937761543474,"X":5.1432764330237379,"Y":-0.73475377614624837,"Z":-0.73475377614624837},{"Level":5,"Radius":0.46089451836521378,"X":-1.3036065573910018,"Y":5.2144262295640074,"Z":-2.6072131147820037},{"Level":5,"Radius":0.46089451836521378,"X":-1.3036065573910018,"Y":-2.6072131147820037,"Z":5.2144262295640074},{"Level":3,"Radius":2.139387691339814,"X":-1.5127755441334152,"Y":1.5127755441334152,"Z":-7.5638777206670751},{"Level":4,"Radius":0.37775486824598364,"X":-0.2671130289629659,"Y":0.2671130289629659,"Z":-1.3355651448148294},{"Level":5,"Radius":0.34576134060244468,"X":1.2224509430607009,"Y":-1.2224509430607009,"Z":-2.6893920747335427},{"Level":5,"Radius":0.31876398046728993,"X":-2.9302022384236803,"Y":-2.479401894050806,"Z":1.5778012053050583},{"Level":5,"Radius":0.31876398046728993,"X":2.479401894050806,"Y":2.9302022384236803,"Z":1.5778012053050583},{"Level":4,"Radius":1.4037600977966975,"X":-6.94825799017795,"Y":-4.96304142155568,"Z":0.992608284311136},{"Level":5,"Radius":0.19716227375982742,"X":-0.97590346538812722,"Y":-0.6970739038486623,"Z":0.13941478076973246},{"Level":5,"Radius":1.0445812551367069,"X":-0.7386304890075206,"Y":-8.1249353790827268,"Z":-3.6931524450376023},{"Level":5,"Radius":1.1978243827074595,"X":-8.469897436830351,"Y":-1.6939794873660703,"Z":-1.6939794873660703},{"Level":5,"Radius":0.83175965498126991,"X":2.9407144617731955,"Y":4.1170002464824735,"Z":7.6458576006103094},{"Level":4,"Radius":1.4037600977966975,"X":4.96304142155568,"Y":6.94825799017795,"Z":0.992608284311136},{"Level":5,"Radius":0.19716227375982742,"X":0.6970739038486623,"Y":0.97590346538812722,"Z":0.13941478076973246},{"Level":5,"Radius":1.0445812551367069,"X":8.1249353790827268,"Y":0.7386304890075206,"Z":-3.6931524450376023},{"Level":5,"Radius":1.1978243827074595,"X":1.6939794873660703,"Y":8.469897436830351,"Z":-1.6939794873660703},{"Level":5,"Radius":0.83175965498126991,"X":-4.1170002464824735,"Y":-2.9407144617731955,"Z":7.6458576006103094},{"Level":3,"Radius":2.139387691339814,"X":-1.5127755441334152,"Y":-7.5638777206670751,"Z":1.5127755441334152},{"Level":4,"Radius":0.37775486824598364,"X":-0.2671130289629659,"Y":-1.3355651448148294,"Z":0.2671130289629659},{"Level":5,"Radius":0.34576134060244468,"X":1.2224509430607009,"Y":-2.6893920747335427,"Z":-1.2224509430607009},{"Level":5,"Radius":0.31876398046728993,"X":-2.9302022384236803,"Y":1.5778012053050583,"Z":-2.479401894050806},{"Level":5,"Radius":0.31876398046728993,"X":2.479401894050806,"Y":1.5778012053050583,"Z":2.9302022384236803},{"Level":4,"Radius":1.4037600977966975,"X":-6.94825799017795,"Y":0.992608284311136,"Z":-4.96304142155568},{"Level":5,"Radius":0.19716227375982742,"X":-0.97590346538812722,"Y":0.13941478076973246,"Z":-0.6970739038486623},{"Level":5,"Radius":1.0445812551367069,"X":-0.7386304890075206,"Y":-3.6931524450376023,"Z":-8.1249353790827268},{"Level":5,"Radius":0.83175965498126991,"X":2.9407144617731955,"Y":7.6458576006103094,"Z":4.1170002464824735},{"Level":4,"Radius":1.4037600977966975,"X":4.96304142155568,"Y":0.992608284311136,"Z":6.94825799017795},{"Level":5,"Radius":0.19716227375982742,"X":0.6970739038486623,"Y":0.13941478076973246,"Z":0.97590346538812722},{"Level":5,"Radius":1.0445812551367069,"X":8.1249353790827268,"Y":-3.6931524450376023,"Z":0.7386304890075206},{"Level":5,"Radius":0.83175965498126991,"X":-4.1170002464824735,"Y":7.6458576006103094,"Z":-2.9407144617731955},{"Level":5,"Radius":1.1978243827074595,"X":1.6939794873660703,"Y":-1.6939794873660703,"Z":8.469897436830351},{"Level":3,"Radius":2.139387691339814,"X":7.5638777206670751,"Y":1.5127755441334152,"Z":1.5127755441334152},{"Level":4,"Radius":0.37775486824598364,"X":1.3355651448148294,"Y":0.2671130289629659,"Z":0.2671130289629659},{"Level":5,"Radius":0.34576134060244468,"X":2.6893920747335427,"Y":-1.2224509430607009,"Z":-1.2224509430607009},{"Level":5,"Radius":0.31876398046728993,"X":-1.5778012053050583,"Y":2.9302022384236803,"Z":-2.479401894050806},{"Level":5,"Radius":0.31876398046728993,"X":-1.5778012053050583,"Y":-2.479401894050806,"Z":2.9302022384236803},{"Level":4,"Radius":1.4037600977966975,"X":-0.992608284311136,"Y":6.94825799017795,"Z":-4.96304142155568},{"Level":5,"Radius":0.19716227375982742,"X":-0.13941478076973246,"Y":0.97590346538812722,"Z":-0.6970739038486623},{"Level":5,"Radius":1.0445812551367069,"X":3.6931524450376023,"Y":0.7386304890075206,"Z":-8.1249353790827268},{"Level":5,"Radius":0.83175965498126991,"X":-7.6458576006103094,"Y":-2.9407144617731955,"Z":4.1170002464824735},{"Level":4,"Radius":1.4037600977966975,"X":-0.992608284311136,"Y":-4.96304142155568,"Z":6.94825799017795},{"Level":5,"Radius":0.19716227375982742,"X":-0.13941478076973246,"Y":-0.6970739038486623,"Z":0.97590346538812722},{"Level":5,"Radius":1.0445812551367069,"X":3.6931524450376023,"Y":-8.1249353790827268,"Z":0.7386304890075206},{"Level":5,"Radius":0.83175965498126991,"X":-7.6458576006103094,"Y":4.1170002464824735,"Z":-2.9407144617731955},{"Level":1,"Radius":4.4948974278317806,"X":3.1783724519578227,"Y":-3.1783724519578227,"Z":3.1783724519578227},{"Level":2,"Radius":2.8989794855663567,"X":-4.09977610552932,"Y":4.09977610552932,"Z":-4.09977610552932},{"Level":3,"Radius":0.69693845669906873,"X":-0.98561981760319706,"Y":0.98561981760319706,"Z":-0.98561981760319706},{"Level":4,"Radius":0.59531041938993878,"X":1.6837921378465335,"Y":-1.6837921378465335,"Z":-3.367584275693067},{"Level":5,"Radius":0.361050735467887,"X":1.0212056936069329,"Y":-1.0212056936069329,"Z":-2.0424113872138658},{"Level":5,"Radius":0.51954937761543474,"X":-0.73475377614624837,"Y":0.73475377614624837,"Z":-5.1432764330237379},{"Level":5,"Radius":0.46089451836521378,"X":-2.6072131147820037,"Y":-5.2144262295640074,"Z":1.3036065573910018},{"Level":5,"Radius":0.46089451836521378,"X":5.2144262295640074,"Y":2.6072131147820037,"Z":1.3036065573910018},{"Level":4,"Radius":0.59531041938993878,"X":-3.367584275693067,"Y":-1.6837921378465335,"Z":1.6837921378465335},{"Level":5,"Radius":0.361050735467887,"X":-2.0424113872138658,"Y":-1.0212056936069329,"Z":1.0212056936069329},{"Level":5,"Radius":0.46089451836521378,"X":1.3036065573910018,"Y":-5.2144262295640074,"Z":-2.6072131147820037},{"Level":5,"Radius":0.51954937761543474,"X":-5.1432764330237379,"Y":0.73475377614624837,"Z":-0.73475377614624837},{"Level":5,"Radius":0.46089451836521378,"X":1.3036065573910018,"Y":2.6072131147820037,"Z":5.2144262295640074},{"Level":4,"Radius":0.59531041938993878,"X":1.6837921378465335,"Y":3.367584275693067,"Z":1.6837921378465335},{"Level":5,"Radius":0.361050735467887,"X":1.0212056936069329,"Y":2.0424113872138658,"Z":1.0212056936069329},{"Level":5,"Radius":0.46089451836521378,"X":5.2144262295640074,"Y":-1.3036065573910018,"Z":-2.6072131147820037},{"Level":5,"Radius":0.51954937761543474,"X":-0.73475377614624837,"Y":5.1432764330237379,"Z":-0.73475377614624837},{"Level":5,"Radius":0.46089451836521378,"X":-2.6072131147820037,"Y":-1.3036065573910018,"Z":5.2144262295640074},{"Level":3,"Radius":2.139387691339814,"X":1.5127755441334152,"Y":-1.5127755441334152,"Z":-7.5638777206670751},{"Level":4,"Radius":0.37775486824598364,"X":0.2671130289629659,"Y":-0.2671130289629659,"Z":-1.3355651448148294},{"Level":5,"Radius":0.34576134060244468,"X":-1.2224509430607009,"Y":1.2224509430607009,"Z":-2.6893920747335427},{"Level":5,"Radius":0.31876398046728993,"X":-2.479401894050806,"Y":-2.9302022384236803,"Z":1.5778012053050583},{"Level":5,"Radius":0.31876398046728993,"X":2.9302022384236803,"Y":2.479401894050806,"Z":1.5778012053050583},{"Level":4,"Radius":1.4037600977966975,"X":-4.96304142155568,"Y":-6.94825799017795,"Z":0.992608284311136},{"Level":5,"Radius":0.19716227375982742,"X":-0.6970739038486623,"Y":-0.97590346538812722,"Z":0.13941478076973246},{"Level":5,"Radius":1.1978243827074595,"X":-1.6939794873660703,"Y":-8.469897436830351,"Z":-1.6939794873660703},{"Level":5,"Radius":1.0445812551367069,"X":-8.1249353790827268,"Y":-0.7386304890075206,"Z":-3.6931524450376023},{"Level":5,"Radius":0.83175965498126991,"X":4.1170002464824735,"Y":2.9407144617731955,"Z":7.6458576006103094},{"Level":4,"Radius":1.4037600977966975,"X":6.94825799017795,"Y":4.96304142155568,"Z":0.992608284311136},{"Level":5,"Radius":0.19716227375982742,"X":0.97590346538812722,"Y":0.6970739038486623,"Z":0.13941478076973246},{"Level":5,"Radius":1.1978243827074595,"X":8.469897436830351,"Y":1.6939794873660703,"Z":-1.6939794873660703},{"Level":5,"Radius":1.0445812551367069,"X":0.7386304890075206,"Y":8.1249353790827268,"Z":-3.6931524450376023},{"Level":5,"Radius":0.83175965498126991,"X":-2.9407144617731955,"Y":-4.1170002464824735,"Z":7.6458576006103094},{"Level":3,"Radius":2.139387691339814,"X":-7.5638777206670751,"Y":-1.5127755441334152,"Z":1.5127755441334152},{"Level":4,"Radius":0.37775486824598364,"X":-1.3355651448148294,"Y":-0.2671130289629659,"Z":0.2671130289629659},{"Level":5,"Radius":0.31876398046728993,"X":1.5778012053050583,"Y":-2.9302022384236803,"Z":-2.479401894050806},{"Level":5,"Radius":0.34576134060244468,"X":-2.6893920747335427,"Y":1.2224509430607009,"Z":-1.2224509430607009},{"Level":5,"Radius":0.31876398046728993,"X":1.5778012053050583,"Y":2.479401894050806,"Z":2.9302022384236803},{"Level":4,"Radius":1.4037600977966975,"X":0.992608284311136,"Y":-6.94825799017795,"Z":-4.96304142155568},{"Level":5,"Radius":0.19716227375982742,"X":0.13941478076973246,"Y":-0.97590346538812722,"Z":-0.6970739038486623},{"Level":5,"Radius":1.0445812551367069,"X":-3.6931524450376023,"Y":-0.7386304890075206,"Z":-8.1249353790827268},{"Level":5,"Radius":0.83175965498126991,"X":7.6458576006103094,"Y":2.9407144617731955,"Z":4.1170002464824735},{"Level":4,"Radius":1.4037600977966975,"X":0.992608284311136,"Y":4.96304142155568,"Z":6.94825799017795},{"Level":5,"Radius":0.19716227375982742,"X":0.13941478076973246,"Y":0.6970739038486623,"Z":0.97590346538812722},{"Level":5,"Radius":0.83175965498126991,"X":7.6458576006103094,"Y":-4.1170002464824735,"Z":-2.9407144617731955},{"Level":5,"Radius":1.0445812551367069,"X":-3.6931524450376023,"Y":8.1249353790827268,"Z":0.7386304890075206},{"Level":5,"Radius":1.1978243827074595,"X":-1.6939794873660703,"Y":1.6939794873660703,"Z":8.469897436830351},{"Level":3,"Radius":2.139387691339814,"X":1.5127755441334152,"Y":7.5638777206670751,"Z":1.5127755441334152},{"Level":4,"Radius":0.37775486824598364,"X":0.2671130289629659,"Y":1.3355651448148294,"Z":0.2671130289629659},{"Level":5,"Radius":0.31876398046728993,"X":2.9302022384236803,"Y":-1.5778012053050583,"Z":-2.479401894050806},{"Level":5,"Radius":0.34576134060244468,"X":-1.2224509430607009,"Y":2.6893920747335427,"Z":-1.2224509430607009},{"Level":5,"Radius":0.31876398046728993,"X":-2.479401894050806,"Y":-1.5778012053050583,"Z":2.9302022384236803},{"Level":4,"Radius":1.4037600977966975,"X":6.94825799017795,"Y":-0.992608284311136,"Z":-4.96304142155568},{"Level":5,"Radius":0.19716227375982742,"X":0.97590346538812722,"Y":-0.13941478076973246,"Z":-0.6970739038486623},{"Level":5,"Radius":1.0445812551367069,"X":0.7386304890075206,"Y":3.6931524450376023,"Z":-8.1249353790827268},{"Level":5,"Radius":0.83175965498126991,"X":-2.9407144617731955,"Y":-7.6458576006103094,"Z":4.1170002464824735},{"Level":4,"Radius":1.4037600977966975,"X":-4.96304142155568,"Y":-0.992608284311136,"Z":6.94825799017795},{"Level":5,"Radius":0.19716227375982742,"X":-0.6970739038486623,"Y":-0.13941478076973246,"Z":0.97590346538812722},{"Level":5,"Radius":0.83175965498126991,"X":4.1170002464824735,"Y":-7.6458576006103094,"Z":-2.9407144617731955},{"Level":5,"Radius":1.0445812551367069,"X":-8.1249353790827268,"Y":3.6931524450376023,"Z":0.7386304890075206},{"Level":1,"Radius":4.4948974278317806,"X":3.1783724519578227,"Y":3.1783724519578227,"Z":-3.1783724519578227},{"Level":2,"Radius":2.8989794855663567,"X":-4.09977610552932,"Y":-4.09977610552932,"Z":4.09977610552932},{"Level":3,"Radius":0.69693845669906873,"X":-0.98561981760319706,"Y":-0.98561981760319706,"Z":0.98561981760319706},{"Level":4,"Radius":0.59531041938993878,"X":1.6837921378465335,"Y":-3.367584275693067,"Z":-1.6837921378465335},{"Level":5,"Radius":0.361050735467887,"X":1.0212056936069329,"Y":-2.0424113872138658,"Z":-1.0212056936069329},{"Level":5,"Radius":0.46089451836521378,"X":-2.6072131147820037,"Y":1.3036065573910018,"Z":-5.2144262295640074},{"Level":5,"Radius":0.51954937761543474,"X":-0.73475377614624837,"Y":-5.1432764330237379,"Z":0.73475377614624837},{"Level":5,"Radius":0.46089451836521378,"X":5.2144262295640074,"Y":1.3036065573910018,"Z":2.6072131147820037},{"Level":4,"Radius":0.59531041938993878,"X":-3.367584275693067,"Y":1.6837921378465335,"Z":-1.6837921378465335},{"Level":5,"Radius":0.361050735467887,"X":-2.0424113872138658,"Y":1.0212056936069329,"Z":-1.0212056936069329},{"Level":5,"Radius":0.46089451836521378,"X":1.3036065573910018,"Y":-2.6072131147820037,"Z":-5.2144262295640074},{"Level":5,"Radius":0.51954937761543474,"X":-5.1432764330237379,"Y":-0.73475377614624837,"Z":0.73475377614624837},{"Level":5,"Radius":0.46089451836521378,"X":1.3036065573910018,"Y":5.2144262295640074,"Z":2.6072131147820037},{"Level":4,"Radius":0.59531041938993878,"X":1.6837921378465335,"Y":1.6837921378465335,"Z":3.367584275693067},{"Level":5,"Radius":0.361050735467887,"X":1.0212056936069329,"Y":1.0212056936069329,"Z":2.0424113872138658},{"Level":5,"Radius":0.46089451836521378,"X":5.2144262295640074,"Y":-2.6072131147820037,"Z":-1.3036065573910018},{"Level":5,"Radius":0.46089451836521378,"X":-2.6072131147820037,"Y":5.2144262295640074,"Z":-1.3036065573910018},{"Level":5,"Radius":0.51954937761543474,"X":-0.73475377614624837,"Y":-0.73475377614624837,"Z":5.1432764330237379},{"Level":3,"Radius":2.139387691339814,"X":1.5127755441334152,"Y":-7.5638777206670751,"Z":-1.5127755441334152},{"Level":4,"Radius":0.37775486824598364,"X":0.2671130289629659,"Y":-1.3355651448148294,"Z":-0.2671130289629659},{"Level":5,"Radius":0.31876398046728993,"X":-2.479401894050806,"Y":1.5778012053050583,"Z":-2.9302022384236803},{"Level":5,"Radius":0.34576134060244468,"X":-1.2224509430607009,"Y":-2.6893920747335427,"Z":1.2224509430607009},{"Level":5,"Radius":0.31876398046728993,"X":2.9302022384236803,"Y":1.5778012053050583,"Z":2.479401894050806},{"Level":4,"Radius":1.4037600977966975,"X":-4.96304142155568,"Y":0.992608284311136,"Z":-6.94825799017795},{"Level":5,"Radius":0.19716227375982742,"X":-0.6970739038486623,"Y":0.13941478076973246,"Z":-0.97590346538812722},{"Level":5,"Radius":1.1978243827074595,"X":-1.6939794873660703,"Y":-1.6939794873660703,"Z":-8.469897436830351},{"Level":5,"Radius":1.0445812551367069,"X":-8.1249353790827268,"Y":-3.6931524450376023,"Z":-0.7386304890075206},{"Level":5,"Radius":0.83175965498126991,"X":4.1170002464824735,"Y":7.6458576006103094,"Z":2.9407144617731955},{"Level":4,"Radius":1.4037600977966975,"X":6.94825799017795,"Y":0.992608284311136,"Z":4.96304142155568},{"Level":5,"Radius":0.19716227375982742,"X":0.97590346538812722,"Y":0.13941478076973246,"Z":0.6970739038486623},{"Level":5,"Radius":1.1978243827074595,"X":8.469897436830351,"Y":-1.6939794873660703,"Z":1.6939794873660703},{"Level":5,"Radius":0.83175965498126991,"X":-2.9407144617731955,"Y":7.6458576006103094,"Z":-4.1170002464824735},{"Level":5,"Radius":1.0445812551367069,"X":0.7386304890075206,"Y":-3.6931524450376023,"Z":8.1249353790827268},{"Level":3,"Radius":2.139387691339814,"X":-7.5638777206670751,"Y":1.5127755441334152,"Z":-1.5127755441334152},{"Level":4,"Radius":0.37775486824598364,"X":-1.3355651448148294,"Y":0.2671130289629659,"Z":-0.2671130289629659},{"Level":5,"Radius":0.31876398046728993,"X":1.5778012053050583,"Y":-2.479401894050806,"Z":-2.9302022384236803},{"Level":5,"Radius":0.34576134060244468,"X":-2.6893920747335427,"Y":-1.2224509430607009,"Z":1.2224509430607009},{"Level":5,"Radius":0.31876398046728993,"X":1.5778012053050583,"Y":2.9302022384236803,"Z":2.479401894050806},{"Level":4,"Radius":1.4037600977966975,"X":0.992608284311136,"Y":-4.96304142155568,"Z":-6.94825799017795},{"Level":5,"Radius":0.19716227375982742,"X":0.13941478076973246,"Y":-0.6970739038486623,"Z":-0.97590346538812722},{"Level":5,"Radius":1.0445812551367069,"X":-3.6931524450376023,"Y":-8.1249353790827268,"Z":-0.7386304890075206},{"Level":5,"Radius":0.83175965498126991,"X":7.6458576006103094,"Y":4.1170002464824735,"Z":2.9407144617731955},{"Level":4,"Radius":1.4037600977966975,"X":0.992608284311136,"Y":6.94825799017795,"Z":4.96304142155568},{"Level":5,"Radius":0.19716227375982742,"X":0.13941478076973246,"Y":0.97590346538812722,"Z":0.6970739038486623},{"Level":5,"Radius":0.83175965498126991,"X":7.6458576006103094,"Y":-2.9407144617731955,"Z":-4.1170002464824735},{"Level":5,"Radius":1.1978243827074595,"X":-1.6939794873660703,"Y":8.469897436830351,"Z":1.6939794873660703},{"Level":5,"Radius":1.0445812551367069,"X":-3.6931524450376023,"Y":0.7386304890075206,"Z":8.1249353790827268},{"Level":3,"Radius":2.139387691339814,"X":1.5127755441334152,"Y":1.5127755441334152,"Z":7.5638777206670751},{"Level":4,"Radius":0.37775486824598364,"X":0.2671130289629659,"Y":0.2671130289629659,"Z":1.3355651448148294},{"Level":5,"Radius":0.31876398046728993,"X":2.9302022384236803,"Y":-2.479401894050806,"Z":-1.5778012053050583},{"Level":5,"Radius":0.31876398046728993,"X":-2.479401894050806,"Y":2.9302022384236803,"Z":-1.5778012053050583},{"Level":5,"Radius":0.34576134060244468,"X":-1.2224509430607009,"Y":-1.2224509430607009,"Z":2.6893920747335427},{"Level":4,"Radius":1.4037600977966975,"X":6.94825799017795,"Y":-4.96304142155568,"Z":-0.992608284311136},{"Level":5,"Radius":0.19716227375982742,"X":0.97590346538812722,"Y":-0.6970739038486623,"Z":-0.13941478076973246},{"Level":5,"Radius":0.83175965498126991,"X":-2.9407144617731955,"Y":4.1170002464824735,"Z":-7.6458576006103094},{"Level":5,"Radius":1.0445812551367069,"X":0.7386304890075206,"Y":-8.1249353790827268,"Z":3.6931524450376023},{"Level":4,"Radius":1.4037600977966975,"X":-4.96304142155568,"Y":6.94825799017795,"Z":-0.992608284311136},{"Level":5,"Radius":0.19716227375982742,"X":-0.6970739038486623,"Y":0.97590346538812722,"Z":-0.13941478076973246},{"Level":5,"Radius":0.83175965498126991,"X":4.1170002464824735,"Y":-2.9407144617731955,"Z":-7.6458576006103094},{"Level":5,"Radius":1.0445812551367069,"X":-8.1249353790827268,"Y":0.7386304890075206,"Z":3.6931524450376023},{"Level":1,"Radius":4.4948974278317806,"X":-3.1783724519578227,"Y":-3.1783724519578227,"Z":-3.1783724519578227},{"Level":2,"Radius":2.8989794855663567,"X":4.09977610552932,"Y":4.09977610552932,"Z":4.09977610552932},{"Level":3,"Radius":0.69693845669906873,"X":0.98561981760319706,"Y":0.98561981760319706,"Z":0.98561981760319706},{"Level":4,"Radius":0.59531041938993878,"X":3.367584275693067,"Y":-1.6837921378465335,"Z":-1.6837921378465335},{"Level":5,"Radius":0.361050735467887,"X":2.0424113872138658,"Y":-1.0212056936069329,"Z":-1.0212056936069329},{"Level":5,"Radius":0.46089451836521378,"X":-1.3036065573910018,"Y":2.6072131147820037,"Z":-5.2144262295640074},{"Level":5,"Radius":0.46089451836521378,"X":-1.3036065573910018,"Y":-5.2144262295640074,"Z":2.6072131147820037},{"Level":5,"Radius":0.51954937761543474,"X":5.1432764330237379,"Y":0.73475377614624837,"Z":0.73475377614624837},{"Level":4,"Radius":0.59531041938993878,"X":-1.6837921378465335,"Y":3.367584275693067,"Z":-1.6837921378465335},{"Level":5,"Radius":0.361050735467887,"X":-1.0212056936069329,"Y":2.0424113872138658,"Z":-1.0212056936069329},{"Level":5,"Radius":0.46089451836521378,"X":2.6072131147820037,"Y":-1.3036065573910018,"Z":-5.2144262295640074},{"Level":5,"Radius":0.46089451836521378,"X":-5.2144262295640074,"Y":-1.3036065573910018,"Z":2.6072131147820037},{"Level":5,"Radius":0.51954937761543474,"X":0.73475377614624837,"Y":5.1432764330237379,"Z":0.73475377614624837},{"Level":4,"Radius":0.59531041938993878,"X":-1.6837921378465335,"Y":-1.6837921378465335,"Z":3.367584275693067},{"Level":5,"Radius":0.361050735467887,"X":-1.0212056936069329,"Y":-1.0212056936069329,"Z":2.0424113872138658},{"Level":5,"Radius":0.46089451836521378,"X":2.6072131147820037,"Y":-5.2144262295640074,"Z":-1.3036065573910018},{"Level":5,"Radius":0.46089451836521378,"X":-5.2144262295640074,"Y":2.6072131147820037,"Z":-1.3036065573910018},{"Level":5,"Radius":0.51954937761543474,"X":0.73475377614624837,"Y":0.73475377614624837,"Z":5.1432764330237379},{"Level":3,"Radius":2.139387691339814,"X":7.5638777206670751,"Y":-1.5127755441334152,"Z":-1.5127755441334152},{"Level":4,"Radius":0.37775486824598364,"X":1.3355651448148294,"Y":-0.2671130289629659,"Z":-0.2671130289629659},{"Level":5,"Radius":0.31876398046728993,"X":-1.5778012053050583,"Y":2.479401894050806,"Z":-2.9302022384236803},{"Level":5,"Radius":0.31876398046728993,"X":-1.5778012053050583,"Y":-2.9302022384236803,"Z":2.479401894050806},{"Level":5,"Radius":0.34576134060244468,"X":2.6893920747335427,"Y":1.2224509430607009,"Z":1.2224509430607009},{"Level":4,"Radius":1.4037600977966975,"X":-0.992608284311136,"Y":4.96304142155568,"Z":-6.94825799017795},{"Level":5,"Radius":0.19716227375982742,"X":-0.13941478076973246,"Y":0.6970739038486623,"Z":-0.97590346538812722},{"Level":5,"Radius":1.1978243827074595,"X":1.6939794873660703,"Y":1.6939794873660703,"Z":-8.469897436830351},{"Level":5,"Radius":0.83175965498126991,"X":-7.6458576006103094,"Y":-4.1170002464824735,"Z":2.9407144617731955},{"Level":5,"Radius":1.0445812551367069,"X":3.6931524450376023,"Y":8.1249353790827268,"Z":-0.7386304890075206},{"Level":4,"Radius":1.4037600977966975,"X":-0.992608284311136,"Y":-6.94825799017795,"Z":4.96304142155568},{"Level":5,"Radius":0.19716227375982742,"X":-0.13941478076973246,"Y":-0.97590346538812722,"Z":0.6970739038486623},{"Level":5,"Radius":1.1978243827074595,"X":1.6939794873660703,"Y":-8.469897436830351,"Z":1.6939794873660703},{"Level":5,"Radius":0.83175965498126991,"X":-7.6458576006103094,"Y":2.9407144617731955,"Z":-4.1170002464824735},{"Level":5,"Radius":1.0445812551367069,"X":3.6931524450376023,"Y":-0.7386304890075206,"Z":8.1249353790827268},{"Level":3,"Radius":2.139387691339814,"X":-1.5127755441334152,"Y":7.5638777206670751,"Z":-1.5127755441334152},{"Level":4,"Radius":0.37775486824598364,"X":-0.2671130289629659,"Y":1.3355651448148294,"Z":-0.2671130289629659},{"Level":5,"Radius":0.31876398046728993,"X":2.479401894050806,"Y":-1.5778012053050583,"Z":-2.9302022384236803},{"Level":5,"Radius":0.31876398046728993,"X":-2.9302022384236803,"Y":-1.5778012053050583,"Z":2.479401894050806},{"Level":5,"Radius":0.34576134060244468,"X":1.2224509430607009,"Y":2.6893920747335427,"Z":1.2224509430607009},{"Level":4,"Radius":1.4037600977966975,"X":4.96304142155568,"Y":-0.992608284311136,"Z":-6.94825799017795},{"Level":5,"Radius":0.19716227375982742,"X":0.6970739038486623,"Y":-0.13941478076973246,"Z":-0.97590346538812722},{"Level":5,"Radius":0.83175965498126991,"X":-4.1170002464824735,"Y":-7.6458576006103094,"Z":2.9407144617731955},{"Level":5,"Radius":1.0445812551367069,"X":8.1249353790827268,"Y":3.6931524450376023,"Z":-0.7386304890075206},{"Level":4,"Radius":1.4037600977966975,"X":-6.94825799017795,"Y":-0.992608284311136,"Z":4.96304142155568},{"Level":5,"Radius":0.19716227375982742,"X":-0.97590346538812722,"Y":-0.13941478076973246,"Z":0.6970739038486623},{"Level":5,"Radius":0.83175965498126991,"X":2.9407144617731955,"Y":-7.6458576006103094,"Z":-4.1170002464824735},{"Level":5,"Radius":1.1978243827074595,"X":-8.469897436830351,"Y":1.6939794873660703,"Z":1.6939794873660703},{"Level":5,"Radius":1.0445812551367069,"X":-0.7386304890075206,"Y":3.6931524450376023,"Z":8.1249353790827268},{"Level":3,"Radius":2.139387691339814,"X":-1.5127755441334152,"Y":-1.5127755441334152,"Z":7.5638777206670751},{"Level":4,"Radius":0.37775486824598364,"X":-0.2671130289629659,"Y":-0.2671130289629659,"Z":1.3355651448148294},{"Level":5,"Radius":0.31876398046728993,"X":2.479401894050806,"Y":-2.9302022384236803,"Z":-1.5778012053050583},{"Level":5,"Radius":0.31876398046728993,"X":-2.9302022384236803,"Y":2.479401894050806,"Z":-1.5778012053050583},{"Level":5,"Radius":0.34576134060244468,"X":1.2224509430607009,"Y":1.2224509430607009,"Z":2.6893920747335427},{"Level":4,"Radius":1.4037600977966975,"X":4.96304142155568,"Y":-6.94825799017795,"Z":-0.992608284311136},{"Level":5,"Radius":0.19716227375982742,"X":0.6970739038486623,"Y":-0.97590346538812722,"Z":-0.13941478076973246},{"Level":5,"Radius":0.83175965498126991,"X":-4.1170002464824735,"Y":2.9407144617731955,"Z":-7.6458576006103094},{"Level":5,"Radius":1.0445812551367069,"X":8.1249353790827268,"Y":-0.7386304890075206,"Z":3.6931524450376023},{"Level":4,"Radius":1.4037600977966975,"X":-6.94825799017795,"Y":4.96304142155568,"Z":-0.992608284311136},{"Level":5,"Radius":0.19716227375982742,"X":-0.97590346538812722,"Y":0.6970739038486623,"Z":-0.13941478076973246},{"Level":5,"Radius":0.83175965498126991,"X":2.9407144617731955,"Y":-4.1170002464824735,"Z":-7.6458576006103094},{"Level":5,"Radius":1.0445812551367069,"X":-0.7386304890075206,"Y":8.1249353790827268,"Z":3.6931524450376023}]

The Circle and Sphere types have effectively been translated (via the names of their constructor arguments rather than their internal members, which is a little confusing) into the JSON text format.

That's all it took to expose our local web-service using the ASP.NET Web API - and that's with the "overhead" of needing a separate project for our (actually pretty simple) F# code. This is really a quantum leap forwards in terms of reducing the effort required to expose a RESTful web-service. It's also now relatively straightforward to move a local web-service such as this to be hosted in the cloud.

But let's not get ahead of ourselves: in the next post in this series, we’ll look at approaches for consuming the data returned from calling these APIs and generating equivalent geometry inside AutoCAD.

Exposing a RESTful web service for use inside AutoCAD using the ASP.NET Web API – Part 1

As promised, here begins the technical portion of the series on moving application functionality to the cloud.

As suggested, we’re going to take code from a couple of previous posts and put it in the cloud (although not immediately – first we’re going to move it to a local web-service, consume that in AutoCAD, and then look at our various cloud-hosting options).

So why did I choose these two pieces of code, in particular? A couple of reasons: firstly, they both implement “behind-the-scenes” algorithms that are independent of AutoCAD – a typical piece of business logic that companies might choose to place behind a web-service, in my opinion – and, secondly, they are both implemented in F#, which gives us an opportunity to abstract away technology from the user (it removes the need to deploy a separate class library built using F# from our application).

We’re going to use ASP.NET for this effort, which is Microsoft’s application framework for creating web-sites and applications. To expose our web-services (as opposed to a web-site), we’re going to make use of the ASP.NET Web API feature, which is brand new in the as-yet-unreleased ASP.NET MVC 4.

Let’s first resolve some acronyms…

ASP.NET is the .NET-based version of ASP, which standards for Active Server Pages rather than Application Service Provider.

ASP.NET MVC is a framework that sits on top of ASP.NET (which perhaps makes it a meta-framework or even a meta-meta-framework, if you consider the CLR :-) allowing web developers to use the Model-View-Controller architectural pattern (a type of design pattern) to implement web-sites. MVC encourages a clean separation of data (the model) from the way it is presented (the view) and interacted with (the controller).

It’s not specifically interesting to us in today’s post – where we’re simply using MVC 4 to get at the Web API feature – but it’s generally an interesting paradigm for web-site exposure.

And the hot news around MVC and the Web API is that they are now open source, which means you can browse and even contribute to the source, should you be so inclined.

So why use an unreleased (albeit open source) technology for this post? The short answer is that the Web API makes it incredibly easy to expose RESTful web-services. I’ve briefly mention REST a few times in the past, but it’s been a while. I fully expect to be making increasing use of web-services implementing REST over the coming years, though.

I won’t go into the steps needed to install ASP.NET MVC 4, but I will just say that there are a few different ways of getting it, right now: you can install the Beta for Visual Studio 2010, you can install Visual Studio 11 Express Beta for Web, or you can install Visual Studio 11 Ultimate Beta. I was a little unlucky, in that I had Visual Studio 11 Professional Beta installed – which meant I lost some time trying to install MVC 4 Beta on to of it, before I realised I actually needed to upgrade to Ultimate – but I got there in the end. One thing to bear in mind for later: at the time of writing it seems the Windows Azure .NET SDK doesn’t support Visual Studio 11, so I may have some hurdles to face when I get to that point. So sticking with VS2010 may prove the best option, for those of you who haven’t yet gone with VS11 (they can sit side-by-side, anyway, which is how I’ll probably manage the Azure deployment).

With MVC 4 installed, I went ahead and looked at the project types to create. If you want a good foundational article on using the Web API to use C# to expose web-services, take a look at this one. In our case, we want to use F# on the server, so I ended up choosing an online project template that gives us both C# and F# in an MVC 4 app:

We then get to specify that we want an Web API project and that we don’t (for the purposes of this simple example) care about testing:

This creates some nice boilerplate code that makes it really easy to expose our web-services. In the next post we’ll flesh out this project, hooking it up with our existing F# code to expose a couple of web-services for consumption inside our AutoCAD application.