Twitter has inspired lots of people to create clients for it, not just on Mac, but on Windows as well.. It’s a very busy field. Let’s take a look at some of them.

Twitter Apollo Application (Windows and Mac)

Twitter Camp Apollo Application (also Windows and Mac)

Twitteroo (Windows Application)

WPF Twitter (Windows, the name says it all)

TriQQr (Windows App – Not WPF)

Twessenger (Windows Live Messenger)

TwitBox (not wpf)

Whooo! are you Tired yet? There are quite a few left but I decided that I think I will stop here. If you are looking for more of them I’d check out lockergnome’s list of over 76 twitter apps.

Just looking at these you can see just about the same feature (the public timeline) all implemented using different UI standards.. When I started my blend tutorial I wondered if anyone was working on this stuff. I see now, that there is a virtual army out there. I hope you found the tutorial how-to I provided some insight into working with web api’s (an obviously popular thing today). 

Anyway, the design decisions are kinda interesting to review. What do you guys think?

Here’s another great utility. If you have seen the Seattle Post-Intelligencer, or the New York Times Reader you know that they are WPF based and they use something people are referring to as the “reader SDK”. Xaml offers you great formatting and control over content. The tags it uses to control these things are very similar to HTML, but not really the same thing. So if you have HTML content you want to use in the XAML, you’d need to convert it to the XAML markup tags.

Well the folks at the WPFSDK have came to the rescue with a conversion utility.

You should really check this out as it’s a very useful tool.

Today I noticed yet another entry to the web, when I was reading someone’s ridiculous posting claiming Microsoft was dead. The only real revelation I came to is the person realized that he probably could do all his computing needs without a Microsoft product on his machine. This is something I have known for years, but apparently it’s new news to those who haven’t used other operating systems.

Anyway part of the document said that even Photoshop could be done on the web and they provided a link. Well I kinda baulked at that and went to the link anyway.

Okay well Adobe you are safe, it’s not Photoshop by a long way. Snipshot is a very nice tool for basic image editing including cropping, format conversion, and basic image processing stuff (the kind of thing you can do with free applications like Photoshop Album).

Snipshot Features:

Gavin Gear has just wrote a small tool that will save an inordinate amount of time. If you do WPF/E development you know that WPF/E is a control that gets embedded on the page that can be scripted thru javascript. You can pass new xaml code in through javascript to the WPF/E control for rendering by the control using the

CreateFromXAML()

Well getting that XAML code in a format javascript will pass to the control can be a royal pain especially if you have a lot of it. Well not anymore! Thanks to Gavin Gear we now have a tool that formats the XAML into parsable javascript to pass the XAML into the control in a scripted way..

This is quite a nice little tool and I wish microsoft would include it in the WPF/E SDK as it’s a real time saver..

Check it out at Gavin’s Blog  for more details or

download it

Okay stop what you are doing, run over to the ADOguy’s Blog and download his WPF/E Template for Expression Blend.. You will be glad you did..

WPF/E Item Template for Expression Blend

Recently on another blog I publish about Microsoft adding Expression Blend and Expression Web to MSDN. I reluctantly said I thought it was a good idea Microsoft is providing their designer tools to developers.. The developer community should understand and be able to use the toolset. Why is it a good idea?  Mainly to improve windows platform applications and to make them competitive with Adobe Apollo and MacOS X applications they will have to embrace design. That means (in a lot of cases) throwing out old design methodologies and  specifically their Winforms applications.

When I tell a developer he shouldn’t be the “designer” I get mixed signals.. That’s because everyone believes they are an “artist” and yeah just because your UI doesn’t suck, doesn’t make you a designer.. 

Anyway, here is my response to this guy’s comments. I think I raise some good points about this..

“… I actually agree with you, the developers need to start embracing design too. Giving them the tools is a very good idea to start the process moving.

When you mention: “Most of our dev shops don’t have or will not budget for designers, so I hope MS is planning a lot of dev ed. ”

