Specific Occupy Sites

• Occupy Wall Street

• Occupy Boston

• Occupy Together

• Occupy Colleges

• Occupy Maine

• Occupy Women

• Occupy LA

Alternative Press & Blogs With Occupy Wall Street Coverage

• The Street Spirit

• Democracy Now

• Truth Dig

• Truth Out

• AlterNet

• Counterpunch

You Tube

Chris Hedges and Amy Goodman

Michael Moore

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

#Occupy Bat Signal

RESTful GET Requests in WCF

Part I: Overview and Serialization

Part II: WCF Endpoints (This Post)

Part III: Implementing WCF Endpoints

WCF for REST provides a strong set of tools to develop HTTP Endpoints in a RESTful manner, optimized for being called by Browsers and returning JSON in the response body.  In this post will will look at how to develop WCF RESTful endpoint to respond to HTTP GET request.  Our emphasis will be on:

• Serialization
  • XML
  • JSON
  • Text
• Header processing
  • Accept Headers
• Dynamic HTTP Endpoint creation
  • Simple methods to make endpoints visible
• Ease of Development
  • Consistency
  • Clarity

We will not deal in this post with HTTP POST or with security  (authentication and authorization) issues.  From 10,000 feet the processing tasks preformed during and HTTP GET request are:

• Authentication
• Header Processing
• Passing Control to a a Worker object
  • Authorization
  • return a generic Object To the HTTP Get Processor
• Error Processing
• Serialization
  • Based on Accept Header Arguments

IIS (Microsoft’s Web Server) handles HTTP request using HTTP.SYS (IIS 6, IIS 7).  IIS handles requests as a stream the key process in which the key developer hook into the system is with the method call:

public Message AllURIs( Message msg ) where Message is defined  as:

using System;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Xml;

namespace System.ServiceModel.Channels
{
// Summary:  Represents the unit of communication between endpoints in a distributed environment.
public abstract class Message : IDisposable
{…}

…

}

Note dear reader that Message is an object which represents a SOAP envelope.  RESTful WCF allows us to generate a non-SOAP response type and eliminating the overhead of the XML SOAP envelop and return pure  XML, JSON or Text.  Our task is to create our own ALLURIs method which will return a Message class of our own design.  When a request is in the stream and (our version of) ALLURIs is called the request is running in a particular Context. The following calls make this context available to us:

WebOperationContext webCtx = webCtx = WebOperationContext.Current;
IncomingWebRequestContext requestCTX=webCtx.IncomingRequest;
OutgoingWebResponseContext  outgoingCtx = webCtx.OutgoingResponse;

IncomingWebRequestContext.Method allows us to access what type of request we are processing (GET, POST, etc).

IncomingWebRequestContext.Headers allows us to access the Headers associated with the request.

IncomingWebRequestContext.UriTemplateMatch.QueryParameters allows us to access the query parameters associated with the request.

To process any incoming message our first tasks will be to confirm the request type (i.e. An HTTP GET request) and handle an invalid request type appropriately.  A typical error response is to set the HTTP Status Code to a well defined value and return a null Message object.

if ( requestCTX.Method != “GET” )
{
outgoingCtx.StatusCode = System.Net.HttpStatusCode.BadRequest;

               return null;

}

Accept Headers

Our next task is to process any request Headers which are important to us.  In our case we want to process the Accept Header to see how we will serialize the output object.  We can locate the Accept header several ways, but WCF provides a helper method to ease the process:

IncomingWebRequestContext.Accept

Accept headers contain a list of acceptable formats of the response body (our Message class) as defined my the caller (typically the Browser).  These are known as MIME Types and fall into three categories:  well known types (such as application/xhtml+xml, vendor defined types (like application/vnd.myformat) and the generic “give me anything” type (*/*). An accept header is NOT mandatory and the Accept header may (often will) contain more than one MIME type.  WCF does not provide a helper function to parse the Accept Header but since it is a simple coma delimited string we can call a string.Split function to get an array of string accept values. Once we know what responses the caller (browser) can accept our job is to return our C# object in the proper serialized form.  I will discuss three serialization, JSON (application/json), XML (application/xml+xhtml) and text(text/plain). We assume here that the C# object to be serialized has been annotated with the appropriate DataContract and XML Attributes (See Part I).  Our basic tool is the Message method CreateMessage. This method is overloaded and we will use this form:

public static Message CreateMessage(
	MessageVersion version,
	string action,
	Object body,
	XmlObjectSerializer serializer
)

Let cObject represent the object we wish to serialize our basic calls is:

Message msg=Message.CreateMessage(MessageVersion.None,”*”,cObject,{our serializer goes here});

So our goal now is to create a serializer for each of the types we wish to support. Lets start with the JSON serializer (have you been waiting all this time for this?):

private static XmlObjectSerializer _JSONSerializer( object msg )
{
WebBodyFormatMessageProperty formatter=new WebBodyFormatMessageProperty( WebContentFormat.Json );
OperationContext.Current.OutgoingMessageProperties.Add( WebBodyFormatMessageProperty.Name, formatter );
WebOperationContext.Current.OutgoingResponse.ContentType = “application/json”;
return new DataContractJsonSerializer( msg.GetType( ) );

       }

and now our call then becomes:

Message msg=Message.CreateMessage(MessageVersion.None,”*”,cObject,_JSONSerializer( cObject ));

Our XML serializer is just as simple:

private static XmlObjectSerializer _XMLSerializer( object msg )
{
WebBodyFormatMessageProperty formatter=new WebBodyFormatMessageProperty( WebContentFormat.Xml );
OperationContext.Current.OutgoingMessageProperties.Add( WebBodyFormatMessageProperty.Name, formatter );
WebOperationContext.Current.OutgoingResponse.ContentType = “application/xml+xhtml”;
return new DataContractSerializer( msg.GetType( ) );
}

and now our call then becomes:

Message msg=Message.CreateMessage(MessageVersion.None,”*”,cObject,_XMLSerializer( cObject ));

The only “hard” serializer is for plain text (text/plain). For this we need to first replace the default BodyWriter method with our own:

public class TextBodyWriter : BodyWriter
{
byte[] messageBytes;
public TextBodyWriter( string message )
: base( true )
{
this.messageBytes = Encoding.UTF8.GetBytes( message );
}
protected override void OnWriteBodyContents( System.Xml.XmlDictionaryWriter writer )
{
writer.WriteStartElement( “Binary” );
writer.WriteBase64( this.messageBytes, 0, this.messageBytes.Length );
writer.WriteEndElement( );
}
}

then our text serializer becomes:

public static Message CreateRawMessage( object msg )
{
try
{
string sMsg=msg.ToString( ); //See Note Below
               Message reply=Message.CreateMessage( MessageVersion.None, null, new TextBodyWriter( sMsg ) );
reply.Properties[WebBodyFormatMessageProperty.Name] = new WebBodyFormatMessageProperty( WebContentFormat.Raw );
WebOperationContext.Current.OutgoingResponse.ContentType = “text/plain”;
return reply;
}
catch ( Exception xx )
{
throw new ApplicationException( “CreateRawMessage”, xx );
}
}

and now our call then becomes:

Message msg=Message.CreateMessage(MessageVersion.None,”*”,cObject, CreateRawMessage( cObject ));

Note: In order to make this code as generic as possible I am overloading the ToString method of the C# Object to generate the appropriate text output we want.  Here is our example object from Part I with the ToString method overwritten:

[DataContract]
public class CObject{
[DataMember]
public string ID { get; set; }
[DataMember]
public string Name { get; set; }
[DataMember]
public List<string> Data { get; set; }
public CObject( ){
Data = new List<string>( );
}

  public string ToString(){

      return string.Format(“ID:{0} Name: {1}”,ID,Name);

   }

}

We can wrap this all up into a base class to make deriving new endpoints as follows:

public class CGetBaseClass
{
public Message AllURIs( Message msg )
{

Message response=null;

//process security here

//process headers here

//call a method to do the actual work

//pass in the headers (in case there are special headers to be processed by the worker method

//pass in the query parameter to be processed by the worker method

//call a virtual function

object thing=GetObject( requestCTX, requestCTX.UriTemplateMatch.QueryParameters);

//call the appropriate serializer here

//return the properly formatted response Message

outgoingCtx.StatusCode = System.Net.HttpStatusCode.OK;

return Message;

}

protected virtual object GetObject( IncomingWebRequestContext requestCTX, NameValueCollection queryParameters )
{
throw new ApplicationException( “GetObject Not Implemented”);
}

}

Note we have make the GetObject method virtual so for any given endpoint which we which to implement we can derive from CGetBaseClass and simply overriding the GetObject method. As:

public partial class GetMySpecialObject : CGetBaseClass
{
protected override object GetObject( IncomingWebRequestContext requestCTX, NameValueCollection queryParameters)
{ /* Your Code Here */   }

}

