Intermission – Paying for Hulu?

It’s been out on the web that Hulu is interested in finding paying customers for it’s content. Considering that everyone is in business to make some kind of return, including those in the entertainment industry, it seems reasonable to me. So I’ve been thinking the past day or so about what I personally would be willing to pay for. I’ve boiled it down to three general options, and all would be would have to have at least one thing in common: simultaneous-release-to-web at the same time as broadcast.

1) A “Plus” package.

This would be Hulu has we know it BUT with a) release to web at broadcast time, and b) a more expansive catalog of shows with deeper/older archives.

I would value this at around $10/month even if it had commercials for Hulu-delivered content.

2) A “Premium” package.

This would include the plus package, a selection of 10-20 local and cable station live simulcasts of my choosing, plus the option of online movies (first 4 free or discounted per month).

I would value this at around $20 even if it had commercials for Hulu-delivered content.

3) An “Ultimate” package, but with some real-teeth.

This would include the premium package but all Hulu-delivered programming would be commercial free after 24 hours after release date, 20-40 local and cable station live simulcasts of my choosing, on demand movies (first 12 free or discounted per month), a catalog of NBA, NFL, and MLB  on-demand replays (up to 7 days) for 3-5 teams of my choice.

I would put this at $30-$40 per month. I would want this to be my ‘digital cable’ that goes with me.

Impressions – Office 2010 Beta and Thoughts on the Future of IE

The other night I tried out the Office 2010 Beta by using Click-To-Run to install. Nice experience! Very nice! All I had to do was enter a key, let the installer whirl for a few short (very short) minutes and then I was presented with an open Power Point app that highlights new office features as well as showing off Power Point’s new GPU animations. Best of all I didn’t have to uninstall my current version of Office just to try the beta.

Now this all happens thru app-virtualization which downloads the apps incrementally, and allows the apps to be available when the majority of the components are installed. BEST OF ALL – the app will be updated AUTOMATICALLY as updates become available.

Now … you can more than likely see where my madman web-dev self is going. IE should be delivered via app-v and should be delivered once more and for always. Did I just say that? Yes. Let’s look at the Pros and Cons.

PROS

• Security would always be up to date. 

  Considering the blow-back from IE 6 & 7 in regards to the recent Google hacking incident having worry free automatic updates would be a major plus.

• Progressive deployment of web standards.

  IE could have ‘feature modules’ added along with other upgrades added to the mix as they become available. No more needing to get that next version of IE to get that next generation feature, and then wait for two years for everyone to catch up. 

  Want proof this would work? Check out these FireFox install-base stats. Notice the rapid transition to v 3.5 that is underway? Don’t you wish the IE transition was that fast?

  If this were done there could be a RAPID, BROAD AND CONTINUING roll out of sites embracing new web standards for a massive number of users one the browser uptake reached critical mass. 

  No more waiting 2 years for that next update. When it’s ready – it ships in a ‘No-brainer’ way to EVERYONE.

• User Bliss!

  Imagine telling a user ‘Install this version of IE and it will be the LAST version of IE you’ll need to install for a LONG TIME. No – seriously. Updates will be automatic, that includes security and new features.’

CONS

• Moving to a modular release pattern would be very difficult for the IE team.

  An app the size of IE may be very (extremely?) difficult to refactor in such away as to deliver progressive updates via app-v. As an example of modular design benefits the IIS team for version 7 did a MAJOR redesign and they have rolled out a LARGE number of out-of-band updates. They’re very competitive and timely.  

• Installed IE components are often application dependencies for 3-rd party apps.

  Even though IE has been gradually pull back out of the OS, it still has a very COSY relationship with the OS and lost of programs deployed depend on IE components being installed. My guess is that app-v would make this difficult to manage.

  So putting IE in app-v would not be a singular issue unlike browsers on windows. 

• Corporate roll-out would always be slower.

  Like it or not corporate IT for the most part always moves slower. They want to test the updates, they want to deploy on a schedule. Understood. There would need to be some way to allow corporate users to prevent feature/modular updates for a short period of time (3 months). Would this even work? How would you version for this x-ua-compatible?

• UI interface changes would be jarring.

  This is probably the least amount of concern. As long as the UI undergoes a slow transition you could have a browser update/welcome page that shows the new features that have been automatically updated for them. New installs wouldn’t be a problem because the app-v installer would always download the freshest version of the app.

