import java.util.{Properties, UUID}
import org.apache.kafka.clients.consumer.ConsumerRecord
import org.apache.kafka.clients.producer._
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.spark._
import org.apache.spark.rdd._
import org.apache.spark.streaming._
import org.apache.spark.streaming.dstream._
import org.apache.spark.streaming.kafka010._
import org.apache.spark.streaming.kafka010.LocationStrategies.PreferConsistent
import org.apache.spark.streaming.kafka010.ConsumerStrategies.Subscribe
import org.scalatest._
import org.scalatest.concurrent.AsyncAssertions._
import org.scalatest.concurrent.PatienceConfiguration._
import org.scalatest.concurrent.TimeLimitedTests
import org.scalatest.time.Span

final class SparkTests extends FunSuite with TimeLimitedTests {

  private val CONSUMPTION_TIMEOUT_UNITS: Int = 10
  private val COUNT_CONSUMER_THREADS: Int = 1

  private val KAFKA_AUTO_OFFSET_RESET_LATEST : String = "latest"
  private val KAFKA_MESSAGE_BROKER: String = "localhost:9092"
  private val KAFKA_MESSAGE_ACKNOWLEDGEMENTS_LEADER: String = "1"
  private val KAFKA_DESERIALIZER_STRING: Object = classOf[StringDeserializer]
  private val KAFKA_SERIALIZER_STRING: String = "org.apache.kafka.common.serialization.StringSerializer"
  private val KAFKA_TOPIC: String = "test"
  private val KAFKA_DISABLE_AUTO_COMMIT: java.lang.Boolean = false

  private val KAFKA_PROPERTY_KEY_AUTO_OFFSET_RESET: String = "auto.offset.reset"
  private val KAFKA_PROPERTY_KEY_BROKER_ACKNOWLEDGEMENTS: String = "acks"
  private val KAFKA_PROPERTY_KEY_BOOTSTRAP_SERVERS: String = "bootstrap.servers"
  private val KAFKA_PROPERTY_KEY_ENABLE_AUTO_COMMIT: String = "enable.auto.commit"
  private val KAFKA_PROPERTY_KEY_GROUP_IDENTIFIER: String = "group.id"
  private val KAFKA_PROPERTY_KEY_DESERIALIZER_KEYS: String = "key.deserializer"
  private val KAFKA_PROPERTY_KEY_DESERIALIZER_VALUES: String = "value.deserializer"
  private val KAFKA_PROPERTY_KEY_SERIALIZER_KEYS: String = "key.serializer"
  private val KAFKA_PROPERTY_KEY_SERIALIZER_VALUES: String = "value.serializer"

  private val SPARK_BATCH_DURATION: Duration = Seconds(10)
  private val SPARK_MASTER_NODE: String = "local[*]"
  private val SPARK_CHECKPOINT = "SparkStreamingTestsCheckpoint"

  private val TIME_LIMIT_UNITS: Int = CONSUMPTION_TIMEOUT_UNITS * 2
  private val ZOOKEEPER: String = "localhost:2181"

  private val kafkaConsumerParametersDirect: Map[String, Object] = Map[String, Object](
    (KAFKA_PROPERTY_KEY_BOOTSTRAP_SERVERS, KAFKA_MESSAGE_BROKER),
    (KAFKA_PROPERTY_KEY_DESERIALIZER_KEYS, KAFKA_DESERIALIZER_STRING),
    (KAFKA_PROPERTY_KEY_DESERIALIZER_VALUES, KAFKA_DESERIALIZER_STRING),
    (KAFKA_PROPERTY_KEY_GROUP_IDENTIFIER, UUID.randomUUID.toString),
    (KAFKA_PROPERTY_KEY_AUTO_OFFSET_RESET, KAFKA_AUTO_OFFSET_RESET_LATEST),
    (KAFKA_PROPERTY_KEY_ENABLE_AUTO_COMMIT, KAFKA_DISABLE_AUTO_COMMIT))