Ok That gets us up to actually implementing an Endpoint. And that is the story for the next post!

Related articles

• WCF Tutorial (docserve.wordpress.com)

Part I: Overview and Serialization (this post)

Part II: WCF Endpoints

Part III: Implementing WCF EndPoints

Restful HTTP Endpoints

I love QCON, the technical web conference sponsored by InfoQ.  This year I attended the conference in San Francisco.  Some nice things about QCON is that it is not a a trade conference for a major powerhouse like Microsoft or Google.  Although I am a regular attendee of Microsoft’s MIX conferences, but there is something to be said for QCON focus on emergent web technologies and its focus on ideas and not products. My conference report is can be found here. This year I attended the tutorial “REST in Practice” which was presented by the authors of the book “REST in Practice”, Ian Robinson & Jim Webber.  The presenters and the audience were very well informed on both the web in the real world and the minutia of HTTP programming.  For a nerd like me (NLM), nothing is more fun than getting into  the finer points of a Fiddler dump. One thing bumping around QCON this year was the topic “WEB API”, what in the world I though was a WEB API.  Don’t be unhip like me, what is meant by a WEB API is exposing a full API for a distinct system solely through a coordinated set of RESTful HTTP endpoints (think Netflix and Flickr).  Somehow this wants to be a TLA like WEP (Web End Point but WEP is already taken).  This is the concept of AJAX matured into a true systematic technology.   In my day job I work on the development of secure Web Portals, armed with the background provided by the tutorials and sessions at QCON I returned to work resolved to cleanup our HTTP end points.  A couple of references may help.  On RESTful development see the Richardson Maturity Model and the InfoQ classic: How To GET a Cup Of Coffee.

WCF: The Microsoft Connection

I work in a Microsoft shop and so the Microsoft’s WCF is the tool of choice to develop HTTP Endpoints.  Because of our particular product goals HTTP Get’s provide the bulk of our services.  Starting with Framework 3.5, WCF has provided a rich set of tools to create RESTful dynamic HTTP Endpoints.   I started out programming XML Web Service for intra-server communication.  Although this is a very mature and powerful technology it is not optimized for Browser to Server communication, particularly  Javascript is difficult to use to develop Web Service proxies (although it can be done) and XML is rarely the tool of choice to communicate object graphs to Javascript, JSON is preferred for this purpose.  WCF For Rest (see this and this reference).  Here is a chart I developed from my notes during QCON comparing Web Services, REST and WCF for Rest:

	Web Service Standard	REST Service	WCF For REST (Framework 3.5)
1	TCP/IP + others	TCP/IP	TCP/IP
2	SOAP Wrapper	HTTP	HTTP
3	SOAP Headers	HTTP Headers	HTTP Headers
4	WS*Security	Basic Auth/SSL	Basic Auth/SSL or WS*Security
5	Early Binding	Late Binding	Late Binding
6	XSD	WADL	XSD
7	XML	Media Negotiation	Media Negotiation
8	SOAP FAULTS	HTTP Response Codes	HTTP Response Codes
9	Single Endpoint	Multiple Endpoints, URI Templates	Multiple Endpoints, URI Templates
10	Client Proxy	Custom	auto-generated Javascript proxy

The core text I used in developing WCF for Rest is the excellent and insightful RESTful .NET by Jon Flanders (see also and Jon’s Blog).

What We Are Trying to Achieve: The Problem Domain

In this blog post we will focus on a limited problem I need to solve.  Here is the overview of the problem.  At fixed points in time our code needs to collect a complex set of information on a particular subject (i.e. a graph) and persist that information for later recall. At irregular times browsers will request sub sets of the information in JSON format. The data object is quite complex.  Entity Framework would happily generate the hundreds (thousands?) of lines of code to persist and retrieve the data from a SQL database but this task cries out for a key value store (like couchDB ) so rather than looking at:

We can have something like:

Where User_Id and Date are meta data fields for the object graph represented in the column AlertsUser.  This seems like a good start, before developing the actual HTTP Endpoint we need to deal with serialization issues.  How and in what format to serialize the C# object into a nvarchar column in the database, how to desterilize that data back into a C# object and then to serialize the object into JSON for delivery to the user.  Note that in some use cases you could simplify this to:  Object serialized to JSON; and then inserted into the database  and then retrieved and passed directly to the caller.  In our use case however a single HTTP Get will request one or more rows from the data base so we require the more complex: Object serialized to nvarchar compatible object then deserialized into an array of C# object and then serialized into a JSON array.  In this use case we will use XML as our format for storing data into the database, so we have

Object –> database rows of XML in string format

XML rows – > An Array of C# Objects

Array of C# Object –> JSON Array.

In the next section of this post I will cover how to do this using C# and when this is accomplished I will in the subsequent section turn to how I developed a generic HTTP Get endpoint to serialize the data into JSON and return data in that representation to the browser.

Serialization: Objects &  XML

For purposes of this post lets define a basic C# object which we want to work with.  Here is a minimal object for serialization:

    public class CObject{
public string ID { get; set; }
public string Name { get; set; }
public List<string> Data { get; set; }
public CObject( ){
Data = new List<string>( );
}
}

Note that I have defined an an explicit class initializer. If you are going to be doing serialization a parameterless initializer is required.  To make fields available for WCF type serialization we need to add attributes: DataContract and DataMember.  Use the DataMember attribute to identify those fields you whish to serialize.

    [DataContract]
    public class CObject{
[DataMember]
public string ID { get; set; }
[DataMember]
public string Name { get; set; }
[DataMember]
public List<string> Data { get; set; }
public CObject( ){
Data = new List<string>( );
}
}

For XML serialization we may further shape the XML by using the XML attributes as follows:

XmlRoot                                            Defines The XML Namespace used by the object

XmlElement                                     Causes the XML serializer to output a field as an element and optionally names the element

XmlAttribute                                   Causes the XML serializer to output a field as an attribute to the enclosing element and optionally names the attribute

XmlArray and XmlArrayItem             Names The Root Element of an Array and separately the names of each array member

Our full adorned object might then look like:

    [DataContract]