I’m with Coco! (Off topic)

Where he goes – I’ll watch. My brother got me interested in the new Tonight Show in late November and I have enjoyed the show. Never cared much for Jay – don’t dislike him – just never really thought he was interesting. Letterman – please. He just such an anachronism now. (But man – I loved the pencil throwing 80’s.)

Fox – please pick up Coco.

NBC – "You are who we thought you were!”

Asp.net MVC – HandleUnknownAction in Controller

Sorry I have been away so long. Work has been very busy and I have been doing a lot of planning for new projects, reading, rebuilding the notebook and trying to endure winter. Needless to say I have been away for a while.

So … I have started to look in building MetaWeblog support into an MVC project and have found a dearth of examples. So after doing some reading, testing, reflectoring, etc. I have decided to role my own. “Why not?” I figure.

The first thing I tried was to create a basic MetaWeblog action model and custom model binder. The model binder (which was easy to make) worked, but it didn’t solve the big problem – I want to create individual methods for each MetaWeblog RPC, and that wouldn’t cut it. I considered making a filter, but that wouldn’t work either. So the the next thing was to try to hack the controller, and that seems to work nicely.

One of the things the MVC team has done a nice job is keeping the architecture of the MVC platform simple and open. I started using reflector to find an easy access point to inject a change to action method called and sure enough I found it the ‘HandleUnknownAction’ of the Controller class. I’ll show an example and then explain:

Code Snippet

1. public class UnknownController : Controller
2. {
3.  
4.     protected override void HandleUnknownAction(string actionName)
5.     {
6.         if (!String.IsNullOrEmpty(actionName))
7.         {
8.             //set unknown routevalue
9.             ControllerContext.RouteData.Values["UnknownValue"] = DateTime.Now.ToString();
10.  
11.             if (this.ActionInvoker.InvokeAction(this.ControllerContext, "UnknownAction"))
12.             {
13.                 
14.  
15.  
16.                 return;
17.             }
18.         }
19.  
20.         base.HandleUnknownAction(actionName);
21.     }
22.    
23.  
24.     public ActionResult UnknownAction([DefaultValue("")]String UnknownValue)
25.     {
26.         return Content(String.Format("UnknownAction: {0} : {1}", RouteData.Values["action"],UnknownValue));
27.     }
28.     
29.  
30. }

The highlights:

• So for a simple test I just wanted to redirect the action of the ‘actionName’ parameter existed. And unless you change the route defaults it’s ‘index’ – so we are good here. (The base method of HandleUnkownAction is simple – it just throws an Http error. )
• Next I injected an new route value keyed as ‘UnknownValue’ and this matches a parameter on the ‘UnknownAction’ method I am going to call. (Yes! It does bind!’)
• Last we call the ‘InvokeAction’ method on the ActionInvoker property of the controller. Important: you must return if the of the InvokeAction method succeeds. And the rest just works as if your calling a normal action method.
• The results are simple. Here is an example:
  UnknownAction: Index : 1/14/2010 12:54:53 AM

So I am thinking that this would be a good basis for creating a MetaWeblog API handler using basic MVC conventions. I’ll provide more information as I get further along.

Visual Studio 2010 Beta 2 – First Impression

Fast. Seriously, embarrassingly fast. Nice job!

Visual Studio 2010 Standard?

Just read at Mary-Jo Foley’s  blog that it looks like a lot of the VS 2010 Team Editions are being reworked. But the also mentions a change in SKU’s and that has me wondering if a Visual Studio 2010 Standard edition will be released. I’ve purchased VS 205 and 2008 editions and thought it was a great way to get all the languages without a lot of the Pro edition bells and whistles. And I thought it was worth paying for between $199 – $299.

I would love to hear from Microsoft what is happening to this edition and the future of the express editions.

Strong-Typed Routes with Asp.net MVC 2 Preview 2

Last weekend I enthusiastically went on and on about using Strong-Typed routes in MVC 2 Preview 2 based on Goran Gagic’s elegant sample. And so I have built on his code and I have something to share.

Download Sample Project Here

I am going to dive more into usage than working internals, so let’s get underway.

Project Configuration

I have made some configuration changes to the sample project to better illustrate the feature set and make usage very convenient when constructing views. First, I have added a few namespaces to the web.config as you can see in the image below:

