So I believe this could very well be the future of writing. The end of the keyboard and mouse is near. Hopefully all of these services will work a lot better, like the Microsoft Kinect, and other integrated for services from Nuance or TellMe.

If you want you can purchase my VESA universal mounting adapter plate from Ponoko

The above bolt pattern is something like 35mm from center to center of each one. Which is a bit smaller than the smallest 50mm VESA standard.

I searched all around for a universal plate that would do the trick and I couldn’t fine a single option out there, that would do what I wanted. A few people online suggested drilling holes in a standard VESA plate, which is an okay option but that would leave me with something that was modified specifically for this monitor. I thought it might be better to have something that was slotted so that it could work with a larger range of setups.

Here is a photo of the plate mounted to the monitor and the VESA mounting plate mounted to my adapter.

The whole thing works great for me.

One of the most fun projects I’ve worked on in a while and you can see it here Boeing Next-Generation 737 airplane

Fast forward to today and a web application developer has a huge and amazing toolbox at their disposal. Rails, ASP.NET, Python, PHP, Flash, Silverlight, JavaScript, HTML5, CSS, Web Services like JSON, and on and on. Thanks to all the hard word and loads of talented people the limits are no longer the technology or access speeds. The limits now are only our creativity. Now we have geolocation, video, animations, and sound.

The only limit that we’ve had up until recently was that if you wanted to create interactive content you needed a client application running on your local machine. To create Flash you needed to purchase, install and use the editing tools locally. Which brings me to the point of this post. I only recently found out about a new crop of web based IDEs (Integrated Development Environment). In no particular order.

Coderun

You can create and edit .Net , Silverlight and many other types of projects. This is the best damn thing ever. I hope someone at Microsoft buys these guys.

Cloud 9

All your stand website editing power with Git and Mercurial integration. Paid accounts offer many must have features but the free version can get you up and running quickly.

Akshell

use this to create your web apps in JavaScript. Plain and simple just the way it should be.

jsFiddle

It’s not a full fledged IDE, but it is a great way to start learning, creating and sharing JavaScript snippets. Fantastic way to explore and experience in realtime how the code works.

Now for the design side of things

It’s not nearly as new but the design side has been very well covered too.

Photoshop.com

The current leader in desktop design has an excellent head start on the web with their Photoshop.com service

Aviary

Aviary is quickly becoming a designers hub online. What started as a Photoshop lite application for minor photo tweaks has quickly evolved in to one of the best collections of creative applications that run in the browser.

Picnik

My personal favorite web based photo editing tool. I became hooked on Picnik thanks to its early Flickr integration that made it so easy to jump right in and edit my photos already on Flickr.

here’s an example of the simple item model and it’s more complex element.

Model for SimpleItem

public class SimpleItem
        {
            private static FancyItem _item = new FancyItem();
            public static FancyItem Item
            {
                get { return _item; }
                set { _item = value; }
            }
        }

Model for FancyItem

public class FancyItem
       {
           private int _index = 0;
           public int Index
           {
               get { return _index; }
               set { _index = value; }
           } 

           private string _name = string.Empty;
           public string Name
           {
               get { return _name; }
               set { _name = value; }
           } 

           private string _label = string.Empty;
           public string Label
           {
               get { return _label; }
               set { _label = value; }
           } 

           private DateTime _date = new DateTime();
           public DateTime Label
           {
               get { return _date; }
               set { _date = value; }
           }
       }

Then my ViewModel is something like this:

public FancyItem myFancyItem
        {
            set
            {
                if (SimpleItem.Item != value)
                {
                    SimpleItem.Item = value;
                    InvokePropertyChanged("MyFancyItem");
                }
            }
            get { return SimpleItem.Item; }
        }

Then if my binding is something like this:

<TextBox Text="{Binding myFancyItem.Name, Mode=TwoWay}">

My PropertyChanged will never get called since I’m targeting down to the Name item. If I had an element that was directly exposing the Name string in the ViewModel then everything would work just fine. However, then I would have to duplicate all those lines of code for each variable that I want to expose and modify.

This is where my ModelBase event notification comes in to play.

public class ModelBase
        {
            public void ModelPropertyChanged(string p, EventHandler ModelItemUpdated)
            {
                ModelItemUpdated(p, EventArgs.Empty);
            }
        }

The idea with the ModelBase event, is pretty much the same as the View Model PropertyChangedEventHandler. The only challenge I’ve run in to is having to remember to feed it all the way of the food chain.

So here’s how I use it all together:

First I add some events to the parts that can be changed.

public class FancyItem : ModelBase
        {
            public static event EventHandler FancyItemUpdated = delegate { };

            private int _index = 0;
            public int Index
            {
                get { return _index; }
                set
                {
                    _index = value;
                }
            } 

            private string _name = string.Empty;
            public string Name
            {
                get { return _name; }
                set
                {
                    _name = value;
                    ModelPropertyChanged("Name", FancyItemUpdated);
                }
            } 

            private string _label = string.Empty;
            public string Label
            {
                get { return _label; }
                set { _label = value; }
            } 

            private DateTime _date = new DateTime();
            public DateTime Date
            {
                get { return _date; }
                set
                {
                    _date = value;
                    ModelPropertyChanged("Date", FancyItemUpdated);
                }
            }
        }

Then I add a listener to my simple model that fires off it’s own update event when something changes in the fancy model event it’s subscribed to.

public class SimpleItem : ModelBase
        {
            public static event EventHandler SimpleItemUpdated = delegate { };

            public SimpleItem()
            {
                FancyItem.FancyItemUpdated +=new EventHandler(FancyItem_FancyItemUpdated);
            }

            void  FancyItem_FancyItemUpdated(object sender, EventArgs e)
            {
                 ModelPropertyChanged("updated", SimpleItemUpdated);
            }            

            private static FancyItem _item = new FancyItem();
            public static FancyItem Item
            {
                get { return _item; }
                set { _item = value; }
            }
        }

Then on the ViewModel, it subscribes to the SimpleItem model event and then notifies the PropertyChanged event.

public class SimpleViewModel : ViewModelBase
   {
       public static readonly AudioViewModel Instance = new AudioViewModel();
       public SimpleViewModel()
       {
           // to subscribe to the event in the model we need to call the contstructor
           SimpleItem mySimpleItem = new SimpleItem();
           SimpleItem.SimpleItemUpdated +=new EventHandler(SimpleItem_SimpleItemUpdated);
       }

       void  SimpleItem_SimpleItemUpdated(object sender, EventArgs e)
       {
            InvokePropertyChanged("MyFancyItem");
       }

       public FancyItem myFancyItem
       {
           set
           {
               if (SimpleItem.Item != value)
               {
                   SimpleItem.Item = value;
                   InvokePropertyChanged("MyFancyItem");
               }
           }
           get { return SimpleItem.Item; }
       }
   }

It’s all a little crazy I know, but the idea here helps to extract the ViewModel from the underlying model even a step further.  Then If I need to store and retrieve my model data from isolated storage or some other external location it’s just one item that I have to get and set from as apposed to each little part.

The best part is that my UI is always up to date.