  private val kafkaProducerProperties: Properties = {
    val result: Properties = new Properties()
    result.put(KAFKA_PROPERTY_KEY_BOOTSTRAP_SERVERS, KAFKA_MESSAGE_BROKER)
    result.put(KAFKA_PROPERTY_KEY_SERIALIZER_KEYS, KAFKA_SERIALIZER_STRING)
    result.put(KAFKA_PROPERTY_KEY_SERIALIZER_VALUES, KAFKA_SERIALIZER_STRING)
    result.put(KAFKA_PROPERTY_KEY_BROKER_ACKNOWLEDGEMENTS, KAFKA_MESSAGE_ACKNOWLEDGEMENTS_LEADER)
    result
  }

  private lazy val kafkaProducer: KafkaProducer[String, String] = new KafkaProducer(kafkaProducerProperties)

  private lazy val sparkConfiguration: SparkConf = {
    new SparkConf()
    .setMaster(SPARK_MASTER_NODE)
    .setAppName(UUID.randomUUID.toString)
    .setJars(SparkContext.jarOfClass(this.getClass).toSeq)
  }
  private lazy val sparkConsumerStrategy: ConsumerStrategy[String, String] =
    Subscribe[String, String](Array(KAFKA_TOPIC), kafkaConsumerParametersDirect)

  private lazy val sparkStreamingContext: StreamingContext =
    new StreamingContext(sparkConfiguration, SPARK_BATCH_DURATION)

  private val sparkLocationStrategy: LocationStrategy = PreferConsistent

  private val sparkOffsetRanges: Array[OffsetRange] = Array(OffsetRange(KAFKA_TOPIC, 0, 0, 100))

  val timeLimit = Span(TIME_LIMIT_UNITS, org.scalatest.time.Seconds)

  object WaiterSink {
    val waiter: Waiter = new Waiter

    def apply(): Waiter = waiter
  }
  test("A message can be received via a direct stream") {
    assert(Option(sparkStreamingContext).isDefined)
    assert(Option(sparkConsumerStrategy).isDefined)
    assert(Option(kafkaProducer).isDefined)

    val recordValue: String = UUID.randomUUID.toString

    val waiter: Waiter = new Waiter

    val stream: InputDStream[ConsumerRecord[String, String]] =
      KafkaUtils.createDirectStream[String, String](
        sparkStreamingContext,
        sparkLocationStrategy,
        sparkConsumerStrategy)
    val discretizedStream: DStream[(String, String)] =
          stream.map(
            (item: ConsumerRecord[String, String]) =>
              (item.key, item.value))

    val recordFunction: ((String, String)) => Unit =
      (record: (String, String)) => {
        if (recordValue == record._2) {
          WaiterSink().dismiss()
        }
      }
    val outputFunction: (RDD[(String, String)]) => Unit =
      (dataset: RDD[(String, String)]) => {
        dataset.foreach(recordFunction)
      }
    discretizedStream.foreachRDD(outputFunction)

    try {
      sparkStreamingContext.start

      val record: ProducerRecord[String, String] =
        new ProducerRecord[String, String](
          KAFKA_TOPIC,
          recordValue)
      val metadata: RecordMetadata = kafkaProducer.send(record).get()
      assert(Option(metadata).isDefined)

      WaiterSink().await(Timeout(Span(CONSUMPTION_TIMEOUT_UNITS, org.scalatest.time.Seconds)))
    }
    finally {
      sparkStreamingContext.stop(true)
    }
  }
}

I toggled the virtualization support on and off and confirmed that it was indeed having that setting on that led the USB devices to not be detected.  And yes, I ensured that I had flashed up to the latest BIOS. 

When I set about finding a solution, I discovered that it was not just developers like myself that were encountering the disappearing devices problem.  I gather from TechNet that, especially of late, folk are having the miserable experience of turning on their Windows 8 laptops and desktops and finding that they have no keyboard or mouse control.  Only those among them with touch screens are able to log-on! 