You make a very good point in that they don’t embrace designers, and they should and one of the things the developer shops will need to do is start making room for the designers and hire them and pay them. That’s a sad fact of life, most Windows programmers don’t understand the same principles of design that someone who is educated in “design” does. It also makes most ”Windows Designers” starving artists. Development teams for Windows now need to add two new positions to their team and need to learn to work with them. Those two positions being a ”designer” and a “design integration specialist”. Programmers in general do not make good designers because it’s a totally different methodology of thinking. 

The “design integration developer” (also sometimes known as the interaction designer) takes the design and wires it up to the developers functionality. This role is very important because the integrity of the design must be carried over.  In Windows design this rarely happens today due to how restrictive Winforms really is for user interface design. With WPF this could change. Either way as a team hiring manager you really need to be thinking about hiring a Designer and a Design Integration Specialist from the start.

Art folk (designers) don’t even think like programmers (in general) and it’s a very different mindset and you can’t usually get there from here. In my over 20 years I have only seen a very few people (less than 10) who could do both well. Programmers think of logic and code. Artists think about the asthetic. 

That’s been the problem all along with Windows applications, there hasn’t been room for the designer, but if you look at Adobe and Apple this isn’t the case at all. Their products looks and works so much better because they thought about design first and foremost and programmed around the designer’s work.

Microsoft needs to hammer this point home to their developers. My suspect feeling is about two years from now when all the developers who are trying to be designers release applications that look and work like randsom notes (remember when typefaces/fonts were new on the mac?). After many failed attempts and programmers keep releasing WinForm Apps instead of WPF and their sales decrease, then the development houses will see the need for the designer and start embracing them and hiring them.

That’s why  right now the people best poised to take advantage of creating new Windows applications with WPF are the design firms (like IdentityMine, Thirteen23.com, and others) because they know this.. Most of them have been developing on the Mac and other design platforms (such as Adobe) where they know design comes first.

Sure I am not saying knowing a little WPF won’t help you look better with your apps. Microsoft has raised the bar. But designs for applications like you see on the pages of these design firms is a completely different process than you go through for design, interaction and UI design.

You will have to go through and learn that process, and if you don’t have the “designer mindset” you won’t be as successful and your application will suffer. I am really hoping that Microsoft starts seeing that a good MSDN coding demo isn’t the same kinda of presentation that is needed for the design community to embrace the product. See this article if you think it is:

http://synapticburn.com/comments.php?id=233_0_1_0_C

The same goes for a developer trying to be a designer.. It’s all about focus… You really can do one or the other, and developers probably should open themselves to a designer deciding what your app should look and work like. That’s what happens with the very successful development houses on other platforms like the Mac. Most Adobe developers are designers to start with and Apollo is aimed at the design community by default. Most programmers I know program because they like the idea of control and crafting the whole application themselves and probably will be resistant to the change. 

Why is this change important though? Because it really will affect the overall successfulness of the Windows Platform as a whole. Embracing change isn’t easy, but with new platforms such as Apollo where the designer can generate a very full featured application that runs cross-platform (which means the same app right now runs on the Mac and Windows), we will start seeing less and less (real) Windows platform applications as the lines start to blur and robust-ness starts equalizing more.

Remember the old saying “Change or Die..” we really are there with this, and a lot of folks aren’t seeing this yet..

Expression Blend has some really cool features that expose a lot of web functionality. Today I will start a tutorial about how to create a WPF application  I have been using a service called “Twitter” one of my friends called it the greatest internet “stalking” program in the world. Sometimes your friends or associates need to know what you are up to and what’s going on. Twitter works from your instant messenger or your phone.  One of the nice things about twitter is it offers both a public and private log. People only know what you tell them about what you are doing, and you can have private info available to others that you specify.  It’s great around work or even if you have friends that want to see what you are up to and find yourself too busy to talk to on the phone.

Anyway let’s dive in.. For this first tutorial you will need just Microsoft Blend, no visual studio required. So lets dive in, open blend and create a project in C# or VB.net.. Right now since we won’t be doing any code-behind pages or any customization you won’t really need it. We will just be focusing on the XAML and XML.