The namespace ‘MVC2_TypedRoutes.TypedRoutes’ (the ‘TypedRoutes’ folder) contains the extensions and support classes for strong-typed  route value creation. Secondly, I have added an additional routes in the global.asax as show below:

Both of these routes utilize the TypedRoutesController exclusively, but differ in their signature using the ‘_RouteName’ value. I have also set up a simple controller that will be used to demonstrate the features. Let’s look at the controller:

There are several attributes applied here that are leveraged by the strong-typed route extensions. Let’s review them:

• RouteActionAttribute

  This attribute has a single property named ‘PassThru’ that allows for a entering a comma separated list of route value names to be passed thru when creating routes. This attribute can be applied to a class or method.

  In the sample it is applied to the class, so all strong-typed routes created for the TypedRoutesController will have the ‘_RouteName’ route values passed along when generating a route call.

• RouteValueAttribute

  This attribute allows for specifying a format for the values in the route (especially handy for dates), default values and if the parameter is ignored in creating the route. It can be applied to parameters or properties.

  In the sample as applied to the ‘Date’ parameter in the ‘Sample1’ action method it specifies a default DatetTime of Jan 1, 2000. If the date value submitted when creating the strong-typed route in an Html.ActionLink<Controller> extension matches the default, it will not be passed to the resulting route. Additionally, the ‘Format’ value is specified and a route friendly format for the date parameter will be used.

Additionally, the ‘Sample2’ action method has the MVC BindAttribute applied and this will be used by the strong-typed route extensions as well.

Project Usage

The sample get’s right to the point, creating three strong-typed routes inside the HomeController ‘Index’ view to the TypedRoutesController. Let’s take a look at the ActionLink<Controller> calls and the resulting routes.

Sample ActionLink Route 1

Here’s the run down on using the strong-typed ActionLink:

• It’s a generic method – so you have to specify the controller
• The first parameter is simple – the title for the action link
• The second parameter is an expression based call to a method on the TypedRoutesController, in this case ‘Sample1’. (Notice the date supplied is the same as the default specified by the RouteValueAttribute.)
• The third parameter is something I have not mentioned yet. This is a expression call that leverages a fluent-interface object that allows you to easily set route values, route value formats, and html attributes. Let’s take a look at the signature of the fluent-interface object:

     

  As you can see you can  apply single or multiple attributes, formats or values. And for attributes I used the JQuery ‘Attr’ for html attributes. (Important note: any formats or route values specified here will override those specified by by the RouteValueAttribute applied to the action method or the method expression provided by calling the Html.ActionLink<C> extension or Url.Action<C> extensions. Phew!)

  In this case we are submitting a route value for ‘_RouteName’ of ‘TypedRoutes1’.

Here is the resulting route:

/TypedRoutes1/Sample1 

Here is a brief run down:

• The Date RouteValueAttribute default is matched so the value from the ActionLink extension is not passed along in the route.
• The route ‘TypedRoutes1’ is called specified by supplying the appropriate ‘_RouteName’ value.

Sample ActionLink Route 2

 

Let’s look at the differences:

• We are calling the same action method as in sample 1 above, but this time we are specifying the current time.
• This time we are submitting a route value for ‘_RouteName’ of ‘TypedRoutes2’.

Here is the resulting route:

/TypedRoutes2/Sample1?Date=2009-10-18

Notice it correctly chose the ‘TypedRoutes2’ route and submitted a date value formatted as specified by the RouteValueAttribute applied to the method Date parameter.

Sample ActionLink Route 3

Here is the brief run down:

• This sample calls a different action, one that takes a complex object.
• Like sample 2above we are submitting a route value for ‘_RouteName’ of ‘TypedRoutes2’.
• Also, if we look at the controller it has a BindAttribute applied with a prefix. This will be used in formatting values in the route.
• Also we are specifying a custom format for ‘TestObject.Date’.

Here is the resulting route:

/TypedRoutes2/Sample2?TestObject.Name=Sample 2 Link&TestObject.Date=2009-10-18

 

That’s It for Now

But before I go a few additional notes:

• This was compiled for MVC 2 Preview 2 but can easily be made to work under MVC 1 by removing the ‘ToHtmlString’ method calls which are new in MVC 2 Preview 2.
• The RouteValueAtrribute can be applied to properties in complex objects being used as action method parameters, but I have not made extensive testing of this.
• There are additional views in the sample project that shows off the subtle power of using the ‘PassThru’ property of the RouteActionAttribute.
• There are also Action methods of the Url helper for use in view or controllers.

 Download Sample Project Here