Someone had posted a fix to the TechNet thread, which seems to also work for my case.  In the Control Panel, under Power Settings, select the option of choosing what the power button does.  Disable the "Fast Startup" option. 

Of course, I was able to get my mouse and keyboard back by turning off virtualization in order to be able to manipulate this setting.  I'd be very much inclined to recommend disabling Fast Startup on any Windows 8 PC while one still has devices to control it. 

While Skyfall is
not as bad as Quantum of Solace was
and while it might be a fine action thriller, it’s not a good James Bond
movie.  What’s the standard by which one
can make such an assessment?  Well, I
think we can quickly agree that any of the Eon Sean Connery films set the
standard.  We’d probably debate what else
belongs in that pantheon.  I’d certainly
include a great many other films that I consider superior, including On her Majesty’s Secret Service, Live and Let Die, For Your Eyes Only, The
Living Daylights, Goldeneye, The World is Not Enough and Eon’s Casino Royale. 

What might we distill from among those to be the requirements
for a good James Bond film?  I propose
that the foremost criterion is that a good James Bond movie incorporates ideas
that are not found in other films of the era. 
I found none of those in Skyfall
and by that criterion, I dismiss it as an inferior James Bond film.  An excellent example of the sort of novel
idea that is entirely missing from Skyfall
is the frogman fight in Thunderball.  Scuba-diving was not science fiction when the
latter film was made; anyone of moderate means could go scuba diving.  The idea of having dozens of scuba-divers
battle each other underwater, though, was ingenious and, I surmise, devilishly
hard to film at the time.  By contrast, a
motorcycle chase over the rooftops of Istanbul is not conceptually
brilliant.  In fact, it feels like
something that was done at least as well in a Jason Bourne movie; the second
one, if I remember correctly. 

A reasonable counter-proposition might be that although the
Eon Casino Royale is generally
accepted as one of the finest Bond films, it actually doesn’t have any of those
sorts of ideas.  That might be true,
although Le Chiffre’s predicament arguably qualifies and so does Vespa’s betrayal,
which is the reason for the Bond’s progressive mental deterioration and
misogyny in the novels.  And what
certainly qualifies as a remarkable idea was the whole notion of making a Bond
film with brutally-realistic hand-to-hand combat and showing the agent at the
outset of his career.  Unfortunately, it
turns out that’s not enough of an idea to power Quantum of Solace and Skyfall
as well. 

Something else that was remarkable in the original Bond
movies was a particular character trait of Bond himself.  He loved to kill his opponents.  To do so was to triumph, and he relished
that.  Look at the smirk on Connery’s
face when he kills Professor Dent in Dr.
No.  There had been anti-heroes in
film before James Bond, but never one who was presented quite so heroically
while being that brutal.  Daniel Craig
incorporates something of that attitude into his performance, but it’s a different
nuance.  In his performance, the response
to killing is more one that conveys surprise at being the one that
survived.  That’s interesting, but not
interesting enough.  Craig’s Bond is also
written as being too much of a hero.  At
the beginning of Skyfall, for
example, he hesitates over a wounded colleague. 
That plot point is relevant with respect to M’s behavior in that scene,
and M’s behavior is what Skyfall is
all about.  But a compassionate James
Bond is not a memorable or interesting as the refined brute.  The brute was even present in Roger Moore’s
version.  After bedding a woman in Live and Let Die, he kills her and as he’s
about to do that, she protests: ”You wouldn’t kill me after what we’ve just
done!”  “Well, I certainly wouldn’t do it
before,” Bond replies as he pulls the trigger. 