Step 1: create a new project

A little background on the twitter web service which we will be connecting to and pulling information. It is a webservice based on a very old and simple API called REST. REST is a very common web service API, it’s used by Amazon, Google, and a number of webservice providers, it sends data out in standard XML, JSON, RSS and ATOM formats. Microsoft was really great with their databinding inside blend and you can literally attach an XML data source from the webservice and instantly do one way or two way data binding to the application. Binding allows you to pull data from the web service or push it back to it if you have permissions of course.

Step 2: create an XML datasource

In the Data area in the lower right corner of the blend screen click on the +XML button

Step 3: in the datasource dialog type the following:

If you are having problems reading it, type what you see below:

http://twitter.com/statuses/public_timeline.rss

Step 4:  Make sure your schema useage is set correctly (click on the down arrow before the okay in the dialog box) make sure it’s set to infer schema from XML Data, there are other options here including setting up an XPATH but we’ll cover those in a later tutorial.

Step 5: Click Okay on the dialog

Now you have just created your XML datasource, and if you look down in the right corner you will see the fields and the datasource ready to databind..

Note: it polled the datasource and apparently came to us as an RSS formatted feed..

The next step is filling in the application with data and binding..

Step 6: drill down to the item (Array) line and then click and drag and drop that on the blend design surface..

Step 7: A menu item will pop up when you drop onto the surface you will then get an opportunity to select the type of WPF control you will bind to. Since this is a list of data I am going to select “LISTBOX”.

Step 8: Next a list box will pop up with ITEMSOURCE selected, and it will ask the type of databinding (one way, two way, etc.) leave it at default for this tutorial.. For now just click OK.

Step 9: Next another dialog will pop up asking you about how the data should look when inserted in the ListBox..

Note under item there are a number of drop downs, it allows you to bind the fields from the feed into different types of XAML controls. For now Item being a stackpanel is fine and the fields: Title, Description, pubDate, guid, link all can be just a TextBlock which is the standard text control.

Click OK

Step 10:  The design surface now has a list box with some sample data polled from the source, and you are done, you have just pulled data from the webservice.

Step 11: To test this works now go up to the project menu and select test project

Step 12:  your application now compiles and runs and bam you have a feed from Twitter, it’s their unauthenticated feed public timeline

You will notice that it might not be very useful but it is a working example of how to access the twitter API.. If we wanted to check out  what your friends were doing from a certain timeframe (say since tuesday march 27, 2007)  you could just go back up to step 3:

Where it says URL for XML data type the following instead:

http://twitter.com/statuses/friends_timeline.rss?since=Tue%2C+27+Mar+2007+22%3A55%3A48+GMT

The twitter API is very open you can specify just one person (if you want to spy on them) or a number of people. We will work on this during the next tutorial session. If you want to learn more about the Twitter API in the meantime you can check out the API documentation at:

http://groups.google.com/group/twitter-development-talk/web/api-documentation

They have more examples about how to poll the web service.  All of this without even entering Visual Studio for anything pretty neat huh?

If you want to see the code generated (it’s pure XAML) see below:

Code Sample 1.

<Window
 xmlns=”http://schemas.microsoft.com/winfx/2006/xaml/presentation“
 xmlns:x=”http://schemas.microsoft.com/winfx/2006/xaml“
 x:Class=”TWITTER_APP.Window1″
 x:Name=”Window”
 Title=”Window1″
 Width=”640″ Height=”480″ xmlns:d=”http://schemas.microsoft.com/expression/blend/2006” xmlns:mc=”http://schemas.openxmlformats.org/markup-compatibility/2006” mc:Ignorable=”d”>

 <Window.Resources>
  <XmlDataProvider x:Key=”rssDS” d:IsDataSource=”True” Source=”http://twitter.com/statuses/public_timeline.rss”/>
  <DataTemplate x:Key=”itemTemplate”>
   <StackPanel>
    <TextBlock Text=”{Binding Mode=OneWay, XPath=title}”/>
    <TextBlock Text=”{Binding Mode=OneWay, XPath=description}”/>
    <TextBlock Text=”{Binding Mode=OneWay, XPath=pubDate}”/>
    <TextBlock Text=”{Binding Mode=OneWay, XPath=guid}”/>
    <TextBlock Text=”{Binding Mode=OneWay, XPath=link}”/>
   </StackPanel>
  </DataTemplate>
 </Window.Resources>

 <Grid x:Name=”LayoutRoot”>
  <ListBox Margin=”115,59,67,73″ ItemTemplate=”{DynamicResource itemTemplate}” ItemsSource=”{Binding Mode=Default, Source={StaticResource rssDS}, XPath=/rss/channel/item}”/>
 </Grid>
