All Apple needs now is a VM and maybe even a new language.

There is a saying that a piece of data does not exist unless there are three copies of that data. I have always agreed with that principle, but always came short of actually adhering to it. I used local backup solutions to make two copies of my data, but making that third copy was always deferred for later. Well in part because its been sitting in my OmniFocus todo list, my vacation starting this week, and also being inspired by Lab49 colleague Martin Harris’s post Diary of a cloud backup I have finally decided to make that third copy with a offline backup solution. Lets first see what the current setup looks like.

The setup

So I have three macs in the household that has important enough data to be backed up:

Mac Pro – The Mac Pro is my main desktop machine. It has ~300GB of files consisting of documents, music, RAW photos, and AVCHD video (this is the big one) that needs backing up. It is currently setup with Time Machine backing up to an attached Drobo with 1.8TB of space. The Drobo gives it it a bit more safety since the data will survive one HD going bad.

iMac – The iMac is my wife’s desktop machine. It has ~400GB of files mostly consisting of AVCHD video (taking video of your daughter is quite expensive indeed!). It also has Time Machine backing up to external HD enclosure with 2 1TB drives in a RAID 1 (mirrored) configuration.

MacBook Pro – The MacBook Pro acts as an extension to the Mac Pro. Active documents and files are synchronized using Dropbox. Non active documents and files are synchronized on a demand basis using unison. It has no backup strategy since its basically a mirror of the Mac Pro and the backups get done on that box.

The reqs

As Martin Harris stated a third offsite copy is crucial to be truly safe in case of environmental disaster or theft. Given my current setup I had the following requirements:

• 700GB of data
• Run on at least 2 Macs

Some other considerations in a backup service:

• Versions of files – Allow you to recover previous versions of modified or deleted files. Not really important for me, since my Time Machine backup handle this.
• Encryption of data – Ensure privacy by securing the session used to backup, and the data in storage.
• Reliable storage – The online storage storing your data should be reliable. At least make sure the backup service uses RAID to protect against hardware failure.
• Backup control – Controls to backup data when you want and as fast as your want. Features should include idling during computer usage, caps on upload, and scheduling.
• Recovery support – Include considerations such as time to recover, availability of physical recovery media, granularity of recovery. Again not super important for me since I am using the service as primarily a disaster recovery service. But even in this case having a physical recovery media option is a nice to have, and time to recover should be too long.
• Interface – Nice intuitive UI is always a plus but not necessarily crucial for a backup service.

The cost

I checked out the plans for for Crashplan, memopal, Carbonite, and Mozy. It seems if you are in the sweetspot of having 1 computer with about 200GB of data to backup you can find solutions ranging from free to ~$50/yr.

Both Carbonite and Mozy have unlimited storage plans per computer for ~$50. Memopal costs around $380 for backing up 700GB of data.

Crashplan has an unlimited computer and storage plan for $100 a year. Given my storage and computer requirements and since it since it met most of my other considerations above Crashplan seemed to be a good choice for a trial.

The settings

I decided to trial Crashplan with a ~50GB backup (54.1GB to be exact). Crashplan allows you to tailor the backup to put it on a schedule, and control CPU and network utilization. I have a 30/5 Mbps cable connection and for the first test ran the backup with these settings:

• CrashPlan will run: Always
• Limit when away: 2Mbps
• Limit when present: 200 kbps

The checkpoint – 7.75 GB/day

• 3/21/10 6:45pm – 54.1 GB Backup started
• 3/24/10 7:00pm – 31 GB backed up, currently going at ~200kbps

So as of the first checkpoint Crashplan is going at a rate of 7.75GB a day which is roughly 720 kbps. Which does fall in between the present limit and away limit of 200kbps and 2Mbps respectively. It seems on the slow side, and extrapolating it would take about 3 months to backup the entire 700GB.

The next steps