Now Eon’s Casino
Royale was the James Bond film that most closely followed the plot of the
original Fleming novel, other than From
Russia with Love and, of course, Thunderball,
where the novel was written for the screen. 
After seeing that film, which I consider to be one of the very finest of
the series, I thought it would be a wonderful idea for Eon to now proceed with
a series of movies that filmed the books, using their new approach of very
realistic violence rather than the science fiction and even comic action that
had become a hallmark of the franchise. 

Did you know that, with Skyfall,
they’re essentially doing just that?  Yes,
Skyfall is a more faithful movie
version of the novel, The Man with the
Golden Gun than the Roger Moore film with title. 

Now, let’s say that one decided to go back to the original
texts and bring them to the screen using the rich yet muted palate of Casino Royale.  Would one naturally start with the novel that
was least well-received, having been published posthumously from an early Ian
Fleming draft?  Even if one might dismiss
the quality of the novel given that one would be adapting it anyway, lifting
only the essential plot elements, might not the earlier Golden Gun film given one pause? 
As bad as Quantum of Solace
was and as bad as License to Kill was,
I propose that we can quickly agree that The
Man with the Golden Gun is certainly the worst James Bond movie. 

But there it is.  Skyfall is a filmed representation of
Fleming’s novel, The Man with the Golden
Gun.  In the beginning of the book,
Bond is presumed dead, just as he is in Skyfall.  When he returns, his fitness for duty is
questioned in both treatments.  In the
book, a former double-o agent returns from a disappearance and attempts to kill
M.  Bond is that agent in the novel,
whereas in the film, it’s Mr. Silver.  In
the book, Bond must stop the killing of British agents, which is precisely his
mission in Skyfall.  The assassin in the novel is identified by
his unique choice of weapon and ammunition. 
An assassin in Skyfall is
identified by his unique bullets.  In the
book, Bond catches up with the principal villain on an island he’s taken over,
which is exactly the setting in which Bond finds Mr. Silver in the movie.  Just in case aficionados might have missed
these hints, some additional ones are provided by which Skyfall references the earlier Golden
Gun film.  In both movies, Bond
visits Macau and proceeds from there to an island in the South China Sea.  And in the climax of both films, someone dies
because although they shoot first, they’re shooting at a mirror image of their nemesis. 

I can only suppose that, if one wants to reboot the franchise
by going back to the original texts then it might have been considered less
riskly to do so with one of the least well-known plots than it would have been
to redo From Russia with Love, for
example.  Still, I would have thought Golden Gun would have been toxic
material to reference.  Could it possibly
have come up in the pitch meeting? 
Surely the Eon folk have an encyclopedic knowledge of the pantheon and recognized
the intention. 

For all of my disappointment with Skyfall, I wouldn’t hesitate to say that it’s a fine action
thriller.  In particular, Bond’s scene
with Séverine in the bar is extremely well
written and masterfully acted.  Watching
that scene made me expect that I would end up feeling delighted by the
movie.  Then a subway train crashed
through a ceiling and I knew it is was hopeless and just wanted it to be
over. 

A fine action thriller doesn’t
nearly qualify as a good James Bond film; otherwise, License to Kill would not be close to the bottom of every Bond film’s
list.  All the good James Bond films rely
on novel ideas for their effect, and Skyfall
doesn’t have any of those. 

When I learned the craft originally, I'd found "Instant HTML Programmer's Reference: HTML 4.0 Edition," by Alex Homer, Chris Ullman and Steve Wright, to be an excellent resource.  I still have a very, very battered copy of it always handy. 

However, now that I've found myself writing a stylesheet again after several years of not having to do that, I wanted to refresh myself, and carted home several books from Barnes and Noble that looked useful.  The one that looked best in the store turned out to be a fantastic choice.  It's Jon Duckett's "HTML & CSS: Design and Build Websites," published by Wiley. 

Why is it excellent?  Well, the author doesn't just identify all of the CSS properties and values with examples of the effects--which a lot of texts on the subject do.  Duckett does more.  He identifies the fundamentals, such as block and inline elements, which are implicit in the technology, and layers his account of each property and value on that foundation.  Then he tops it off by presenting state-of-the-art advice and useful techniques. 