[XmlRoot(Namespace="http://cloud2013/2012/01/”)]
    public class CObject{
[DataMember]
[XmlElement("Key")]
public string ID { get; set; }
[DataMember]
[XmlAttribute]
public string Name { get; set; }
[DataMember]
[XmlArray("Points")]
[XmlArrayItem("Point")]
public List<string> Data { get; set; }
public CObject( ){
Data = new List<string>( );
}
}
We can use the WCF Data Contract Serializer to serialize an object to an XML string using the generic method ToXMLString and serialize from and XML string back into a C# Object using the generic method XMLToObject as:

public class XMLMethods<T>
{
const string _NameSpaceBase=”http://schemas.datacontract.org/2004/07/”;
       public static string ToXMLString( T myObject )
{
MemoryStream stream1 = new MemoryStream( );
DataContractSerializer ser = new DataContractSerializer( typeof( T ) );
ser.WriteObject( stream1, myObject );
return Convert.ToString( Encoding.UTF8.GetString( stream1.GetBuffer( ), 0, ( int ) stream1.Length ) );
}
public static T XMLToObject( string xmlString )
{
TextReader sr=new StringReader( xmlString );
XmlRootAttribute root=new XmlRootAttribute( typeof( T ).Name );
root.Namespace = _NameSpaceBase + typeof( T ).Namespace;
XmlSerializer xmlSerializer = new XmlSerializer( typeof( T ), root );
return ( T ) xmlSerializer.Deserialize( sr );
}
}

calling these as:

CObject myObject=new CObject();

string xmlString=XMLMethods<CObject>.ToXMLString(myObject);

myObject=XMLMethods<CObject>.XMLToObject(xmlString);

Easy and Fun, no?

If we insert or update a SQL server column with an XML String we will need to escape the XML so we don’t run into conflicts with the string syntax of what ever SQL server type you are losing.

In my case with SQL server I need to escape single and double quote marks.  One simple way to do this, but not necessarily the fastest way,  is to 64 bit encode the string. Example code to do this is:

public static class CStaticFunctions
{
static public string EncodeTo64( string toEncode )
{
byte[] toEncodeAsBytes = System.Text.ASCIIEncoding.ASCII.GetBytes( toEncode );
return System.Convert.ToBase64String( toEncodeAsBytes );
}
static public string DecodeFrom64( string encodedData )
{
byte[] encodedDataAsBytes = System.Convert.FromBase64String( encodedData );
return System.Text.ASCIIEncoding.ASCII.GetString( encodedDataAsBytes );
}
}

OK.  Enough for Part I. To be continued…

The economic and moral depravity of this system must end.

“Hon Hai has a workforce of over one million worldwide and as human beings are also animals, to manage one million animals gives me a headache,”

Terry Gou, chairman of Foxconn parent Hon Hai Precision Industry

“[Whatever it was Gou said there could have been] a lot lost in translation…[Besides, Biggs noted, it's important to remember priorities when criticizing such stuff] In the end, it’s companies like Foxconn that keep us in our gadgets,” 

TechCrunch’s John Biggs

Priorities, indeed John.  We need to keep priorities in mind.  If the virtual enslavement of the Chinese workforce and massive unemployment in the United States are required to keep us supplied with our gadgets, so be it.  The New York Times reported extensively on the horrors of Foxconn and Apple Corporation’s culpability here,  here and here. According to Digital Trends, here are some of the workforce issues at Foxconn as reported in a An American Life report from Mike Daisey (he of “The Agony & Ecstasy of Steve Jobs“):

• Living within dormitories inside the factory walls, employees are packed into 144 square foot (12-by-12) cement rooms with 15 beds stacked up like bunk-beds. Employees are often placed into rooms where they do not know anyone as well.
• Any attempt at forming a union is met with arrest and a prison sentence as unions are illegal within China.
• Workers cleaning iPhone screens used a chemical called hexane, specifically because the chemical solution evaporates faster and allows the production line to speed up. However, hexane is a neuro-toxin. Inhalation of hexane causes mild euphoria, followed by nausea and headaches. Repeated exposure causes extensive peripheral nervous system failure, a result that Daisey spotted as the hands of the workers on the line shook involuntarily. 
• Five percent of the workers Daisey spoke to were underage, some as young as twelve. The children working at the factory mentioned that Foxconn doesn’t check ages and shifts older employees to the front line when inspections occur.
• The standard working shift at the plant lasts 12 hours, but that’s pushed up to 16 hours when Apple is getting ready to launch a new gadget like the upcoming iPad 3. However, a worker on a 34 hour shift dies while Daisey tours the facility.
• On the factory floor, there’s no talking allowed among the 20,000 to 30,000 workers. There’s also little machinery on the floor since labor costs are far lower than machines. However, Gau has stated publicly that investing in advanced automation is a high priority.
• Workers that have developed severe carpal-tunnel issues from repeating the same process over and over are simply fired. Foxconn could eliminate this issue by rotating jobs between employees, but they do not.
• Workers that get severely injured on the job are fired without any severance and workers that complain about working conditions are fired as well as black-listed with all companies that operate within Shenzhen.

An inside look at the Apple Facility at Foxconn that can be heard on This American Life here.

When Foxconn workers threatened mass suicide Foxconn issued this statement:

The workers climbed to the top of the six-story dormitory on 3 January and threatened to jump before Wuhan city officials persuaded them to desist and return to work, according to the workers and accounts online. The workers gave varying estimates of the numbers involved in the strike, from 80 to 200, and photos posted online showed dozens of people crowding the roof of the boxy concrete building. “Actually none of them were going to jump. They were there for the compensation. But the government and the company officials were just as afraid, because if even one of them jumped, the consequences would be hard to imagine,” said Wang Jungang, an equipment engineer in the Xbox production line, who left the plant earlier this month.

Nothing like a mass suicide to ruin an executives day. Just think of the PR headache.  This is not the first time suicides and Foxconn have been linked.  Among the corporate responses has been to erect suicide netting at the workers dormitories.

The basic wage of workers is $17 per Day and that’s for a twelve hour shift.  No wonder the jobs go to China.  There is a work for this type of worker, and that word is Slave.  Western corporations using Foxconn include:

• Acer Inc. (Taiwan)
• Amazon.com (United States)

• Apple Inc. (United States)
• ASRock (Taiwan)
• Asus (Taiwan)
• Barnes & Noble (United States)
• Cisco (United States)
• Dell (United States)
• EVGA Corporation (United States)
• Hewlett-Packard (United States)
• Intel (United States)
• IBM (United States)
• Lenovo (China)
• Logitech (Switzerland)
• Microsoft (United States)
• MSI (Taiwan)
• Motorola (United States)
• Netgear (United States)
• Nintendo (Japan)
• Nokia (Finland)
• Panasonic (Japan)
• Philips (Netherlands)
• Sharp (Japan)
• Sony Ericsson (Japan/Sweden)
• Toshiba (Japan)
• Vizio (United States)

The New York Times recently published a full report on Apple, Foxconn and American unemployment.  This is the most up to date  and comprehensive report I have seen It can be read here.  A full list of ‘the grey ladies’ reporting on Foxconn can be found here.  Being ‘balanced’ The Times reprints Apples defense of using the Foxconn facility.  It is basically our old friend, the cult of efficiency.  On this report, The Daily Beast notes:

In 2007, when Apple made a last-minute change to the original iPhone, workers in China had to scramble to meet a tight deadline, according to an unnamed former Apple executive who spoke to the Times:  A foreman immediately roused 8,000 workers inside the company’s dormitories, according to the executive. Each employee was given a biscuit and a cup of tea, guided to a workstation and within half an hour started a 12-hour shift fitting glass screens into beveled frames. Within 96 hours, the plant was producing 10,000 iPhones a day. “The speed and flexibility is breathtaking,” [the executive] said. “There’s no American plant that can match that.”

The Daily Beast’s Dan Lyons comments:

The question is: should there be? Would we accept the idea of a plant where people are packed into barracks and can be roused in the middle of the night, given a biscuit, and sent to work for 12 hours? Where workers have no right to complain?  We would not accept this in the United States because, quite simply, it’s barbaric.  Not “breathtaking.” Barbaric.

The Times article estimates that making the IPhone in the United States would add $65 dollars to the cost of each unit.  What is a human life worth? 

Dan Lyons concludes:

Why are we doing business with this kind of regime? Why are we making this bargain?  As the Times article points out, this isn’t just Apple. It’s every company. It’s every product we use. It’s our entire way of life, built on the backs of people who are being treated in ways that we would not allow ourselves or our countrymen to be treated.  Ultimately the blame lies not with Apple and other electronics companies—but with us, the consumers.  And ultimately we are the ones who must demand change.  So what if building that smartphone in China means we save 65 bucks and get things done faster? Maybe we would be better off paying a little more and waiting a little bit longer.  This week, Apple will report its financial results for the holiday quarter. It’s probably going to be another huge blowout, with Apple doing about $40 billion in revenues and keeping $10 billion of that as bottom-line profit—an incredible profit margin for a company that makes hardware.  Wall Street will be ecstatic. The stock will soar. But it’s worth keeping in mind how Apple did it.

A nice thing about the New York Times article it is also looks at how this effects employment in the United States.  According to the Times:

Last year, it earned over $400,000 in profit per employee, more than Goldman Sachs, Exxon Mobil or Google.  Apple employs 43,000 people in the United States and 20,000 overseas… Many more people work for Apple’s contractors: an additional 700,000 people engineer, build and assemble iPads, iPhones and Apple’s other products. But almost none of them work in the United States.

As Jared Bernstein, who until last year was an economic adviser to the White House said: “If it’s the pinnacle of capitalism, we should be worried.”

If the jobs are overseas so are the wages, thus while Apple (and Google and Microsoft and …) earn huge profits for the few, the many go unemployed. And the unemployed can’t afford IPhones.  In its own defense An Apple Executive told the Times:

“We shouldn’t be criticized for using Chinese workers,” a current Apple executive said. “The U.S. has stopped producing people with the skills we need.”

Right the $17 per day worker and the slave drivers (opps, Middle Managers) to control them (oops again, to manage them).

Strangely, the dominate political culture in the United States, people are taught to blame the government for fixes to the economy.  It was the Occupy Wall Street movement that re-awakened us to the idea that its Capitalism and Capitalism inequality and Capitalisms pursuit of profits over people that drives this country into misery, not congress not the president and the Supreme Court.  It would be so nice if just a change of the resident of the Whitehouse would make an appreciative change in our economic crisis.  Say they say at OWS to the question of why they are on Wall Street and not in Washington: Why deal with middle management when you can talk directly to the boss! 

Occupy Silicon Valley Anyone?

Related articles

• INCONVENIENT TRUTH: Your iPhone Was Built, In Part, By 13 Year-Olds Working 16 Hours A Day For 70 Cents An Hour (businessinsider.com)
• What Hath Apple Wrought? (dailyfinance.com)
• The People That Make Our Stuff (localpaper.wordpress.com)
• What Hath Apple Wrought? (fool.com)
• Foxconn, Revisited (bigthink.com)
• Hundreds Threaten Suicide At MICROSOFT Supplier Plant In… (seattle.cbslocal.com)
• There’s Blood On Your Ipad (broadsideblog.wordpress.com)
• Workers threaten mass suicide at company that supplies Apple (independent.co.uk)
• Xbox workers threaten suicide in China labor tiff (ajc.com)
• Getting an Apple (ronscoffeeandchocolates.wordpress.com)

=>

Wikipedia:

Google:

=>

Source: Patrick Meighan’s Occupy LA Blog

My Occupy LA Arrest, by Patrick Meighan (UPDATE: 12/9/11)

My name is Patrick Meighan, and I’m a husband, a father, a writer on the Fox animated sitcom “Family Guy”, and a member of the Unitarian Universalist Community Church of Santa Monica.

I was arrested at about 1 a.m. Wednesday morning with 291 other people at Occupy LA. I was sitting in City Hall Park with a pillow, a blanket, and a copy of Thich Nhat Hanh’s “Being Peace” when 1,400 heavily-armed LAPD officers in paramilitary SWAT gear streamed in. I was in a group of about 50 peaceful protestors who sat Indian-style, arms interlocked, around a tent (the symbolic image of the Occupy movement). The LAPD officers encircled us, weapons drawn, while we chanted “We Are Peaceful” and “We Are Nonviolent” and “Join Us.”

As we sat there, encircled, a separate team of LAPD officers used knives to slice open every personal tent in the park. They forcibly removed anyone sleeping inside, and then yanked out and destroyed any personal property inside those tents, scattering the contents across the park. They then did the same with the communal property of the Occupy LA movement. For example, I watched as the LAPD destroyed a pop-up canopy tent that, until that moment, had been serving as Occupy LA’s First Aid and Wellness tent, in which volunteer health professionals gave free medical care to absolutely anyone who requested it. As it happens, my family had personally contributed that exact canopy tent to Occupy LA, at a cost of several hundred of my family’s dollars. As I watched, the LAPD sliced that canopy tent to shreds, broke the telescoping poles into pieces and scattered the detritus across the park. Note that these were the objects described in subsequent mainstream press reports as “30 tons of garbage” that was “abandoned” by Occupy LA: personal property forcibly stolen from us, destroyed in front of our eyes and then left for maintenance workers to dispose of while we were sent to prison.

When the LAPD finally began arresting those of us interlocked around the symbolic tent, we were all ordered by the LAPD to unlink from each other (in order to facilitate the arrests). Each seated, nonviolent protester beside me who refused to cooperate by unlinking his arms had the following done to him: an LAPD officer would forcibly extend the protestor’s legs, grab his left foot, twist it all the way around and then stomp his boot on the insole, pinning the protestor’s left foot to the pavement, twisted backwards. Then the LAPD officer would grab the protestor’s right foot and twist it all the way the other direction until the non-violent protestor, in incredible agony, would shriek in pain and unlink from his neighbor.

It was horrible to watch, and apparently designed to terrorize the rest of us. At least I was sufficiently terrorized. I unlinked my arms voluntarily and informed the LAPD officers that I would go peacefully and cooperatively. I stood as instructed, and then I had my arms wrenched behind my back, and an officer hyperextended my wrists into my inner arms. It was super violent, it hurt really really bad, and he was doing it on purpose. When I involuntarily recoiled from the pain, the LAPD officer threw me face-first to the pavement. He had my hands behind my back, so I landed right on my face. The officer dropped with his knee on my back and ground my face into the pavement. It really, really hurt and my face started bleeding and I was very scared. I begged for mercy and I promised that I was honestly not resisting and would not resist.

My hands were then zipcuffed very tightly behind my back, where they turned blue. I am now suffering nerve damage in my right thumb and palm.

I was put on a paddywagon with other nonviolent protestors and taken to a parking garage in Parker Center. They forced us to kneel (and sit–SEE UPDATE ) on the hard pavement of that parking garage for seven straight hours with our hands still tightly zipcuffed behind our backs. Some began to pass out. One man rolled to the ground and vomited for a long, long time before falling unconscious. The LAPD officers watched and did nothing.

At 9 a.m. we were finally taken from the pavement into the station to be processed. The charge was sitting in the park after the police said not to. It’s a misdemeanor. Almost always, for a misdemeanor, the police just give you a ticket and let you go. It costs you a couple hundred dollars. Apparently, that’s what happened with most every other misdemeanor arrest in LA that day.

With us Occupy LA protestors, however, they set bail at $5,000 and booked us into jail. Almost none of the protesters could afford to bail themselves out. I’m lucky and I could afford it, except the LAPD spent all day refusing to actually *accept* the bail they set. If you were an accused murderer or a rapist in LAPD custody that day, you could bail yourself right out and be back on the street, no problem. But if you were a nonviolent Occupy LA protestor with bail money in hand, you were held long into the following morning, with absolutely no access to a lawyer.

I spent most of my day and night crammed into an eight-man jail cell, along with sixteen other Occupy LA protesters. My sleeping spot was on the floor next to the toilet.

Finally, at 2:30 the next morning, after twenty-five hours in custody, I was released on bail. But there were at least 200 Occupy LA protestors who couldn’t afford the bail. The LAPD chose to keep those peaceful, non-violent protesters in prison for two full days… the absolute legal maximum that the LAPD is allowed to detain someone on misdemeanor charges.

As a reminder, Antonio Villaraigosa has referred to all of this as “the LAPD’s finest hour.”

So that’s what happened to the 292 women and men were arrested last Wednesday. Now let’s talk about a man who was not arrested last Wednesday. He is former Citigroup CEO Charles Prince. Under Charles Prince, Citigroup was guilty of massive, coordinated securities fraud.

Citigroup spent years intentionally buying up every bad mortgage loan it could find, creating bad securities out of those bad loans and then selling shares in those bad securities to duped investors. And then they sometimes secretly bet *against* their *own* bad securities to make even more money. For one such bad Citigroup security, Citigroup executives were internally calling it, quote, “a collection of dogshit”. To investors, however, they called it, quote, “an attractive investment rigorously selected by an independent investment adviser”.

This is fraud, and it’s a felony, and the Charles Princes of the world spent several years doing it again and again: knowingly writing bad mortgages, and then packaging them into fraudulent securities which they then sold to suckers and then repeating the process. This is a big part of why your property values went up so fast. But then the bubble burst, and that’s why our economy is now shattered for a generation, and it’s also why your home is now underwater. Or at least mine is.

Anyway, if your retirement fund lost a decade’s-worth of gains overnight, this is why.

If your son’s middle school has added furlough days because the school district can’t afford to keep its doors open for a full school year, this is why.

If your daughter has come out of college with a degree only to discover that there are no jobs for her, this is why.

But back to Charles Prince. For his four years of in charge of massive, repeated fraud at Citigroup, he received fifty-three million dollars in salary and also received another ninety-four million dollars in stock holdings. What Charles Prince has *not* received is a pair of zipcuffs. The nerves in his thumb are fine. No cop has thrown Charles Prince into the pavement, face-first. Each and every peaceful, nonviolent Occupy LA protester arrested last week has has spent more time sleeping on a jail floor than every single Charles Prince on Wall Street, combined.

The more I think about that, the madder I get. What does it say about our country that nonviolent protesters are given the bottom of a police boot while those who steal hundreds of billions, do trillions worth of damage to our economy and shatter our social fabric for a generation are not only spared the zipcuffs but showered with rewards?

In any event, believe it or not, I’m really not angry that I got arrested. I chose to get arrested. And I’m not even angry that the mayor and the LAPD decided to give non-violent protestors like me a little extra shiv in jail (although I’m not especially grateful for it either).

I’m just really angry that every single Charles Prince wasn’t in jail with me.

Thank you for letting me share that anger with you today.

Patrick Meighan

Photojournalist Tyson Zoltan Header beaten and detained BY LAPS at Occupy Los Angles

Let me say write off that I do not pay for my own ticket to QCON, my boss picks up the tag.  I love QCON.  It is definitely not MIX. I go there to see what is happening in the world which is NOT Oracle and Not Microsoft.  That’s the same reason I read their online Zine: InfoQ.   QCon always provides a look at what is current and recent in the open stack world.  This year we looked closely at REST, Mobile development, Web API and NOSQL. As they did last  year QCON provides a nice look at what is open and emerging.  Big metal with always be with us but the desk top is looking very weak during the next few years while Mobile devices of all kinds and makers are exploding.  The biggest fall out is that while HTML5 is only slowly emerging on desktops in place, all new Mobile devices (which is to say most new systems) will be fully HTML5 compliant.  Not only that but with the exception of Windows Phones, the rendering engine for all mobile devices is based on WebKit.  What this mean for those of us in the cubes is that worrying about how to bridge to pre-HTML5 browsers with HTML5 code is a non-issue.  Mobile development is HTML5 development.  The big metal end of the supply chain is being segmented into Web API servers (which service JSON XHR2 data calls) and the NOSQL engines which serve the WEB API farms.  Remember a native mobile app     ideally has pre-loaded all of its pages its interactions are solely over JSON XHR2 for data (be it documents, data or HTML fragments).  The traditional JSP or ASPX web server is not really in play with native mobile apps and has and increasingly small role to play in “native like” or browser based mobile apps.  Let’s move on.

“IPad Light by cloud2013”

Speaking of moving on: There is an occupation going on in this country.  I visited occupations sites in San Francisco, UCal Berkeley and  Berkeley “Tent City”.  These are all very active and inspiring occupy sites.  Now if we can only get to Occupy Silicon Valley! 

I attended the REST in Practice tutorial this year and it was a very nice.  The authors were well informed and the agenda comprehensive.  I personally like the Richardson maturity model but think that people are not facing up to the fact that level three is rarely achieved in practice and the rules of web semantics necessary to interoperate at level 3 are almost non-existent. Remember the original REST model is client/server.  The basic model is a finite state machine and the browser (and the user) are in this model required to be dumb as fish.  Whether Javascript is a strong enough model and late binding semantics can be made clear enough to pull off level three is really an open question which no one has an answer to.  If we forget about interoperability (except for OAuth) things start to fall into place but we thought OPENNESS was important to REST.

Workshop: REST In Practice by the Authors: Ian Robinson & Jim Webber

Why REST? The claims:

· Scalable

· Fault Tolerant

· Recoverable

· Secure

· Loosely coupled

Questions / Comment:

Do we agree with these goals?

Does REST achieve them?

Are there other ways to achieve the same goals?

REST design is important for serving AJAX requests and AJAX requests are becoming central to Mobile device development, as opposed to intra-corporate communication. See Web API section below.

Occupy Market Street (San Francisco)            

The new basic Document for REST: Richardson Maturity Model (with DLR modifications)

Level 0:

One URI endpoint

One HTTP method [Get]

SOAP, RPC

Level 1:

Multiple URI,

One HTTP Method [Get]

Century Level HTTP Codes (200,300,400,500)

Level 2:

Multiple URI,

Multiple HTTP Methods

Fine Grain HTTP Codes (“Any code below 500 is not an error, it’s an event”)

URI Templates

Media Format Negotiation (Accept request-header)

Headers become major players in the interaction between client and server

Level 3:  The Semantic Web

Level 2 plus

Links and Forms Tags (Hypermedia as the engine of state)

Plus emergent semantics

<shop xmlns=”http://schemas.restbucks.com/shop”

xmlns:rb=”http://relations.restbucks.com/”>

<items>

<item>…</item>

<item>…</item>

</items>

<link rel=”self” href=http://restbucks.com/quotes/1234 type=”application/restbucks+xml”/>

<link rel=”rb:order-form” href=”http://restbucks.com/order-forms/1234″ type=”application/restbucks+xml”/>

</shop>

Think of the browser (user) as a finite State Machine where the workflow is driven by link tags which direct the client as to which states it may transition to and the URI associated with each state transition.

The classic design paper on applied REST architecture is here: How To GET a Cup Of Coffee. Moving beyond level 1 requires fine grain usage of HTTP Status Codes, Link tags, the change headers and media type negotiation. Media formats beyond POX and JSON are required to use level 3 efficiently (OData and ATOM.PUB for example).

Dude, where’s my two phase commit? Not supported directly, use the change headers (if-modified, if-non-match, etag headers) or architectural redesign (redefine resources or workflow). Strategic choice is design of the finite state machine and defining resource granularity.

(Slide from Rest in Practice)

Architectural Choices:

The Bad Old Days: One resource many, many ‘verbs’.

The Happy Future: Many, many resources, few verbs.

The Hand Cuff Era: Few Resources, Few verbs.

The Greater Verbs:

GET: Retrieve a representation of a resource

POST: Create a new resource (Server sets the key)

PUT: Create new resource (Client sets the key); ( or Update an existing resource ?)

DELETE: Delete an existing resource

Comment: The proper use of PUT vs. POST is still subject to controversy and indicates (to me) that level 3 is still not well defined.

Typically they say POST to create a blog entry and PUT at append a comment to a blog. In Couchdb we POST to create a document and PUT to add a revision (not a delta) and get back a new version number. The difference here is how the resource is being defined, which is an architectural choice.

The Lesser Verbs:

OPTIONS: See which verbs a resource understands

HEAD: Return only the header (no response body)

PATCH: Does not exist in HTML5. This would be a delta Verb but no one could agree on a specification for the content.  Microsoft did some early work on this with their XML Diffgram but no one else followed suit.

Security

Authentication (in order of increased security)

Basic Auth

Basic Auth + SSL

Digest

WSSE Authentication (ATOM uses this)

Message Security:

Message Level Encrypt (WS-SEC)

For the Microsoft coders I highly recommend

RESTful .Net (WCF For REST (Framework 3.5) Jon Flanders

There are significant advantages to building your RESTful services using .Net.  Here is a comparison table to get you oriented:

DLR’s Cross Reference:

	Web Service Standard	REST Service	WCF For REST (Framework 3.5)
1	TCP/IP + others	TCP/IP	TCP/IP
2	SOAP Wrapper	HTTP	HTTP
3	SOAP Headers	HTTP Headers	HTTP Headers
4	WS*Security	Basic Auth/SSL	Basic Auth/SSL or WS*Security
5	Early Binding	Late Binding	Late Binding
6	XSD	WADL	XSD, WADL
7	XML	Media Negotiation	Media Negotiation
8	SOAP FAULTS	HTTP Response Codes	HTTP Response Codes
9	Single Endpoint	Multiple Endpoints, URI Templates	Multiple Endpoints, URI Templates
10	Client Proxy	Custom	auto-generated Javascript proxy

The REST of the Week

Wednesday is more or less vendor day at QCON and the sessions are a step down from the tutorials but the session quality picked up again on Thursday and Friday.  XXX XXXX who gave an excellent tutorial last year gave an informative talk on ‘good code’.  The Mobile Development and HTML5 tracks were well attended and quite informative.  The fie   ld is wild open with many supporting systems being free to the developer (support will cost you extra) and the choices are broad: from browser ‘responsive design’ application to native appearing applications to native apps ( and someone threw in “hybrid app” into the mix).  The Mobile panel of IBM DOJO, JQuery.Mobil and Sencha was hot.  I am new (to say the least) to Mobile development but here are my (somewhat) random notes on these sessions:

MOBILE Development is HTML5 Development

HTML5 is the stack. Phone and Tablet applications use WebKit based rendering engines and HTML5 conformant browsers only (Windows Phone 7 is the exception here). HTML5 has its own new security concerns ( New Security Concerns)

Three major application development approaches are:

· Browser Applications;

· Native like Applications;

· Hybrid Applications; and

· Native Applications.

Browser applications may emulate the screens seen on the parallel desk top browser versions on the front end but in practice the major players (Facebook, YouTube, Gmail) make substantial modifications to at least the non-visual parts of the Mobile experience making extensive use of local storage and the HTML5 manifest standard for performance and to allow for a reasonable off line experience. Browser applications fall under the guidelines of Responsive Design (aka adaptive Design) and tend to be used when content will appear similarly between desktop and Mobile devices.

“Native like” applications use:

· The Browser in full screen Mode with no browser ‘chrome’; and

· Widgets are created using CSS, JS and HTML5 which simulate the ‘look and feel’ of a native application;

· No Access to Native Functionality (GPS, Camera, etc)

· Tend to use, but does not require use of HTML5 manifest or local storage but it is strongly encouraged.

A Native application is still an HTML5 application with the following characteristics:

· All JS Libraries, CSS and HTML are packaged and pre-loaded using a vendor specific MSI/Setup package;

· AJAX type calls for data are allowed;

· Access to Native Widgets and/or Widgets are created using CSS, JS and HTML5

· Access to Native Functionality (GPS, Camera, etc)

· Standard HTTP GET or POST are NOT allowed

A Hybrid Application is a “Native Like” Application” placed within a wrapper which allows access to device hardware and software (like the camera) via a special JavaScript interface and, with additional special coding, can be packaged within a MSI/Setup and distributed as a pure Native application.

AJAX calls are made via XHR2 (aka XMLHttpRequest Level 2) which among other things relaxes the single domain requirement of XHR and processing Blob and File interfaces.

The following major vendors offer free libraries and IDE for development:

Native Apps: PhoneGap, Appcelerator

Native App Like: Sencha, PhoneGap, IBM Dojo

Browser App: JQuery.Mobile

PhoneGap does NOT require replacement of Sencha, JQuery.Mobil, Dojo.Mobile JQuery libraries.

PhoneGap allows JavaScript to call PhoneGap JavaScript libraries which abstract access to device hardware (camera, GPS, etc).

Sencha does not require replacement of the JQuery.Mobil, Dojo.Mobile JQuery libraries.

Although it is theoretically possible to create “Native like” applications with only JQuery.Mobile this is NOT encouraged.

Local Storage

This is a major area of performance efforts and is still very much open in terms of how best to approach the problem:

The major elements are:

App Cache (for pre-fetch. and Native App Approach)

DOM Storage (aka Web Storage)

IndexedDB (vs. Web SQL)

File API (this is really part of XHR2)

Storing Large Amounts of Data Locally

If you are looking to store many Megabytes – or more, beware that there are limits in place, which are handled in different ways depending on the browser and the particular API we’re talking about. In most cases, there is a magic number of 5MB. For Application Cache and the various offline stores, there will be no problem if your domain stores under 5MB. When you go above that, various things can happen: (a) it won’t work; (b) the browser will request the user for more space; (c) the browser will check for special configuration (as with the “unlimited_storage” permission in the Chrome extension manifest).

IndexedDB:

Web SQL Database is a web page API for storing data in databases that can be queried using a variant of SQL.

Storage Non-Support as of two weeks ago.

	IE	Chrome	Safari	Firefox	iOS	BBX[RIM]	Android
IndexedDB	Supported	Supported	No Support	Supported	No Support	No Support	No Support
WEB SQL	No Support	Supported	Supported	No Support	Supported	Supported	Supported

Doing HTML5 on non-HTML5 Browsers: If you are doing responsive design and need to work with Desktop and Mobil using the same code base: JQuery.Mobile, DOJO and , Modernizr(strong Microsoft support for this JavaScript library).

WEB API

What is it? Just a name for breaking out the AJAX servers from the web server. This is an expansion of REST into just serving data for XHR. It is a helpful way to specialize our design discussions by separating serving pages (with MVC or whatever) from serving data calls from the web page. Except for security the two can be architecturally separated.

Web APIs Technology Stack

Look familiarr? Looks like our old web server stack to me.

NOSQL

The CAP Theorem  (and Here)

• Consistency: (all nodes have the same data at the same time)
• Availability: (every request receives a response – no timeouts, offline)
• Partition tolerance: (the system continues to operate despite arbitrary message loss)

Pick Any Two

If some of the data you are serving can tolerate Eventual Consistency then NOSQL is much faster.

If you need two phase commit, either use a SQL database OR redefine your resource to eliminate the need for the 2Phase Commit.

NoSQL databases come in two basic flavors:

Key/Value: This are popular with content management and where response time must be minimal. In general you define what btrees you want to use before the fact. There are no on the fly Joins or projects. MongoDB and CouchDB are typical leaders in this area.

Column Map: This is what Google calls Big Table. This is better for delivering groups of records based on criteria which may be defined ‘on the fly’. Cassandra is the leader in this group.

Web Sockets:

Sad to say this is still not standardized and preliminary support libraries are still a little rough.  Things do not seem to have moved along much since the Microsoft sessions I attended at MIX 11.

Photos: All Photos by Cloud2013

CouchDB Documents and Views

I have written elsewhere on couchdb on Windows and using Ruby on Rails to interface to this system.  These posts can be found here:

Part 0 – REST, Ruby On Rails, CouchDB and Me

Part 1 – Ruby, The Command Line Version

Part 2 – Aptana IDE For Ruby

Part 3 CouchDB Up and Running on Windows

Part 4 – CouchDB, Curl and RUBY

Part 5 – Getting The Data Ready for CouchDB

Part 6 – Getting The Data Into And Out Of CouchDB

Part 7 – JQUERY,JPlayer and HTML5

In my work life I work in a Microsoft shop which for us means Microsoft servers for the back end and (mostly) pure HTML/AJAX frontends.  We are transitioning towards using Microsoft MVC 3 to provide HTTP end points for our AJAX calls.  Here are some notes from my POC work in this area.  My couch data consists of documents describing Grateful Dead concerts stored on the great site Internet Archive, if you have never visited the Internet Archive, please do so.  I back engineered the meta data of IA’s extensive collection of Dead concerts (over 2,000 concert recordings).  Visit the Grateful Dead Archive Home at the Internet Archive here.

I stored the meta data into a local couchdb (running on Windows XP).  The basic document I am storing is a master detail set for the ‘best’ recording for each Dead concert.  The Master part of the document contains the date, venue and other data of the concert and the detail set is an array of meta data on each song preformed during the concert.  As is traditional with couchdb, the documents are represented as JSON strings.  Here is what the document for the UR recording (1965-11-01) found on the IA:

{

“_id”: “1965-11-01″,

“_rev”: “1-6ea272d20d7fc80e51c1ba53a5101ac1″,

“mx”: false,

“pubdate”: “2009-03-14″,

“sb”: true,

“venue”: “various”,

“tracks”: [

{

"uri": "http://www.archive.org/download/gd1965-11- 01.sbd.bershaw.5417.sbeok.shnf/Acid4_01_vbr.mp3",

"track": "01",

"title": "Speed Limit",

"time": "09:48"

},

{

"uri": "http://www.archive.org/download/gd1965-11-01.sbd.bershaw.5417.sbeok.shnf/Acid4_02_vbr.mp3",

"track": "02",

"title": "Neil Cassidy Raps",

"time": "02:19"

}

]

}

Couchdb allow the creation of views which are binary trees with user defined Keys and user defined sub sets of the document data.  If one wanted to return the venue and the tracks for each concert for a given Month and Day (across all years) the view created in couchdb would look like:

“MonthDay”: {

“map”: “function(doc){emit(doc._id.substr(5,2)+doc._id.substr(8,2),[doc.venue , doc.IAKey, doc.tracks ])}”

}

This view allows us to use and HTTP GET to pass in a monthday key (e.g. “1101”) and get back (as a JSON array)

the date (MMDDYY: doc._id.substr(5,2)+doc._id.substr(8,2))

the venue (doc.venue);

the AI URI of the concert (doc.IAKey); and

an array of track data (doc.tracks)

MVC URL Routing Maps

Although we could call couchdb directly from the browser, we normally work through a gateway system for security, so we will build a shim to sit between the browser and couchdb.  This allows us to flow the authentication / authorization stack separately from couchdb’s security system.  In MS MVC we can create a new HTTP endpoint for AJAX calls (our shim) is a very simple manner. Let’s create an endpoint which will look like:

http:\\{our server path}\DeadBase\MonthDay\{month}\{day}

where

http:\\{our server path}\DeadBase\MonthDay\111

would request month:11 and day:01 concerts.  In MVC we can declare this routing as:

routes.MapRoute(

“MyMonthDay”,

“{controller}/{action}/{month}/{day}”, 

new { controller = “DeadBase”, action = “RestMonthDay”,null} );

Done.  Interestingly in MVC 3 this route definition will accept either the form:

http:\\{our server path}\DeadBase\MonthDay\{month}\{day} ; or

http:\\{our server path}\DeadBase\MonthDay?month=”??”&day=”??”

In the second form,  parameter order does not matter, but case does; quotation marks are optional and need to be dealt with internally by the action method.

either of these call will resolve to the same controller and method.

MVC Controller and Method Handler

We now need to create the shim which will be the target for the Http Endpoint.  In C# this looks like:

public class DeadBaseController : Controller
{ 

public string RestMonthDay( string month, string day )
{
//our shim code goes here

      }

    }

We able to use string as our return type because we will be calling couchdb which returns a string from of JSON by default.  As a side note if we wanted to use MVC 3 to return JSON from a native C# object our controller method takes a different form:

public JsonResult GetStateList()

{

List<ListItem> list = new List<ListItem>() {

new ListItem() { Value = “1″, Text = “VA” },

new ListItem() { Value = “2″, Text = “MD” },

new ListItem() { Value = “3″, Text = “DC” } };

return this.Json(list);

}

Our AJAX call from the browser does not need to know any of these details.  Here is one way to code the call in JavaScript using JQuery:

var url = urlBase + “?” + args;

$.ajax({

url: url,

dataType: ‘json’,

success: okCallBack,

error: nookCallBack

});

function okCallBack(data) {

gdData = data;

//do something useful here

}

function nookCallBack(xhr, ajaxOptions, errorThrown) {

alert(“ErrorText:” + errorThrown + ” ” + “Error Code:” + xhr.status);

}

}

From Handler to CouchDB in C#

Here is the rest of the generic C# code to go from the Handler to CouchDB and back.

Clean the parameters and pass the call to a generic couchDB GET caller:

Format the view name and parameter into couchdb format  and pass to the low level couchDB caller:

Classic Framework HTTP code to make the HTTP GET and return the results as a string back up the call stack:

We could (and did) take our Browser code from the Ruby on Rails project above and with minimum changes call our MVC shim.

Simple clean and fun.

No single journalist has been as insightful as Chris Hedges. Chris is a regular contributor to truthdig. His essay Why The Elites Are In Trouble contains a seminal analysis.

It been a while since I have been able to post so here a large group of links related to speeches, analysis and social media related to Occupy Wall Street.

Occupy the Future!

Online Resources:

Occupation Groups:

Occupy Wall Street –> Click Me!

Occupy Boston –> Click Me!

Occupy Together (Clearing House for smaller occupations) –> Click Me! (This is a great way to locate web sites for occupations in other than NYC)

Alternative News and Analysis:

AlertNet  -> Click Me!

N+1 (New York Based Literary Journal) –> Click Me!

TruthDig –> Click Me!

Social Media And Images:

Tumblr Sites: Here and Here

Pictures And Logos:    Here;  Here; Here; and  Here.

 Yoga Teachers For The Occupation:

Here; Here; Here; Here

Occupy Comedy:

Daily Show

Colbert

Analysis And Speeches:

Naomi Klein (The Shock Doctrine) has been an early and consistent support of the Occupy movement.  Her speech at the park began:

I love you.

And I didn’t just say that so that hundreds of you would shout “I love you” back, though that is obviously a bonus feature of the human microphone. Say unto others what you would have them say unto you, only way louder.

Yesterday, one of the speakers at the labor rally said: “We found each other.” That sentiment captures the beauty of what is being created here. A wide-open space (as well as an idea so big it can’t be contained by any space) for all the people who want a better world to find each other. We are so grateful.

If there is one thing I know, it is that the 1 percent loves a crisis. When people are panicked and desperate and no one seems to know what to do, that is the ideal time to push through their wish list of pro-corporate policies: privatizing education and social security, slashing public services, getting rid of the last constraints on corporate power. Amidst the economic crisis, this is happening the world over.

And there is only one thing that can block this tactic, and fortunately, it’s a very big thing: the 99 percent. And that 99 percent is taking to the streets from Madison to Madrid to say “No. We will not pay for your crisis.” Read More…

Listen to her here  discussing her theory of the the shock doctrine.

All rights reserved by DianeSweet

 Hail The Unknown Organizer (By Charles M. Young):

Liberated Autonomous Manhattan — In a century, community organizers will still be debating what to call Zuccotti Park/Liberty Plaza/Liberty Square. The surrounding skyscrapers will be covered with luxuriant tomato vines hanging from rooftop organic gardens. Electricity will be generated by solar panels and fermenting compost. Inside, the skyscrapers will be humming with intense conversation at the Occupy Education Graduate School of Revolutionary Studies, open to anyone willing to teach everyone wanting to learn.

Visitors to the park will meander through meticulously maintained sidewalks that wind in fractals through authentic tarps and wet sleeping bags from the early 21st century. Scent generators will alternately waft herbal cigarettes, sandalwood incense and mildew into the breeze.

In the center of the park will stand a 100-foot statue, cast from the bronze of the long forgotten Wall Street bull that was melted down in 2014 and recast as a 5’1” woman in a windbreaker, waving a big red flag. On the marble pedestal, it shall be carved: THE UNKNOWN ORGANIZER. And below it there shall be some beautiful words, maybe a sonnet, written about October 15, 2011, when The Unknown Organizer, who looked at a distance to be in her 30s, led a contingent of 500 brave revolutionaries from the 10,000 massed in Washington Square Park to defend 20-odd people who were being arrested for the crime of withdrawing their own money and closing their accounts at Citibank, one of the most corrupt, heartless and stupid institutions in all of corrupt, heartless and stupid Wall Street.

It will be written that the 500 volunteers followed The Unknown Organizer from the center of Washington Square Park to the sidewalk at the southern entrance where she waved her red flag in a “Halt!” gesture and asked, “Hey, does anyone know where LaGuardia Place is?”

Somebody did know, and we marched for a few minutes east and south to a Citibank branch where a couple dozen cops, decked out in their body armor and black uniforms and riot helmets, were standing in the middle of LaGuardia Place nervously tapping their extra-long batons.

Suddenly the riot squad didn’t know whether to shit or go blind. “Are we supposed to face the bank where we’re arresting people for withdrawing their own money?” they seemed to be asking as they turned around and around. “Or are we supposed to face these lunatics on the other side of the street who are shouting that they want to save our pensions while Mayor Bloomberg wants to cut them? Read More…

All rights reserved by DianeSweet

Noam Chomsky has addressed the Boston Occupation:

I’ve never seen anything quite like the Occupy movement in scale and character, here and worldwide. The Occupy outposts are trying to create cooperative communities that just might be the basis for the kinds of lasting organizations necessary to overcome the barriers ahead and the backlash that’s already coming.

In 2005, Citigroup, which, by the way, has repeatedly been saved by government bailouts, saw the wealthy as a growth opportunity. The bank released a brochure for investors that urged them to put their money into something called the Plutonomy Index, which identified stocks in companies that cater to the luxury market. “The world is dividing into two blocs, the plutonomy and the rest,” Citigroup summarized. “The U.S., U.K. and Canada are the key plutonomies, economies powered by the wealthy.” As for the non-rich, they’re sometimes called the precariat, people who live a precarious existence at the periphery of society. The “periphery” however, has become a substantial proportion of the population in the U.S. and elsewhere. So we have the plutonomy and the precariat: the 1 percent and the 99 percent, as Occupy sees it, not literal numbers, but the right picture.

Karl Marx said, “The task is not just to understand the world but to change it.” A variant to keep in mind is that if you want to change the world you’d better try to understand it. That doesn’t mean listening to a talk or reading a book, though that’s helpful sometimes. You learn from participating. You learn from others. You learn from the people you’re trying to organize Read More….

An Essay on The Politics Of Poverty and The Occupy Wall Street Movement In N+1:

The celebrated social movements of the past half century achieved their successes—however achingly partial they remain—by demanding full citizenship for Americans whose racial or sexual identity barred them from equality under the law and equal economic opportunity. The different challenge facing Occupy Wall Street can be seen, ironically, in the movement’s most distinctive slogan: We are the 99 percent. Pretty funny when a Canadian-launched agitation, started by a few hundred people, claims to represent 310 million Americans! The problem here isn’t the more ordinary one of gathering a disenfranchised group into We, the people . . . That particular story of freedom, with a deep moral and legal basis in American life, extends from the elimination of property qualifications for white male voters starting in 1811 to the gay marriage victories of 2011. It’s another thing entirely to redefine the American populace at large as an excluded group, cast out from the democracy and prosperity that supposedly form the national birthright. To imagine that something like this could possibly succeed is about as outlandish as supposing that a harassed Tunisian street vendor could topple governments throughout the Arab world by setting himself on fire.For now We are the 99 percent doesn’t come close to being true. And yet the scope of the claim—99 percent!—indicates the immense promise of the movement: nothing less than to build a left populism capable of rescuing the country in the name of the people of, by, and for whom it’s allegedly governed. Given the demoralization of the working class, the corporate domination of politics and the media, the Republican control of the House (and blockade in the Senate), this is undeniably a quixotic effort. No one but our grandparents has a living memory of the last attempt at left populism during a prolonged economic crisis. Can Occupy Wall Street eventually lead to a re-occupation of the fifty states by a citizenry with a new idea of itself? For the moment, it looks like the country’s last best hope. Read More…

Ketchup, a petite 22-year-old from Chicago with wavy red hair and glasses with bright red frames, arrived in Zuccotti Park in New York on Sept. 17. She had a tent, a rolling suitcase, 40 dollars’ worth of food, the graphic version of Howard Zinn’s “A People’s History of the United States” and a sleeping bag. She had no return ticket, no idea what she was undertaking, and no acquaintances among the stragglers who joined her that afternoon to begin the Wall Street occupation.

The lords of finance in the looming towers surrounding the park, who toy with money and lives, who make the political class, the press and the judiciary jump at their demands, who destroy the ecosystem for profit and drain the U.S. Treasury to gamble and speculate, took little notice of Ketchup or any of the other scruffy activists on the street below them. The elites consider everyone outside their sphere marginal or invisible. And what significance could an artist who paid her bills by working as a waitress have for the powerful? What could she and the others in Zuccotti Park do to them? What threat can the weak pose to the strong? Even now, three weeks later, elites, and their mouthpieces in the press, continue to puzzle over what people like Ketchup want. Where is the list of demands? Why don’t they present us with specific goals? Why can’t they articulate an agenda?

The goal to people like Ketchup is very, very clear. It can be articulated in one word—REBELLION. These protesters have not come to work within the system. They are not pleading with Congress for electoral reform. They know electoral politics is a farce and have found another way to be heard and exercise power. They know the economy serves the oligarchs, so they formed their own communal system. This movement is an effort to take our country back.

This is a goal the power elite cannot comprehend. The elites believe, and seek to make us believe, that globalization and unfettered capitalism are natural law, some kind of permanent and eternal dynamic that can never be altered. What the elites fail to realize is that rebellion will not stop until the corporate state is extinguished. It will not stop until there is an end to the corporate abuse of the poor, the working class, the elderly, the sick, children, those being slaughtered in our imperial wars and tortured in our black sites. And that is why the elites, and the rotted and degenerate system of corporate power they sustain, are in trouble. That is why they keep asking what the demands are. They don’t understand what is happening. They are deaf, dumb and blind.  Read More… 

Here is a video of Chris with Amy Goodman discussing the Occupy Wall Street Movement

 

 

 

 

They tell you we are dreamers. The true dreamers are those who think things can go on indefinitely the way they are. We are not dreamers. We are awakening from a dream which is tuning into a nightmare. We are not destroying anything. We are only witnessing how the system is destroying itself.

Naomi Klein

 

=>

Occupy George

Related articles

• Noam Chomsky Addresses Occupy Boston Protesters (dandelionsalad.wordpress.com)
• Noam Chomsky on #OccupyWallStreet Protest, Obama: the Killer, and Israel (dandelionsalad.wordpress.com)