At 2 Mbps Crashplan should backup at a theoretical rate of 21.6 GB/day or 700GB in about 33days. Obviously that would require some ideal conditions such as ensuring that no other computers are using the connection and a guaranteed upload bandwidth from your ISP. But I should be able to come close with a 5 Mbps upload connection. As an experiment I am changing the backup settings to the following for the next checkpoint:

• Limit when away: 2.5Mbps
• Limit when present: 2Mbps

Hopefully that shouldn’t saturate my connection too much.

The first time I used a Bloomberg terminal, I was taken aback by the interface and its steep learning curve. I am not a UX designer (IANAUXD), but wouldn’t a redesign of a complex system carry a risk of imposing a loss of productivity on its users? The Bloomberg terminal given its warts is extremely powerful and experienced users of the system would have ingrained usage patterns into there brain and muscle memory. Inertia from users does come to play here but a good redesign of a system with an established user base needs to take this into account.

Anyway with some competition from Single Dealer Platforms (SDP) with slick UX, as exemplified by Morgan Stanley’s Matrix, who is to say that Bloomberg is not redesigning there terminal right now?

I just ran into the Code Bubbles project, which abstracts aways the file and exposes code and documentations as arrangeable code bubbles on a expandable canvas. Its an interesting idea worth exploring and experimenting with.

Probably will need to check out the beta and play with it a bit.

User Interface
The web has a number of advantages over rich client applications. Some of the advantages are ease of deployment and centralized data storage. The one advantage that a web application does not have is User Interface. AJAX helps bring back some of the interactivity that is lost when moving from a rich client applicatin to a web application. But it is not a panacea that it is hyped to be. It has a number of issues for those that are used to rich client applications.

Specifically for Gmail, here are my issues:
1. The keyboard shortcuts in Gmail are great improvement over legacy web interfaces. But what is the Delete keyboard shortcut? I know there is an Archive keyboard shortcut and a Delete Button, but it is not the same. How do you select all messages on the page with the keyboard? Point being is that most rich client applications worth its salt allows you to change keyboard shortcuts to your hearts desire.
2. How do you drag and drop anything in Gmail?
3. Window management is a nice feature of Gmail, but no where near the interactivity I get with a rich client application. I like opening a message in a new window by just pressing the enter key.

I think the point is that Rich application gives you more flexibility than web interfaces. AJAX helps a lot, but it is all just playing catch up, and will probably never catch up fully.

Because of these reasons, I try to use a rich client application as much as possible over Gmail’s web interface. Which brings me to another reason I am leaving Gmail:

External Access
Gmail’s external access is horrible. The only option you get for accessing Gmail with an external mail reader is POP. And its not like standard POP I see in every other POP mail server in existence. You cannot realistically have two POP clients retrieve mail from Gmail. Even if you set the POP clients to keep messages on the server, the two POP clients will not automatically get the same message. Whoever checks the POP mail first will get the message and other POP clients are out of luck, unless you manually reset the POP settings in Gmail. Not nice.

Thoughts
I love the web’s ability to keep your data centralized and accessible from any computer. What I don’t like is the browser interface. I am a fan of hybrid applications, in which rich applications interact with the web. Currently we have rich applications that are distributed by conventional means, but access the web to leverage the web’s centralized data storage capabilities. The next step is for rich applications to be deployed over the web in a platform agnostic way.

One glimpse of how one can utilize the web is NewsGator. It provides multiple interfaces to the RSS feeds it manages. It provides a Web Interface, Mobile Interface (for PDA, and Cell Phones), and Rich Client applications. This way a user can manage there RSS feeds truly anywhere, with whatever interface they have access to at the moment.

So with that rambling commentary aside. I say goodbye Gmail. It was truly delight to have all that storage at our fingertips. But ultimately, it was just too difficult for my fingertips to conform.

After failing to find a solution after googling for a VS option or VS Addin that provides this functionality, I decided to roll my own. This is how I did it:

1. I created a Visual Studio .NET Addin Project in Visual Studio. I chose C# as the language to develop the addin, but VB and C is also available. The Visual Studio .NET Addin Project generates C# source for a Connect class. The Connect class is a COM Interop enabled class which will generate a COM object with a Prog ID of [addinName].Connect. The Connect class implements the IDTExtensibility2 COM interface, which VS uses to load and interact with the AddIn.