MVC 2 Preview 2: Strong-Typed Route Links and Other Thoughts

I’m setting here and looking back at when I last made an entry – September 20th. Been a while. Work as been very busy and I’ve been engrossed in exploring MCV 2 on my own time.  So let’s get to it.

Strong-Typed Route Links

I have been investigating this heavily the past week or two. Based on past experience I have found the notion of un-typed, “magic string” routes to be a bit of insanity. So, with it appearing that strong-typed route links are no longer on the MVC 2 roadmap finding a solution was paramount. I’ve seen two nice solutions thus far.

The first thing I found was  David Ebbo’s T4MCV t4 template. It’s a very nice piece of work. You’ll find it on codeplex along with the the MCV 1 source code. Here’s the link: http://aspnet.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=24471

Setting up T4MVC was quite easy. Just drop it into your project root and go. It will create strong-typed routes, links to scripts and much more. It’s a very nice piece of T4 template work. However, I personally had a few concerns. The biggest is the method you call to create the route is not the same method in your controller, it’s an overload that returns the values in a special ActionResult object. Now – you might be thinking – what’s the problem? Let’s say I want to use my own attributes to control how parameters are formatted in making a route. (Specifically, I wanted to format a DateTime object because the default ‘ToString’ representation is not route friendly at all. ) Since it’s an overload the attributes are not there, T4MVC does not copy them, and for met to put them there and use them takes a lot of T4 hacking that I really don’t want to get to (no Intellisense).  So while I really respect the work – it wasn’t what something I could easily tool to my liking. So with great regret, I pulled out T4 MVC based and went solution hunting again. What was I after? I was looking for an expression (as in lambda expression) based solution. And then I stumbled on on Goran Gagic’s sample. Here’s the link:
http://www.visualsoftware.net/Blog/post/2009/09/26/Strong-typed-ASPNET-MVC-Action-Links-My-ingenious-secrets-Part-1.aspx

Curiously, it’s the only blog entry he has. But it’s a gold mine. He has a very nicely written sample solution ( even saith  The Haack ) that serves as a foundation for building a strong-typed route link system, and also serves as an well documented insight into using lambda expression. So I’ve taken the sample and worked in the ideas I wanted to implement and will be posting a full solution in the next few days. But here is a bit of my thinking on why I wanted this kind of solution in the first place.