As other reviewers of the book have mentioned, the thing also looks gorgeous.  Duckett himself is credited as a designer along with Emme Stone. 

I was going to post this review where I thought it would have the most effect, on Amazon.com, but there I was surpised to find that the book is only available through the marketplace and not sold directly by the world's biggest bookseller.  That's unfortunate.  I think everyone that has anything to do with getting pages up on the Web would benefit from owning Jon Duckett's book. 

The first step is to download the remote icon to a local file.  Here is a function for doing that:

void WebResource::Download()

{

       if(!(this->uniqueIdentifier))

       {

              ::AfxThrowNotSupportedException();

       }

       CFile fileLocal(this->fileName,CFile::modeWrite|CFile::modeCreate);

       const UINT BufferSize = Constants::BufferSizeInBytesDownload;

       char* buffer = new char[BufferSize];

       if(!(buffer))

       {

              THROW(new CMemoryException());

       }

       CInternetSession session;

       CStdioFile* fileRemote = session.OpenURL(this->GetLocator());

       if(!(fileRemote))

       {

              Exception::Throw(IDS_ERROR_DOWNLOAD_TARGET_TEMPLATE,this->GetLocator());

       }

       UINT downloaded = 0;

       BOOL result = TRUE;

       try

       {

              do

              {

                     ::ZeroMemory(buffer,BufferSize);

                     downloaded = fileRemote->Read(buffer,BufferSize);

                     if(downloaded <= 0)

                     {

                           break;

                     }

                     fileLocal.Write(buffer,downloaded);

                     if(downloaded < BufferSize)

                     {

                           break;

                     }

              }

              while(TRUE);

       }

       catch(...)

       {

              result = FALSE;

       }  

       if(fileRemote)

       {

              delete fileRemote;

       };

       if(buffer)

       {

              delete [] buffer;

       }

       if(!(result))

       {

              Exception::Throw(IDS_ERROR_DOWNLOAD_TEMPLATE,this->GetLocator());

       }

}

The next step is to load the icon from the local file.  Here is a function that accomplishes that task: 

HICON WebResource::GetIcon()

{

       if(!(this->icon))

       {

              if(!(::PathFileExistsW(this->fileName)))

              {

                     this->Download();

              } 

              this->icon = (HICON)::LoadImage(

                                                       NULL,

                                                       this->fileName,

                                                       IMAGE_ICON,

                                                       Constants::HeightWidthIcon, //16

                                                       Constants::HeightWidthIcon,

                                                       LR_CREATEDIBSECTION|LR_LOADMAP3DCOLORS|LR_LOADFROMFILE|LR_SHARED|LR_VGACOLOR); 

       }

       return this->icon;

}

Note that the desired height and width of the icon are specified.  If the .ico file happens to include icons of different dimensions, then specifying the desired height and width will ensure that the preferred one will be loaded. 

The last step is to paint the icon.  Here is the implementation of OnPaint that accomplishes that:

void Tab::OnPaint()

{

       CPaintDC deviceContext(this);

       CRect area;

       this->GetClientRect(&area);

       this->displayBehavior->DisplayTab(&deviceContext,&area);

       WebResource* iconResource = webResource->GetIconResource();

       if(iconResource)

       {

              this->PaintIcon(&deviceContext,iconResource);

       }

       deviceContext.SelectObject(this->font);

       deviceContext.SetBkMode(TRANSPARENT);

       deviceContext.SetTextColor(this->colorText);

       deviceContext.DrawText(this->webResource->GetLocator(),&this->areaLabel,Tab::StyleText);

}

void Tab::PaintIcon(CDC* deviceContext, WebResource* iconResource)