2. The OnConnection method of the IDTExtensibility2 interface is called by VS whenever an Addin is loaded into the environment. The default OnConnection method implementation saves references to the application object and addinInstance objects in fields. The application object is a COM class which implements the _DTE interface. The application object can be used by the AddIn too interact with Visual Studio.

I modified the OnConnection method to subscribe to two events:

windowEvents = applicationObject.Events.get_WindowEvents(null);
windowEvents.WindowActivated
 = new _dispWindowEvents_WindowActivatedEventHandler(WindowEvents_WindowActivated);

applicationObject.Events.SolutionEvents.Opened
 =new _dispSolutionEvents_OpenedEventHandler(SolutionEvents_Opened);

The WindowActivated event needs to be handled because, I needed to change the window title anytime a document was switched to. And the window activated event is the closest event I could find in the object model that came close to doing this.

The Opened event occurs whenever a solution is opened.

3. The SolutionEvents_Opened event handler extracts the solution filename from the path of the solution and saves it in a field. The path of the Solution may be retrieved using the Solution.FileName property. You could be led to believe that the FileName property will return just the filename of the solution as the name suggests, but alas it returns the entire path:

private void SolutionEvents_Opened()
{
	_solutionName =
Path.GetFileName(applicationObject.Solution.FileName);
}

4. Now in the WindowEvents_WindowActivate event handler we need to set the Window Title.

Since I just wanted to prepend the file name of the solution to the window title, I first checked to see if the solution file name is already there:

