The Faces of Twitter

Posted April 14, 2007 by donburnett
Categories: Uncategorized

by Don Burnett

 

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?

HTML to XAML Flow Document (yet another GEM)

Posted April 13, 2007 by donburnett
Categories: Uncategorized

by Don Burnett

 

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.

Snipshot to the Rescue!

Posted April 12, 2007 by donburnett
Categories: Uncategorized

by Don Burnett

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:

  •  Firefox extension to put Snipshot in your right-click menu
  • free API lets you use Snipshot for your own website
  • No download necessary—100% browser based, no plug-ins required
  • One-click import from any web site (including Flickr) with our bookmarklet
  • Save to a free permanent URL at WebShots or to your Flickr account
  • Save as GIF, JPG, PDF, PNG or TIF
  • One-click enhance improves most images
  • Basic editing tools like crop, rotate, resize
  • Basic image adjustments like contrast, brightness, saturation, sharpness and hue
  • Unlimited undo and redo (Ctrl+Z and Ctrl+Y, or ⌘Z and ⌘Y on your Mac)
  • Nondestructive editing—we always work from the original
  • Edit big pictures—up to 10 MB, or 25 megapixels (5000×5000 pixels)
  • Import PDF (first page only), EPS or SVG

    The best feature may be the product’s API.. I am looking at it right now to see if I can incorporate it into my own website and hopefully WPF/E application. It seems simple and easy so far. 

    With Snipshot people can do things like upload photos to company websites and make the pictures look better without opening an image editing tool and they don’t have to be familiar with image editing and that’s really cool.

  • WPF/E Javascript Gem

    Posted April 12, 2007 by donburnett
    Categories: Uncategorized

    by Don Burnett

     

    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

    WPF/E Users… Stop what you are doing…

    Posted April 9, 2007 by donburnett
    Categories: Uncategorized

    by Don Burnett

    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

    Programmers aren’t Designers but it doesn’t mean you shouldn’t try!

    Posted April 8, 2007 by donburnett
    Categories: Uncategorized

    by Don Burnett

    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..

    Twittering Around in Expression Blend Part 1

    Posted April 7, 2007 by donburnett
    Categories: Uncategorized

    by Donald Burnett

    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>


    Follow

    Get every new post delivered to your Inbox.