{

       if(!(iconResource))

       {

              return;

       }

       try

       {

              if(!(this->icon))

              {

                     this->icon = new Icon();

                     if(!(this->icon))

                     {

                           return;

                     }

                     if(!(this->icon->Create(deviceContext, this->iconHandle,this->colorBackground)))

                     {

                           this->InvalidateIcon();

                           return;

                     }

              }

              if(this->icon)

              {

                     CDC* memoryContext = this->icon->GetDeviceContext();

                     if(memoryContext)

                     {

                           deviceContext->BitBlt(this->areaIcon.left,this->areaIcon.top,Constants::HeightWidthIcon,Constants::HeightWidthIcon,memoryContext,0,0,SRCCOPY);

                     }

              }

       }

       catch(...)

       {

              return;

       }

}

Tab::Icon::Icon()

{

       this->InvalidateDeviceContext();

}

Tab::Icon::~Icon()

{

       this->DeleteDeviceContext();

}

BOOL Tab::Icon::Create(CDC* targetContext, HICON iconHandle, COLORREF backgroundColor)

{

       BOOL result = FALSE;

       this->InvalidateDeviceContext();

       this->backgroundBrush.CreateSolidBrush(backgroundColor);

       while(!(result))

       {

              CBitmap iconBitmap;

              if(!(iconBitmap.CreateCompatibleBitmap(targetContext,Constants::HeightWidthIcon,Constants::HeightWidthIcon)))

              {

                     break;

              }

              this->deviceContext = new CDC();

              this->deviceContext->CreateCompatibleDC(targetContext);

              CBitmap* originalBitmap = this->deviceContext->SelectObject(&iconBitmap);

              HGDIOBJ originalBrush = this->deviceContext->SelectObject(this->backgroundBrush);

              if(!(this->deviceContext->PatBlt(0, 0, Constants::HeightWidthIcon, Constants::HeightWidthIcon,PATCOPY)))

              {

                     break;

              }

              if(!(this->deviceContext->DrawState(

                     CPoint(0,0),

                     CSize(Constants::HeightWidthIcon,Constants::HeightWidthIcon),

                     iconHandle,

                     DST_ICON|DSS_NORMAL,

                     (HBRUSH)NULL)))

              {

                     break;

              }

              result = TRUE;

       }

       if(!(result))

       {

              this->InvalidateDeviceContext();

       }

       return result;

}

void Tab::Icon::DeleteDeviceContext()

{

       if(this->deviceContext)

       {

              if(this->originalBrush)

              {

                     (void)this->deviceContext->SelectObject(this->originalBrush);

              }

              if(this->originalBitmap)

              {

                     (void)this->deviceContext->SelectObject(this->originalBitmap);

              }

              delete this->deviceContext;

       }

}

void Tab::Icon::InvalidateDeviceContext()

{

       this->deviceContext = NULL;

       this->originalBitmap = NULL;

}

CDC* Tab::Icon::GetDeviceContext()

{

       return this->deviceContext;

}

Here is what happens.  First, a bitmap is created that is compatible with the CPaintDC, the full-color screen device context onto which the icon is to be painted:

CBitmap iconBitmap;

if(!(iconBitmap.CreateCompatibleBitmap(targetContext,Constants::HeightWidthIcon,Constants::HeightWidthIcon)))

Then a device context that will serve as the buffer of the painted icon is created:

this->deviceContext = new CDC();

this->deviceContext->CreateCompatibleDC(targetContext);

Next, within that buffer, the bitmap is painted with the background color, and then with the icon:

                                 CBitmap* originalBitmap = this->deviceContext->SelectObject(&iconBitmap);

          HGDIOBJ originalBrush = this->deviceContext->SelectObject(this->backgroundBrush);

              if(!(this->deviceContext->PatBlt(0, 0, Constants::HeightWidthIcon, Constants::HeightWidthIcon,PATCOPY)))

              {

                     break;

              }

              if(!(this->deviceContext->DrawState(

                     CPoint(0,0),

                     CSize(Constants::HeightWidthIcon,Constants::HeightWidthIcon),

                     iconHandle,

                     DST_ICON|DSS_NORMAL,

                     (HBRUSH)NULL)))

              {

                     break;

              }