if (_solutionName != string.Empty)
{
	if (!applicationObject.MainWindow.Caption.StartsWith(_solutionName))
	{
...

Now we can just set the window title like below right?

applicationObject.MainWindow.Caption = _solutionName   " - "
  applicationObject.MainWindow.Caption;

Nope. The Caption property cannot be set for the MainWindow. So I had to resort to the Win32 API and use a function called SetWindowText:

[DllImport("user32.dll")]
static extern bool SetWindowText(IntPtr hWnd, string lpString);

The above is a PInvoke signature for the SetWindowText Win32 function. It accepts an hWnd which is a handle to a window, and the string to set as the text of the window. For “normal” windows setting the text of the window changes the window title.

So now because MainWindow conveniently provides an HWnd property which will receive the window handle of the main window. I could set the window title of the VS window title like this:

IntPtr hwnd = (IntPtr) applicationObject.MainWindow.HWnd;
SetWindowText(hwnd, _solutionName   " - "
  applicationObject.MainWindow.Caption);

5. Compile and then voila!! I could load my addin into VS and have the solution file name appear in the VS window title. Now getting this AddIn installed onto other machines is a different story, and is better left off for now.
interracial free movies sexvideo free sex movies downloadfree trailers xxx moviewild gone movie girlsregal theater moviesapphic pink moviessamples sex moviemovie strip Map

I particulary find useful the tip on the Find Combo Box. The Find Combo Box may be used a a mini Command Window so you can do something like:
1. Ctrl-D
Keyboard shortcut to get to the Find Combo Box.
2. > open [file]
Open any file in the current solution. The great thing is that intellisense works here for completing the filename.

Bjarne Stroustrup the father of C has a sneak peek of the upcoming features of the next version here.

It looks like the new C will make generic programming simpler to use. The new C will have “concepts” which are similiar to the where clause in C#. Concepts specifies the properties required of a type in a template specification. More information can be found in the article above.

I am excited to see what the new C will bring us, as C is my first programming language love.lesbians movies sexloews movie theatremature ebony movieshardcore movies and milano melissaloca movie mi vidathe miami movie vicemovies breasts milkingcrack collector moviemovie cummovie monologues female

A thousand feet view of Fluent Interfaces is that it makes development in general purpose object oriented languages look more like programming in a natural language. Or more specifically more domain specific and “fluent”.

This is something that may gain popularity in the future, as the development community tries to minimize complexity in software development. Developing in the language of the domain focuses development on the domain logic and away from the machinery of the underlying technologies used to develop the application.

And on second thought may lead to new “fluent” oriented languages that specifically accommodate development with fluent interfaces. It will be interesting how the software development community reacts to fluent interfaces.

So I am writing this Windows Forms application with the .NET Framework 1.1. The Windows Forms Application reads messages from MSMQ (Microsoft Message Queue). And on a ReceiveCompleted event handler I update some model objects with the data read from the message. Simple enough if everything goes right. If everything goes wrong on the other hand, it will lead you deep into issues beyond your control, and will leave you scratching your head in disbelief.

I noticed that my model objects were not getting updated with no output what so ever, from Visual Studio or the application itself. After checking that I was indeed receiving messages from MSMQ, I stepped through the code and noticed that if I stepped over a particular call to a DataSet method the application would just continue to run and not break at the next line. Interesting I thought, that would only happen if an exception was thrown but no unhandled exception message box was ever displayed by Visual Studio.

So I surrounded the offending statements with a try catch handler and lo and behold an exception was being thrown. I had forgotten to add a primary key to the DataSet. I probably should have added exception handling when I wrote the code, but this bothered me. You cannot anticipate every exception that will be thrown when developing a non trivial application, so there will be times when you miss an exception and you the traveler want to be notified of it.

The standard advice for “handling” unhandled exception’s is to define exception handlers in three different places in a Windows Forms application:
1. Surround your Application.Run call with a try … catch block. This will handle exceptions from the main application thread.
2. Add a handler to the Application.ThreadException event. This will handle exception on UI Threads.
3. Add a handler to the AppDomain.CurrentDomain.UnhandledException event. This will handle exceptions on all other threads (worker threads, thread pool threads).

Details on the above three handlers and why you need them can be found in this MSDN article.

Alrighty, armed with that knowledge I implemented the three handlers and fixed the DataSet code. Things didn’t feel right tho. I was pretty certain that even if code running on a thread in the thread pool threw an exception, at least the Visual Studio debugger would notify me of the exception. So I decided to test the unhandled exceptions handlers by manually throwing an exception in the ReceiveCompleted event handler. I debugged the application and ….. nothing happened. The application just continued to run, no notification of an exception from the debugger or the application. The only thing that told me that something was wrong is that my model objects were not getting updated.

I had run into a brick wall on the road to exception handling nirvana. I was dismayed by this news and all hope was lost, until I found this blog entry. What particularly interested me is this quote:

if the unhandled exception [ occurs in ] a thread that began its life in unmanaged code, the CLR eats the exception and allows your app to keep going

Ahhhh the MSMQ ReceiveCompleted event handler is probably being called from a thread created by MSMQ unmanaged code. That is probably the reason why the three unhandled exception handlers were not called.

So as far as I can tell there is no way to handle all unhandled exceptions in a .NET application that interact with unmanaged code with threads. So the lesson learned is that you should identify the spots in your code where the underlying thread could come from unmanaged code and pay particular attention to exception handling within that code.

Note that .NET Framework 2.0 is supposed to address this problem by not swallowing the exception from background and worker pool threads. Stay tuned as I test these changes, and most importantly see if they addressed the issue of swallowing exceptions from threads created from unmanaged code. Hopefully the road will be straighter and have less walls.

Run the following from the command prompt:
C:\Inetpub\AdminScripts>adsutil.vbs create_vserv W3SVC/2
C:\Inetpub\AdminScripts>adsutil.vbs copy W3SVC/1 W3SVC/2

Now you will want to go in the IIS snapin and rename the newly created site, and set the Home Directory. That’s it! The only problem is that you can only run one site at a time, so you must go into the IIS MMC snapin to stop the site(s) you don’t want running and start the site your are currently developing and testing.

More details and inspiration for this entry came from Steven Cohn’s blog here. I ran across it while banging my head against the wall trying to find out how to create a site on my Windows XP box.