</Window>

If you talk to a designer you’ll hear many takes on design, everyone has a unique approach to the subject. That’s why you get diversity. If you talk to a programmer about programming you will get a significantly less diverse answer. Well he might talk to you about open source or closed source, he might talk to you about programming in a language (pick any of the 4-5 popular ones out there). However the likelyhood of talking to another programmer and not getting a bit of the same “content” mentioned in the conversation will be less likely.

I have been reading different people’s views on design tools and what they are. I hear a lot of things from both sides of the isle, one such polar opposite view from mine is from a guy named “Dave” who seems to be in the UK.. While his views are quite a bit different than mine, I still feel he does make some valid points from people of a certain point of view of a designer with no windows development experience.

My design experience comes from years of work and windows application design, including working for a company where they were scripting storybook screens with lots of little clickable hotspot animations and games and singing “M-I-C.. K-E-Y” or something like that all the time.. So I admit I am very subjective about this stuff oh since probably 1994..

While I was with this company I learned a lot about how people interact with computers including those from three years old to sixty years old.  It “instilled” upon me just how very important the user experience is. So things like click-throughs and making things as easy to navigate as possible, I find not negotiable.

One of the things I have always thought needing changed about Flash was that it was more timeline oriented than event based, and there was no way to describe all the elements of the screen and see them because of the dependence on timelines. Flex and Flash 9 adds a screen description system,  but until lately Flash was very much looked at as a timeline based system.. Events vs Timelines has always been a struggle for the interactive developer. I believe that WPF and Blend correctly makes events and triggers and timelines have the appropriate heirarchy.

When I started diving into Windows development this “screen description language” was still missing, but in it’s place was Winforms.  It was component based but at least it let you assemble a UI out of components that were layed out visually. It didn’t offer much in the way of the things I wanted to improve about how people use the applications developed for it. It was the winforms way or the highway until XAML and WPF came along.   On Windows development has always been about “events”.

When Microsoft started looking at what the next version of Windows UI would have to be like to be competitive with everyone else and they realized they could have a UI that was more open and flexible to move the platform forward.

Microsoft wasn’t out to clone some other platform they wanted to improve everyday Windows application development. They wanted to make them more internet aware, give them all the UI coolness that has been attracting people to other platforms like Flash, and of course the cool Apple style user interfaces but focused on not some generic extensions but how they could improve the standard windows UI.

Did they do this? Mission accomplished (in my opinion)..

The quality of the applications that have been showing up as proof of concept are attracting many people to writing new Windows applications however mostly people not familiar with the programming model behind Windows. Such as that is, WPF applications still have to be written like a Windows application. How difficult is that?  Well there is still a bit of a learning curve over writing a web site application in something like ASP.NET.

In a data driven website you usually have these minimum steps,

1. Create the database
2. Design the Web Interface
3. Connect to the database and wire up the pages (databinding with a connection string)
4. Start testing

When creating a WPF Application the process is different

Designer:

1. Creates the UI design in your graphics design program
2. Export Graphics to blend
3. Create custom screen elements interactivity and components and style
4. pass the completed UI to the developer

Developer:

1. Take the UI project
2. Create/Connect to the database
3. Create your datalayer
   1. Create custom classes for your datalayer so you can represent Datasets and Tables as objects.
4. Create business rules layer
   1. Connect busines rules to your datalayer classes
   2. code your application functionality