Finally, the buffer is swapped onto the CPaintDC:

deviceContext->BitBlt(this->areaIcon.left,this->areaIcon.top,Constants::HeightWidthIcon,Constants::HeightWidthIcon,memoryContext,0,0,SRCCOPY); //deviceContext is CPaintDC, whereas memoryContext is the CDC* buffer. 

this->MoveWindow(area.left,area.top,area.Width(),area.Height(),FALSE);

this->RedrawWindow(area,NULL,RDW_UPDATENOW|RDW_ALLCHILDREN);

using System;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Description;
using System.ServiceModel.Web;

namespace Server
{
    [DataContract]
    public class Some
    {
        [DataMember]
        public string What;

        [DataMember]
        public string Why;
    }

    [ServiceContract]
    [JavascriptCallbackBehavior(UrlParameterName="method")]
    class MyService
    {
        [OperationContract]
        [WebGet(ResponseFormat = WebMessageFormat.Json)]
        public Some GetSome(string input)
        {
            return new Some() { What = "A Shotgun", Why = "Needs an Outcome" };
        }
    }

    class Program
    {
        const string BaseAddress = "https://localhost:8888/MyService/";
        const string EndpointAddress = "MyEndpoint";

        static void Main(string[] args)
        {
           
            using(ServiceHostBase serviceHost = new ServiceHost(typeof(MyService),new Uri[]{new Uri(Program.BaseAddress)}))
            {
                WebHttpBinding binding = new WebHttpBinding();
                binding.CrossDomainScriptAccessEnabled = true;
                ServiceEndpoint endpoint = serviceHost.AddServiceEndpoint("Server.MyService", binding, Program.EndpointAddress);
                WebHttpBehavior behavior = new WebHttpBehavior();
                WebScriptEnablingBehavior scripting = new WebScriptEnablingBehavior();
                endpoint.Behaviors.Add(behavior);
                endpoint.Behaviors.Add(scripting);
                serviceHost.Open();
                Console.WriteLine("Press <ENTER> to terminate this program.");
                Console.ReadLine();
            }
        }
    }
}

And here is the HTML page that you can open in the current version of any major browser to see the output from the service:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="https://www.w3.org/1999/xhtml" >
<head>
    <title>Untitled Page</title>
    <script src="https://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.5.1.js" type="text/javascript"></script>
    <script type="text/javascript">
        function callback(data) {
            alert("Like a " + data.What + " " + data.Why);
        }
        $(document).ready(
            function () {
                $("<p>Hello, I am Dynamic Text!</p>").appendTo("body");
                $("<p>Attempt</p>").appendTo("body");
                $.getJSON("https://localhost:8888/MyService/MyEndpoint/GetSome?method=?", callback);
                $("<p>Done</p>").appendTo("body");
            }
        );
    </script>
</head>
<body>

</body>

</html>

using System;

using System.Globalization;

using System.IO;

using System.Linq;

using System.Net;

using System.Runtime.Serialization;

using System.Runtime.Serialization.Json;

using System.Windows.Forms;

namespace LiveID

{

    public partial class Form1 : Form

    {

        const string ApplicationIdentifier = "0000000000000000"; //YOUR APPLICATION IDENTIFIER GOES HERE

        const string AuthenticationHost = "oauth.live.com";

        const string AuthenticationLocalPathDesktop = "/desktop";

        const string AuthenticationResourceTemplate = @"https://{0}/authorize?client_id={1}&response_type=token&scope=wl.signin%20wl.basic&redirect_uri=https://{0}{2}";

        const string ContentTypeText = "application/text";

        const string KeyAccessToken = "#access_token";

        const string MethodGet = "GET";

        const string ResultTemplate = "User Name: {0}; Identifier {1}";

