I saw recently that a buddy had celebrated his fifth year of blogging. Very cool but it made me, of course, start to wonder when I started blogging. Now, so much depends on what you mean by blogging. Because blogs didn’t come out of nowhere, they evolved out of prior technologies. For example, before I had a blog I had a threaded discussion that was part blog, part comments and part conversation.
Yet Another Podcast–Bill Wagner
Effective C# and much more with Bill Wagner
- Bill is a Microsoft Regional Director and the author of both Effective C# and More
Effective C#. - Links discussed include:
- Chris Marinos’ MSDN article
- Rich Minerich’s Blog
- Dianne Marsh on the history of CodeMash
Listen | Return to Yet Another Podcast
Call in comments: 1-347-YAP-CAST
Reactive Extensions–Observable Sequences are First Class Objects
Windows Phone From Scratch #28
In yesterdays’ posting on Asynchronous programming with Reactive Extensions I created a browser application that reacted to user input into a TextBox.
You will remember that the observable was created from the TextChanged event as demonstrated in the following bit of code (the throttle was used to avoid picking up any changes in the text until the user paused in entering new text),
var keys = Observable.FromEvent<KeyEventArgs>( search, "KeyUp" ) .Throttle( TimeSpan.FromSeconds( .5 ) );
Then we subscribed to the observable collection and had to reach into the text box to obtain the changed text:
keys.ObserveOn( Deployment.Current.Dispatcher ).
Subscribe( evt =>
{
txtSearching.Text =
"Searching for... " + search.Text;
txtLoading.Visibility =
System.Windows.Visibility.Visible;
webBrowser1.Navigate( new Uri(
"http://en.wikipedia.org/wiki/" + search.Text ) );
} );
This is fine as far as it goes, but we can go further. Because observable sequences are first class objects we can provide operators over them using generic extension methods; which is exactly what was done by the creators of the Rx framework.
Rx–Reactive Programming for Windows Phone
Windows Phone From Scratch #27
My first posting about Reactive Programming for Windows Phone generated 
some terrific comments… many of which asked (and others answered) “what is the benefit of this?”
In this second posting on the topic I’ll tackle a bit of asynchronous programming that may help to illustrate how the implementation of the observer pattern by the Reactive Programming framework can greatly simplify Windows Phone programming.
Posted in Data, Mini-Tutorial, Patterns & Skills, Reactive, WindowsPhone
Tagged Mini-Tutorial
5 Comments
Stop What You Are Doing And Learn About Reactive Programming
Windows Phone From Scratch #26
I’m increasingly convinced that Reactive Programming is going to be critical for Silverlight and Windows Phone developers. Reactive Programming is not new, and the Rx toolkit has been out for a while, but this is not a heavily covered topic, and the more I look the more I think it should must be.
In short, Reactive Programming is a way to take aspects of your code that are currently imperative and turn them into something much more event-driven. In fact, Reactive Programming is sometimes referred to as LINQ Over Events.
This is tremendously helpful with asynchronous programming, but also with managing routine programming as well.
Posted in Patterns & Skills
23 Comments
Linq and Fluent Programming
A LINQ Tutorial
I interviewed Bill Wagner for Yet Another Podcast while we were both at CodeMash 
(look for his interview to be published next week). In addition to being one of the nicest guys I know, he is also one of the smartest.
During the conversation he illustrated the ideas behind Linq and Fluent programming with a verbal example. With his permission, I’ve picked up that example and present it here as a crisp crystallization of these key programming concepts.
Using the Camera in Windows Phone 7
Windows Phone From Scratch #24
On January 24 we created an application that launched the contact list and returned 
the phone number of the selected contact. In that posting I reviewed, briefly, the difference between Launchers and Choosers. This posting builds on that work.
Today we will use the Chooser for the Camera, which will bring up the camera and then return the location of the image taken.
Launchers & Choosers–Part 2
Windows Phone From Scratch #23
In yesterday’s posting we created an application that used a chooser to allow you to pick a name from the contacts list and to obtain the related phone number.
Today we’ll use that information to launch the SMS service to send a message to the selected user.
Tasks: Launchers and Choosers–Windows Phone From Scratch #22
To provide your Windows Phone application access to the operating system (and with 
it, to the native applications such as SMS, the Contact List, the Camera, and, oh yes, making a call) Windows Phone 7 has a set of predefined Tasks.
Tasks can be divided into two types: Launchers, which launch an application but do not return a value (e.g., sending a SMS message) and Choosers, which launch an application and do return a value (e.g., fetching a phone number).
Yet Another Podcast #21–Jeremy Miller
IOC Containers, .NET, Alt.NET and much more with Jeremy Miller
Jeremy is the Chief Software Architect at Dovetail Software, the coolest ISV in Austin. 
Jeremy began his IT career writing "Shadow IT" applications to automate his engineering documentation, then wandered into software development because it looked like more fun.
Jeremy is the author of the open source StructureMap tool for Dependency Injection with .Net, StoryTeller for supercharged acceptance testing in .Net, and one of the principal developers behind FubuMVC. Jeremy’s thoughts on all things software can be found at The Shade Tree Developer.
- Listen | Return to Yet Another Podcast
Call in comments: 1-347-YAP-CAST
Personal Brain: Quick Tip
Personal Brain has an extraordinary feature called ESP. Depending on how you set it up (I have it set to monitor the clipboard and to automatically bring up a thought), it watches everything you type, in any Windows application, and as you type if it recognizes the word you just typed it jumps to the relevant entry.
This can be amazingly powerful; I have only to type Full Stack and up comes that though with all its related thoughts.
I’ve collapsed the related thoughts and cropped the image to make it fit here.
Posted in Patterns & Skills
1 Comment
Oops! Our OData Was Read Only. Yikes!
Jon Galloway and I recently documented what we were learning about Entity Framework Code-First and oData as part of the Full Stack project. It turns out, however, that we were into some bleeding edge technology, and while everything we posted works, it works read-only, as written it is not possible to update the data. Not great.
With the guidance of Chris “Woody” Woodruff we stopped using batch updating and we opened up our error messages to see more detail. This led Jon to an article by Rowan Miller which targeted exactly the problem we were having. Jon documents it all here.
Key was that we were using DbContext, which is a wonderfully lightweight convention-over-configuration based wrapper over ObjectContext, but one of its limitations is that it does not does not include IUpdatable support, as documented here.