5. Wire up the UI and DataBinding to your presentation layer
6. Start testing

Where does Microsoft have a lot of work to do with WPF?  Well mainly with developer education as they try to make Windows application development more friendly.

WPF was not designed to make Flash, Flex or Apollo runtime apps, it was designed to make Windows application development more friendly.  Do they deliver on this? The best person to ask this of is a Windows application developer.

So where in this process will for instance a web developer trying to be a WPF developer go wrong?

Well lets see, if you are a web developer you might be asking yourself, well I know how to use a connection string and connect a web page to a database and databind, unless you are using the XML connectivity in Blend you might ask “where do I wire up my SQL database?”

The answer is the CLR object data source…

You can find a great tutorial in the Blend RC help system under “Home > Data > Create a CLR Object datasource”.

You might say what’s this? It’s unfamiliar to me, I usually just connect to a datasource through a data connection string and databind right to the onpage controls.

In Windows development there are multiple ways to access data sources and code them for efficiency. In a normal Windows application people create multiple  layers of code. One is a data layer, the other is a business rules layer, and a presentation layer.. The usual method is an ADO.NET datasource which talks to the datalayer. In a web application most people just talk to the database directly over ADO.

In an effort to improve efficiency of data access ,Windows applications usually have a layer of code that does all the talking for it. This is the DAL (Data Access Layer). Microsoft has been watching the fact that people are talking to data from other things than a SQL database lately and decided to support more than just that, so we now can do that one layer of abstraction higher with the object datasource. This lets the datalayer efficiently handle data easier and you don’t have to think about anything but the data as objects itself.

So how do you do it then? You create object ”classes” that represetn the datatables and datasets as objects you call and work with instead of working with the database directly.

So you worried yet? This isn’t as hard as it sounds. Visual Studio gives you the tools to easily auto generate these classes (XSD, Schemas and others). I was able to do this in about 30 minutes and it’s very easy using the tutorial in blend.

Then after you are done with that (you just created your data layer) then you can use Expression Blend’s CLR object data source. You just reference the layer you have just created and then start binding your data right to your application.

Microsoft has made data connectivity very easy with Blend, but you do have to understand the layers of code in an Application and a little about programming and making “classes”.. I agree it’s not as easy as drag and drop or a timeline, but the tools make it very fast and not that bad and you don’t have to be a geek who knows much about constructors and delegates etc..

Yes, it’s a little different but actually quite easy and most developers will clue in quite quickly. Designers however will just have to do a little bit more to understand the design process but not very much.

I actually like the CLR object datasource because it means that at the level of implementation data can come from more diverse sources other than ADO.NET and it’s as easy to use as the XML datasource as well.

Is this a 5 year step backwards? Well I don’t think so. I would just say BLEND is not Flash and neither is WPF, and never was intended to be.  So stop making the comparison, and if you know of other people that are, well get them to stop too. It’s doing the whole platform comparison a disservice. If you understand Windows development it’s a big leap forward and a makes Windows development a lot easier and of course way more powerful.

Will you want to use WPF instead of Flash or Apollo? If you are doing fullblown Windows application development it’s definitely the way to go.  Otherwise, If you don’t mind a different approach and a different toolset you’ll find that you are very productive at creating Windows applications than ever before in history with these new tools. The applications you can make can have the feature richness you are used to in a real application, not just an RIA.

Anyway, I’d say just because something’s a little different don’t stop, or get lost. Keep at it slowly and you’ll get there quicker than you expect and be able to have a bigger arsenal under your belt than ever before.

I would also say click events in XAML and C# or VB.Net aren’t difficult, they work just like button events have always worked. I don’t see Blend as full blown development environment so things like this (which requires Visual Studio integration). People who don’t understand the event model which is again that of a Windows application, not an event on a timeline will make you very productive very quickly.

I would just say anyone who is a “true designer” should probably investigate a few things about Windows development before diving into Blend.  You should at least understand the concept of a Business Rules Layer, a Data Access Layer, and the Windows Event Model. Then you won’t feel so lost or overwhelmed and you’ll find yourself more productive.