The main conclusion I had when trying to work with T4MVC is that while a controller action method can serve as the basis for making a strong-typed route link there needs to be tools for formatting the route derived from the method. And after considering several avenues I decided on attributes directly applied to the controller action method. Why? They’re already being used to nice effect already. For example the ‘ActionName’ attribute allows you to have a different route name (say if want to use a logical method name but also want the same method to be the controller’s ‘Index’ action). In MVC 2 the ‘DefaultValue’ attribute allows you set a default for parameters not passed along in the route. (This is a nice workaround for .net 3.5 and won’t be necessary for 4.0 as C# 4.0 supports optional parameters with default values). And the ‘Bind’ attribute allows you to choose a prefix for a parameter and even set includes/excludes on complex objects. So creating a ‘RouteValue’ attribute is a logical extension. Here’s an example (this method  exists in a controller class named ‘ArticleVisualController’ as you will see later ):

   1: public ActionResult Date(

   2: [DefaultValue(typeof(DateTime),"2000-01-01"),RouteValue(typeof(DateTime), "2000-01-01",Format="yyyy-MM")] DateTime id,

   3: [DefaultValue(0),RouteValue(Default=0)] int index)

   4: {

   5:     //method body here

   6: }

In this case the RouteValue attribute is supplying two kinds of detail. First for the ‘id’ parameter it’s supplying the format of the DateTime to be used in the route. Secondly  on the ‘id’ and ‘index’ parameters it’s providing a default value, and if the parameter value from the called method expression matches the default it will not be added to the RouteValues dictionary. Here are examples of creating an action link for the method above:

   1: <%
   1: = Html.ActionLink<ArticleVisualController>("Date", a => a.Date(new DateTime(2009,09,01),0))
%>

   2:  

   3: <%
   1: = Html.ActionLink<ArticleVisualController>("Date", a => a.Date(new DateTime(2009,09,01),1))
%>

Here are the corresponding routes created:

   1: <a href="/testing1/Date/2009-09">Date</a>

   2:  

   3: <a href="/testing1/Date/2009-09?index=1">Date</a>

   4:  

You can see in both resulting routes the DateTime is formatted as requested (ModelBinding ‘magic’ will ensure it’s a real DateTime object when the controller action method is called in the request) and in the first route the ‘index’ parameter is not added as the value matches the default.

Here is a list of things I will looking to support:

1. Route parameter formatting
2. Route parameter default values
3. Using the ‘Bind’ attribute ‘prefix’, ‘include’ and ‘exclude’ properties
4. Using the ‘ActionName’ attribute
5. Support for complex parameter types
6. And a few others …

I have about 75% of this work done and need to polish for a sample release hopefully next weekend.

Thank you Goran Gagic! You have shown the way!

Lambda Expression Compile Caching Namespace

Honest! The API has it’s own name space and supports several expression types. It looks like this was made to speed the DataAnnotations work, but it’s all internal. Having an open API would help. Wondering if that’s in the plan (or could be) for the beta. Lots of MVC blog posts seem to be leaning towards expression usage and having Lambda Expression compile caching out of the box would be helpful.

And on that matter, is Lambda Expression compile caching a part of .Net 4.0? If not – curious to know why?

Client Side Validation

It works! All you have to do is link to the jQuery and asp.net Ajax scripts and it works. It is not implemented when using ‘Ajax.BeginForm’ – and this is probably a good idea since you never know what’s coming back and avoids wire up problems.

Areas and Related Tips

Nicely done. I am hoping there will be an ‘areas’ folder out of the box added to new projects to the beta. Why? See the first tip below.

1. Area view compilation problems. If you run into this just copy the ‘web.config’ from the normal ‘View’ folder and place it under the ‘area’ folder. This will give your views the appropriate compilation settings and prevents them from being viewed by direct url call.
2. Controller namespace in ‘Areas’. If you move a controller from the normal “Controllers’ to a custom area ‘Controllers’ folder be sure to update the namespace. If not it won’t be available and you’ll be stuck with a 404 error.

Lambda Expression Programming Insights?

Does anybody know of any good resources for this? What I don’t mean by this is how to write expressions for linq – but for documentation, tutorials and/or books on how to do custom programming with them as the strong-typed route link Goran’s sample does. I would love to grok it.

Asp.net MVC 2 – Of(T).Item for Html.DisplayFor

Sometimes the easiest solutions are not always obvious. Take for example  if you try to call against the indexer of a list when calling ‘Html.DisplayFor’ such as:

   1: <%
   1: for (int i = 0; i < Model.Elements.Count; i++){
%>

   2:       <%
   1: =Html.DisplayFor(m => m.Elements[i])  
%>

   3: <%
   1: }
%>

You get the following error:

System.InvalidOperationException: Templates can be used only with field and property accessor expressions.

 

Well – that sucks. And so I went and made workarounds such as DisplayItemFor, and yet found it wanting. And I explored into the bowels of lambda expressions, and I wanted out.

And then it hit me. You can only return expressions that are for properties or fields. Okay – so let’s say I do something like call the indexer and then a property on the returned object:

   1: <%
   1: =Html.DisplayFor(m => m.Elements[i].Title)  
%>

Okay – that actually works because we end with a property expression. But what if you use a foreach loop instead. Here is the ‘Html.DisplayFor’ call:

   1: <%
   1: =Html.DisplayFor(m => m.Elements[m.Elements.IndexOf(element)].Title)  
%>

And that works to … but who wants to write that? I don’t. And you still don’t have the capability of calling an object template for just the element after all of that work.

Okay – so what about using Linq? Actually, you can make that happen if you just remember to end with a field or property expression:

   1: <%
   1: =Html.DisplayFor(m => m.Elements.Where( e=> e == element ).Select( e=> new{item=e}).FirstOrDefault().item)  
%>

That actually works for the object template and the field and property templates out of the box. But who wants this much Linq fun when all you want is an element tied to an expression of the ViewModel? (I don’t).

So why not try an extension method – just make for any enumerable. It needs to be simple to call, and we need to get element back in the for ofm a callable property.

Here is an example for an object template would look like:

   1: <%
   1: =Html.DisplayFor(m => m.Elements.Of(element).Item)  
%>

Here is an example for a field or property template would look like:

   1: <%
   1: =Html.DisplayFor(m => m.Elements.Of(element).Item.Title)  
%>

And below is the code. It is simple and works. When you call the ‘Of’ extension method it does the following:

• Verifies that the element passed in is in the enumerable (in this case m.Elements).
• Returns a simple wrapper object that contains the element passed.
• The element is returned by the wrapper property ‘Item’, making easy to get an object template.

Here’s the code:

   1: public class EnumerableItemOf<T>

   2: {

   3:     internal EnumerableItemOf(T Value)

   4:     {

   5:         this.Item = Value;

   6:     }

   7:     

   8:     public T Item { get; private set; }

   9: }

  10:  

  11:  

  12: public static class LinqUtility

  13: {

  14:     public static EnumerableItemOf<T> Of<T>(this IEnumerable<T> Enumerable, T Item)

  15:     {

  16:     

  17:         if (Enumerable != null && Enumerable.Contains(Item))

  18:         {

  19:             return new EnumerableItemOf<T>(Item);

  20:         }

  21:     

  22:         return new EnumerableItemOf<T>(default(T));    

  23:     }

  24: }

Take the Red Pill – Think and Vote Independent.

I know I don’t have many readers if any – but maybe someone out there will pick this up. Maybe there are people out there who are listening.

I once had a person ask me if I was voting Democratic? I told him no. He told me that he was, because ‘he was smart’ and by implication I wasn’t. It was offensive, and I told him so, especially because he was working for a local school district and I was working in free enterprise. And then came the excuses about no WMD’s in Iraq, the ‘stay the course’ as a strategy speech, Katrina, lack of determined action on health care, excuses about firing Rumsfeld, the banking bust and then TARP. In the last election I voted for Bob Barr. I couldn’t trust Obama with my wallet, and the Republicans become something out of a Monty Python skit.

Now as a brief tangent – I want to look at scene from recent global political history. In the late 1930’s Europe was dominated by Nazi Germany and their chief rival in the region was the USSR. It was Hitler vs. Stalin. Left vs. Right. Surely there was one side to cheer for? From all that we know – no. Here is what they did:

• Directly killed over 50 million in 10 year window thru war or non-sustainable imprisonment.
• Actively enslaved their own country mean (through direct or indirect means? who really cares) to forward their own personal ambitions.
• Almost destroyed their own countries.

Neither country was worth supporting. When we defeated Nazi Germany, many Nazi officials and officers actually tried to compel us to take up arms with them to defeat the Communists, seeming to not understand that they were are  as corrupted and diabolical as their opponent. It’s only out of circumstances that we had a brief military alliance with Russia – a kind of ‘the enemy of my enemy is my friend’ thing. If you’ve been alive for more than 30 years you know for certain just how bad the cold war aftermath was.

The point is that you can have two opposed groups and neither one is with supporting.

The far right is now what I call a ‘Schoolyard Bully’ fringe. They intimidate others, attempt to keep people in line by scaring the hell out of them or reminding them why the should be scared. They don’t believe in rational government regulation because they don’t want to get caught swindling others. And when the chips are down they are far less likely to be reasonable, rational, principled or consistent, and they are not ashamed of this. They are actually soft.

The far left is the ‘Confidence Man’ fringe. It’s taken me a long time, but after watching enough episodes of Lost I’ve figured it out. They are con artists. They want you to think that all the things they want to do are really your idea. They take their time. They flash some cash. They say nice things about you. They get a supporting actor to play the victim part. And when you bite on their ideas, just remember they are not to blame when you are stuck with the bill. After all – you are the one that said yes. Try to expose them for what they are and these ‘thoughtful, patient, intellectual types’ will try to tear you to pieces. They are actually vicious.

And just to be fair, the far right has held more than a few in their ‘confidence’, and the far left has bulled more than their share as well. But in general this is the way they act. Both support classical un-American positions such as nationalization of entire industries or getting a bailout when their financial empires come crashing down. They believe that corporations exist to be used as hosts and drained until they go bankrupt, or that those that cannot afford health care are just losers – there is no problem.

They tend to both be takers, not makers. They wouldn’t have their place with out the creators such as Jobs and Gates, Ford and Durant, Edison and Bell and all of the other countless men and women that worked with them or like them to make their lives better by making others more productive. This is the real American Way. It’s the Win-Win scenario and it’s not easy. This is what people are striving for. And this is what is at stake.