        const char SeperatorQuery = '&';

        const string UserResourceTemplate = "https://apis.live.net/v5.0/me?{0}";       

        public Form1()

        {

            InitializeComponent();

        }

        private void Form1_Load(object sender, EventArgs e)

        {

            this.webBrowser1.Url =

                new Uri(

                    string.Format(

                        CultureInfo.InvariantCulture,

                        Form1.AuthenticationResourceTemplate,

                        Form1.AuthenticationHost,

                        Form1.ApplicationIdentifier,

                        Form1.AuthenticationLocalPathDesktop));

        }

        private void webBrowser1_Navigating(object sender, WebBrowserNavigatingEventArgs e)

        {

            Uri location = e.Url;

            if ((location.Host == Form1.AuthenticationHost) && (location.LocalPath == Form1.AuthenticationLocalPathDesktop))

            {

                string[] fragments = location.Fragment.Split(Form1.SeperatorQuery);

                string token = fragments.Where((string item) => item.StartsWith(Form1.KeyAccessToken)).FirstOrDefault();

                if (!(string.IsNullOrEmpty(token)))

                {

                    WebRequest request = WebRequest.Create(new Uri(string.Format(CultureInfo.InvariantCulture,Form1.UserResourceTemplate,token.Substring(1))));

                    request.Method = MethodGet;

                    using(Stream responseStream = request.GetResponse().GetResponseStream())

                    {

                        request.ContentType = Form1.ContentTypeText;

                        User user = (User)new DataContractJsonSerializer(typeof(User)).ReadObject(responseStream);

                        this.textBox1.Text = string.Format(CultureInfo.CurrentUICulture,Form1.ResultTemplate,user.Name,user.Identifier);

                    }

                }

            }

        }

    }

    [DataContract]

    partial class User : IExtensibleDataObject

    {

        ExtensionDataObject extendedData;

        [DataMember(Name = "id")]

        internal string Identifier

        {

            get;

            set;

        }

        [DataMember(Name = "name")]

        internal string Name

        {

            get;

            set;

        }

        public ExtensionDataObject ExtensionData

        {

            get

            {

                return this.extendedData;

            }

            set

            {

                this.extendedData = value;

            }

        }

    }

}

Anyone who has read Jacques Derrida will note with interest how Google's computer scientists have arrived at the same perspective on semantics that philosophers did with Derrida's publication of On Grammatology: that meaning is not complete at the current location in a stream of language, but is always only being completed by the subsequent location.  Derrida, of course, called this essential aspect of semantics "differance." 

In the next paragraph of In the Plex, the engineers speculate on the prospect of the machine ascending to artificial intelligence by using the repository of data at its disposal to acquire more knowledge and linguistic understanding.  That's the point at which their thinking departs from Derrida's. 

They're absolutely right to recognize that intelligence is linguistic, that it is demonstrated by fundamentally linguistic capabilities.  What computer scientists generally don't see is that the use of language, and therefore, the capacity for intelligence is essentially organic. 

That's because the use of language is driven by desire.  If the meaning of a stream of language is always within the context of what comes next in that stream, then it is desire that drives a user of that language onward in that stream. 

An understanding of the nature of that desire is to be found somewhere between the writings of Karl Marx, Charles Darwin and the early Jean Baudrillard: most likely the latter.  Jacques Lacan explained how desire draws infants into language. 

Machines have no desire.  So while they can be made to appear as if they have linguistic capability, they simply don't.  They may be able to take a stream of language as input, and predict how that stream will continue, but they will never care about whether the stream actually does continue or not. 

So we can program machines to win at poker or chess.  We can't make they care about winning or losing, though, and therefore, we can't ever make them play those games or any others, just make the moves. 

That's why I find "artificial intelligence" to be an oxymoronic term.  Intelligence is linguistic and linguistic capability is irreducibly organic.  Nothing about intelligence is artificial, and nothing artificial can be intelligent.