I don’t think it’s true that Microsoft just sees Flash as “gaming and animation” environment, I think they see it as a path to robust windows applications that are on par with everyone else and will see Windows developers not as easily “migrating” to other platforms when they can produce the same amount of sizzle with something they already know and understand.

I do agree that Apollo ups the anti, but doesn’t have the depth yet of the Windows api’s for flexibility due to it’s need to be using features in it’s framework. WPF 3D is just one example of stuff missing. 

When you go to a system that has an event model, objects needing referenced and mapped there is a certain amount of pain in learning all of that, but it’s actually no different than the flash/actionscript people who will need to learn Flex 2 which they will have to move to for effective Apollo development and using an IDE similar to Visual Studio (okay in a generic sense, very generic) in Eclipse..

I also believe that for web browser applications Expression Web leaves Dreamweaver far behind in a cloud of dust and legacy plug-in features which people don’t use anymore..

Also I beg the question, if you weren’t creating a Windows WPF application where would you find a use for WPF anyway?

WPF and WPF/E are very different animals talking to different layers and handling things very different from each other..

Just when you thought it was safe to come out of the water, Microsoft has relented and given Expression out to MSDN subscribers. Personally I was hoping the product would stay within the design community but I understand Microsoft’s need for it’s development community to understand the products better and embrace them as part of their workflow environment. It will enhance Microsoft’s acceptance of these tools.

This reminds me of the days when Microsoft had “SiteBuilders” and special tools for web designers, later we were forced to meld with MSDN..We were all disappointed when those little site builder level logos ended up meaning nothing after we had to earn them.  

I really hope this all doesn’t mean that Microsoft is giving up on keeping their  “Design Division” a separate entity because the changes we have seen signal a very different path for Microsoft that everyone has been very approving of. I hope this doesn’t signal a return to “past” ways of working.

Either way this is a good deal for developers, though I for one think they should have had to pay for these just like the designers who don’t code do as well. I know that’s not very friendly of me, but I think Expression Studio means long term enhanced revenue for Microsoft and I think MSDN folks should have to pay for these tools just as they would if they bought the Adobe Studio product. I would also note that Expression Design wasn’t announced as part of the MSDN bundling.

If you want to read the official announcement it can be found at..

Expression comes to MSDN

Well for the past two years I have been watching a new operating system grow out of the reminants of the Amiga community. Today for the first time I was able to make a new pc out of scrap hardware from a number of older systems I own and make a working machine out of it. I could have easily installed a Microsoft operating system on it, and who knows maybe in the future I will, but I do like keeping an eye on other systems.

AROS runs on very cheap generic x86 hardware. I took a CPU that was about 3 years old added an Nvidia FX graphics card and downloaded the ISO, and boom in about 5 minutes I had the hard drive partitioned and was staring at a very high resolution screen and UI that looked a lot like Old AmigaDOS 3.x/Workbench3.x but higher resolutions and all those enhancements I have missed starting with MUI (the magic user interface).

What’s new with AROS over the last few months? Well USB 1.1 support is one thing, a networking stack based on AmiTCP is another along with support for ethernet cards and wireless.

Aros has grown significantly and is seeing much development in Europe. I have been wondering when this OS  will become a watershed, and it looks like we are approaching this very quickly.

There were many fans of the original Commodore-Amiga platform because of it’s multi-tasking, multimedia features and OS design. AROS brings  a lot of the original OS design concepts that made the operating system popular. For many years with the original architecture you could just here people ask the question, “So why use it?” and the answer was it just works better.

AROS will probably never become my “ONLY OPERATING SYSTEM” but it sure brings back a lot of the things I liked about the first computer I ever loved.  Some people are closet Linux and BEOS users, I am a closet AROS.  I like it because it’s really great technology created by people and for people and community driven and created and it’s fun. When I do stuff outside of work I like it to be very different than work and AROS fits that bill for me. It’s a great hobby OS and maybe someday could be a lot more.