WPF-Blogger.com [Complete Feed]

Listbox, Why Art Thou Blanking?

Windows Phone Dev Blog — 2012-05-17T02:53:58

One of the biggest performance changes for developers using Silverlight in Mango (WP 7.5) is off-thread input for ListBox. In a nutshell this basically means that all any flick or pan a user makes on a ListBox is handled by a dedicated thread, the Direct Manipulation (DM) thread, instead of the UI thread. By connecting the DM thread to the Compositor thread (that’s the one that does all the drawing to the screen independent of the UI thread) we have a ListBox that moves smoothly even when the UI thread is completely blocked.

Unfortunately this also comes with a price – the ListBox is now so responsive and moves so fast that the Listbox can run out of content to display to the user as the user is flicking, and blank – basically drawing nothing except for an updated ScrollBar (so the user knows he’s still moving in the ListBox, but it doesn’t help much) and the background while the UI thread scrambles to bring in new items to fill up the holes.

My ListBox isn’t blanking, why do I care about this blog post?

You care because you care about your users. You’re the kind of dev who knows that even though he’s got a great, powerful phone, not everyone does. You care because you are proud to call yourself a developer. You care because… ok, back to reality.

With the release of Tango, Windows Phone is now supported on lower powered machines which often have slower hardware and less memory, so even though your device shows no blanking, others may see blanking, especially if they’re rocking a new, lower powered, Tango phone. This post will help give you the tools that let your app run smooth, with hardly any blanks, even on those phones.

My ListBox is not blanking, but it’s really jerky during scroll

Holy Smokes Batman! Jerky scrolling is all but eliminated in the new ListBox, even for WP7 apps – are you sure you’re using it? There’s a good chance you’re using the original LongListSelector (LLS) from the toolkit, which doesn’t auto-update when you move your project to Mango. To take full advantage of the new ListBox improvements you need to download the latest toolkit from http://silverlight.codeplex.com and update to the new LLS which is based on the platform’s ListBox.

Why does blanking occur: the nitty gritty

There are a couple of common code / design reasons that cause a ListBox to blank, but in general it all boils down to the amount of time it takes to bring in a new item. The ListBox maintains a one screen buffer of items in each direction which moves with the user’s viewport as they scroll around. If the ListBox can’t fill that buffer in the direction of the scroll fast enough, you get blanking.

Diagram 1: In a stationary world, when there is no scrolling going on, the user will be looking at the center screen and there will be buffered items waiting to be shown in both directions

Filling the buffer takes a few steps, namely creating an Item Container (if a suitable one from the excess buffer in the other direction doesn’t already exist) and Data Binding the new item’s content (which kicks off the Measure pass). All of these updates occur on the UI thread and they all happen at once (not item by item) so if a flick is fast and the ListBox realizes that it needs to draw a full screen worth’s of items it will block the UI thread while it does just that.

Diagram 2: As the user moves downwards we balance the buffers by transferring the excess buffer from the top buffer (red) to the bottom buffer and re-databind it to the new data, maintaining 1 screen of buffer in each direction.

But if the user flicks again while the UI thread is blocked bringing in buffer items, we’ll get even more out of sync and move completely out of our buffer space – since there is nothing in the Control to draw (remember, the ListBox is still scrambling on the UI thread to bring the new items in, it’s just too slow) you just get the background, i.e blankness.

If there’s nothing to draw, why is the ListBox still moving? Or, look at it from another angle:

As we mentioned earlier, scrolling is now off-thread, so from the Compositor’s point of view it’s moving the ListBox and everything in it, the problem is that the UI thread hasn’t stuck anything in it (at that position) yet, so we blank.

Diagram 3: Fast flicking a few times get you into this situation, where we have excess buffer above which we are trying to move downwards, but because there is so much of it and the UI thread is blocked trying to bring these items in we don’t finish in time and the user sees blankness (black) until the items are ready, at which time they simply appear.

So why is *my* ListBox blanking? And how do I fix it?

Let’s run through a couple of common reasons why ListBoxes blank, with some proposed solutions to each one.

1. Using ValueConverters in your template

ValueConverters are great – they allow you to transform your data on the fly as they are being DataBound into your items. Unfortunately they incur a UI thread cost – we need to transition from Silverlight into User Code, run your converter and then return. If your converter is heavy or you’re using lots of them in your template, then this will introduce blanking.

Question to ask yourself: does this code look like it can run in a trivial amount of time across all of the elements being brought in for a given frame? If not, you probably should explore a different way of doing the DataBinding. For example,you can have the object translate the values on population / property get time instead of using a converter - even though this may break your Data Model this can significantly reduce the DataBinding cost (and you could always wrap your object in a ViewModel).

2. Complex DataTemplates

When an item is moved from one buffer to another during a scroll, ListBox is usually smart enough to determine that this is the same kind of item and just update the data in the item. While this might sound cheap this dirties the item causing it to be remeasured. If your template is complex you will find that a lot of your time is wasted in Measure – remeasuring the layout of the control now that the data has been updated.

Fixing this is very per-scenario. Some general guidelines are to make sure to only use a container if you really need the options it provides – do you have a Grid within a Grid? Could you replace all of your Grids with a simple Canvas or maybe a StackPanel?

3. Decoding images on the UI thread

By default all images are decoded synchronously on the UI thread, so if you have something like this:

you're going to block the UI thread for however long it takes to decode your image. Luckily there’s an easy fix for this, change your template to read as follows:

Note that this does come with some caveats – older images will still show up until the new ones are loaded and the user may see a visual pop-in of the image when it is done loading, but these can all be worked around and massaged into a nice user experience that is not harmed by excessive image decode.

For further details see this blog post.

4. Using PrepareItemForContainerOverride to dynamically select a template

A simple list item is often times just not good enough – your app has an image item, a text item, a video item, a link item etc. etc. and you have a different template for each one of them. A common pattern is to use the ListBox’s PrepareItemForContainerOverride callback to dynamically change the container’s template based on what item is being databound.

Unfortunately, doing this can completely throw off the ListBox’s buffering technique – the ListBox sees that the container that it had in its buffer is not the type that you need and junks it, wasting even more time on the march to blankness.

So how do I solve this? Surprisingly enough, it is often cheaper to have all of your template parts in one large template (yes, yes, I know about point 2 above – keep reading!) with each mini-template collapsed if it does not apply. Since collapsed template items incur next to no cost during layout, they have next to no impact on run time (though there is a slightly larger memory cost).

And how do I get my different items to display on the different templates? Simple – databind to a new property on your classes which either has a type enumeration that runs through a value converter (ItemTypeToVisibility), these kinds of converters are often cheap, or wrap your class in a UI view model so that it has a property that returns the Visibility type directly.

5. Pulling data from [favorite heavy source] as part of your binding

The properties you bind to should have simple getters (setters is a different story) – always. If you have logic like this:

public int Rating
{
get
{
    <read from database>
    - or -
    <read from IsoStore>
    - or -
    <parse out some XML>
    - etc -
}
}

then you’re doing something wrong. This kind of logic is fine for a property that you know is only read very rarely, if at all, but if it’s in a ListBox then it most likely is going to be seen and you should be initializing the data up front.

Don’t get me wrong – you don’t need to load everything as you are pulling in 1000 items to your list, but you can certainly do it on a background thread as a deferred task kicked off in the constructor of your object. If your objects are really heavy and memory is becoming an issue then you have a few possible routes:

Implement a completely delayed load by hooking into the ListBox’s scroll amount or compression states and only loading more items when you get to the end of the list
Implement a DoubleLinkedObservableCollection, where each item in the collection knows about the next node (in each direction) and when it gets databound (based on one of the properties) it notifies X number of nodes on each side to make sure they all have their data ready to go. This should be done on a background thread, just don’t forget to Dispatch back to update any properties that raise a PropertyChanged event.

6. Cut down background work

With only one core any background thread can interfere with the smoothness of the UI thread. Although background threads get a much smaller time slice compared to the UI thread, enough of them vying for time will effectively starve the UI thread.

Diagram 4: Fictional time slice showing the effects of more background threads (not to scale)

Across any given slice of time, the UI thread will be allowed to run longer than any other thread, but is effectively running at the same priority, hence it is forced to yield to the background threads when its time is up. The more background threads, the longer it is before you get back to the UI thread so that it can complete its task.

Moral of the story? Be wise about the number of active background, especially in high stress scenarios. Stick to using a thread pool so that you can queue up your work without it all trying to run at the same time.

I’ve tried all the above, it’s still blanking and I only have a couple of screens of data – help!

If you find yourself blanking on a relative small set of data (approximately 3-5 screens), then it might be time for drastic measures. As mentioned above the cause for blanking is the amount of time it takes to bring in new items with new data as the user is scrolling, i.e. the virtualization overhead is the culprit. If you disable virtualization on your list, you’ll generate of all your items up front and scrolling will be blankless. To do this, add the following to your XAML:

<ListBox.ItemsPanel>
  <ItemsPanelTemplate>
    <StackPanel>
    </StackPanel>
  </ItemsPanelTemplate>
</ListBox.ItemsPanel>

While making this change is relatively simple, the impact can be drastic – no more blanking, but it comes at a cost:

Startup time for the Page increases – we now have to realize more items, so it’s going to take longer
Memory – same as above, more items hanging around, larger memory cost

If you give it a try on a low end device and startup and memory look acceptable – then this is your magic bullet!

So what are we left with?

Hopefully at this point you have a non to minimally blanking list, which scrolls smoothly and generally delights your users! Have you run into any other pitfalls that you think others should be warned of? Let us know below!

Running into other, unrelated performance issues? Drop us a line and we'll see if we can focus on them in a future blog post (stay tuned for a "memory" series coming soon).

Programming Windows 6th Edition Preview Ebook Is Here!

Charles Petzold — 2012-05-17T15:53:34

The long-awaited 6th edition of Programming Windows is scheduled to be published by Microsoft Press in November 2012, but you can purchase the ebook direct from the O'Reilly website today:

... more ...

La “locura” de las optimizaciones en los juegos.

Juan María Laó Ramos — 2012-05-16T22:58:37

¿A quien no le preocupa que su código no sea óptimo? Eso de "funcionar funciona ... pero tarda mucho" no es escusa para no preocuparse por optimizar las partes optimizables. Una de las mejores formas de evitarse problemas desagradables cuando el sistema … Continue reading →

Primer camino para alcanzar el Nirvana del Garbage Colector

Juan María Laó Ramos — 2012-05-16T23:00:20

En este post vamos a ver una de las técnicas usadas para evitar que el recolector de basura se ejecute en mitad de la partida de un juego, teniendo como consecuencia una pérdida de rendimiento. Continue reading →

¿Veremos en The Windows Phone Developer Conference a WP Apollo?

Juan María Laó Ramos — 2012-05-14T01:00:23

Dentro de unos meses se cumplen dos años de la salida de Windows Phone 7 y un año de la de Mango. Como no deja de ser una ciencia, la estadística nos dice que en Octubre estará disponible Windows Phone … Continue reading →

MSDN Webcast series on building Metro style apps

Jaime Rodriguez [MS] — 2012-05-11T08:50:11

A few colleague evangelists are doing a series on MSDN Webcasts on building Windows 8 Metro style apps..
Catch the whole series and get a very concise, yet comprehensive introduction to building Metro style apps..
See below for abstracts and presenter for each session, click on the title for each session to visit the registration page for that session
Each session is one hour.

Monday May 14th, 2012 8:30 AM PST
Introduction to the Windows 8 platform and the Windows store
Jennifer Marsman
Windows 8 is Windows re-imagined! Join this session to learn about the new platform for building Metro-style applications. Get an understanding of the platform design tenets, the programming language choices, and the integration points with the operating system and across Metro-style apps. We will also discuss the enormous opportunity for developers to make crazy money with the Windows Store. You will walk away with the resources to begin writing Metro applications for Windows 8.

Wednesday, May 16th, 2012 8:30 AM PST
Designing apps with Metro style principles and the Windows personality
Chris Bernard
Metro style design has a set of five guiding principles to help you make the best choices when designing your app. These principles are the foundation for building great Metro style apps. Consider these principles as you plan your app, and always ensure your design and development choices live up to these principles.

Monday, May 21, 2012    8:30 AM PSTJohn WieseMonday, May 21, 2012    8:30 AM PST
Monday, May 21, 2012    8:30 AM PST
Building Metro style apps with XAML: What .NET developers need to know
John Wiese

If you are experienced with .NET or Silverlight and are already familiar with XAML, this session will teach you everything you need to know to create a Metro style app for Windows 8. This session will cover updates to familiar features and explore concepts that are new for Windows 8. We’ll talk about building reusable Windows Runtime Components in C#, Async programming in Windows 8 and both the Visual Studio and Expression designers. This session will show you how to turn your XAML skills into money-making Metro style apps.

Wednesday May 23, 2012 8:30 AM PST
What HTML developers need to know about coding Windows 8 Metro style apps
Michael Palermo
This session is perfect for any web developer wanting to leverage his/her skillset to develop Windows 8 Metro style apps. The session begins by proving how much web developers already know about building apps for Windows 8. The focus then turns to how to write JavaScript code with WinJS. Key points for Metro style app development will be highlighted by implementing popular feature requests using HTML5, CSS3, and JavaScript.

Thursday, May 31, 2012 8:30 AM PST
Win as One: How Contracts in Windows 8 Help You Build a Killer Metro App
G. Andrew Duthie
Contracts are agreements between Windows and your Metro style app that allow you to integrate Windows 8 features into your app. For example, Windows 8 lets users share content from one application to another by using the Share contract.

In this session, you'll learn how contracts work and how to implement the built-in contracts such as Search, Share, Settings, and More. With Contracts, you can help users get more out of your app, and in a way that is consistent and intuitive, and they will reward you by coming back to your app again and again.

Monday, June 4th, 2012 8:30 AM PST
Bring Your Windows 8 Metro Style Apps to Life with Tiles and Notifications
Chris Bowen

Tiles and Notifications are important ways to draw attention to your app and improve your users' experiences. Tiles can draw users back into your app when your tile comes to life on Start screen. They can also let users personalize their Start screen by creating deep links to specific places within your app. Notifications, delivered through the Windows Push Notification Service, can inform and draw your users back into your app even when it's not running.
In this session, you will learn how to effectively implement Tiles and Notifications to help your apps shine.

Wednesday, June 6th, 2012 8:30:00 AM PST
Building Windows 8 Metro style casual games using HTML 5
David Isbitski

The intent of this session is to help HTML5/JavaScript developers with writing their first Metro Style App in a fun, immersive way. We will cover the basics of HTML5 Canvas gaming and how we can easily bring it to Windows 8. We will then add additional game functionality as we introduce HTML5 Audio, CSS3 styling and web fonts, implementing a game loop with JavaScript, 3rd party frameworks, touch, camera, accelerometer, and WInJS controls.

I will be watching. I hope you join us.

Happy WIndows 8 coding!

Programming Windows 6th Edition Preview Ebook Coming!

Charles Petzold — 2012-05-10T18:40:13

If all goes according to plan, in one week, on May 17, 2012, you will be able to purchase a preview ebook of Programming Windows, 6th edition, for just $10. For that one-time payment of $10, you will also get the second preview ebook a couple months from now, and the final ebook later this fall.

... more ...

Memory Profiling - The Heap Summary View

Windows Phone Dev Blog — 2012-05-10T18:24:11

In an earlier post we looked at how we can gain broad insight into an application scenario’s memory characteristics and how the graph and markers drew our attention to ranges of execution for further analyses. Recall that in the memory leak diagnosis case we chose to analyze only the time range over which we observed the increase in memory usage. Indeed, that is a key first step to the analysis: filtering the memory activity data by a time range. The Heap Summary view is the result of such filtering, and represents the population of the heap during the chosen time range.

Heap Summary View

The Heap Summary view presents, in tabular form, a demographic analysis of the population of the heap.

In human population demographics, data collection happens through a census as well as through a continuous update to registries that track births, deaths, migration of place of residence and the like. The data collection in the case of heap population demographics is no different. “Births” map to allocations, “deaths” map to objects’ memory collected by the GC, and “migration of place of residence” maps to the migration of objects between the Gen0 region of the heap and the Gen1 region. A census of the heap at the start of time range identifies all incumbent objects (i.e. that were in existence). Births, deaths, and migrations are updated continuously, and a final census at the end of the time range identifies all the objects that were retained. In order to have a consistent terminology, we refer to the incumbent objects at the start as objects that were “retained” at the start.

Managed Silverlight Visual elements (i.e. objects that go into the Silverlight visual tree) are not just plain old managed objects. These might be facades with backing native-implementations holding native memory and during the course of execution might create and hold on to texture memory. Casual use of such elements in code can even lead to subtle leaks. From this perspective, subsequent analysis can be made easier if Silverlight Visual elements were tracked and reported separately from plain old managed objects. And this is precisely how they are tracked and reported through the Heap Summary view. Continuing with the demographic analogy, such classification has precedent in social demographics where human populations have been classified on ethnicity.

Armed with this context, let us study the following Heap Summary view from the memory leak diagnosis case:

The shaded region across the graph and markers indicates the time range used as the filer.

The census at the start reports 5576 instances of managed type objects accounting for about 283 KB and 26 instances of Silverlight Visual elements accounting for about 13 KB. In terms of incumbency the plain old managed objects dominate.

The churn happening within the selected time range is reported as 10615 instances allocated (births) and 11590 instances collected (deaths), accounting for about 23 MB each. The counts and sizes are somewhat balanced and cancel each other out to an extent. And this is borne out by the census at the end for the managed objects; the census at the end reports 4601 instances of managed type objects accounting for about 223 KB, which is just a little lower than what we had at the start. However, it also reports 69 instances of Silverlight Visual elements accounting for about 4 MB now (up from 13KB at the start).

When we correlate this table with the graph, our suspicion is drawn towards the Silverlight visuals. Why did their count go up, and why are they accounting for so much more memory? Within the filtered time range, memory usage has been steadily increasing too. Could we be leaking memory? Could we be leaking some part of visual tree itself? And there even seem to be images being loaded along the way; might we be leaking their texture memory too? We wonder.

Clearly, the next lead to follow is to get more visibility into what are those “Retained Silverlight Visuals at End”.

Summary

The Heap Summary view presents, in tabular form, a demographic analysis of the population of the heap. Interpreting the data in the table and correlating it with the graph and markers by itself can be used to make educated guesses at what could potentially be the problem, but equally importantly it serves to inform the next step in the performance investigation, as we shall see.

Silverlight 5.1.10411.0 Released Today

Pete Brown — 2012-05-09T21:54:33

Today we released a minor update to Silverlight 5. The 32 and 64 bit update version number is 5.1.10411.0. (The documentation said 5.2 at first, but this has been fixed.)

This will be rolled out to everyone. We throttle large updates of products at the start, so for some folks it was not automatically downloaded this morning.

This is primarily an important security update addressing an TrueType security issue that was reported across a large number of products. Some folks (like me) have reported issues seeing the TechNet page which has the information about the security issue, so I've repeated it here:

Executive Summary

This security update resolves three publicly disclosed vulnerabilities and seven privately reported vulnerabilities in Microsoft Office, Microsoft Windows, the Microsoft .NET Framework, and Microsoft Silverlight. The most severe of these vulnerabilities could allow remote code execution if a user opens a specially crafted document or visits a malicious webpage that embeds TrueType font files. An attacker would have no way to force users to visit a malicious website. Instead, an attacker would have to convince users to visit the website, typically by getting them to click a link in an email message or Instant Messenger message that takes them to the attacker's website.

This security update is rated Critical for all supported releases of Microsoft Windows; for Microsoft .NET Framework 4, except when installed on Itanium-based editions of Microsoft Windows; and for Microsoft Silverlight 4 and Microsoft Silverlight 5. This security update is rated Important for Microsoft Office 2003, Microsoft Office 2007, and Microsoft Office 2010. For more information, see the subsection, Affected and Non-Affected Software, in this section.

The security update addresses the most severe of these vulnerabilities by correcting the manner in which affected components handle specially crafted TrueType font files and by correcting the manner in which GDI+ validates specially crafted EMF record types and specially crafted EMF images embedded within Microsoft Office files. For more information about the vulnerabilities, see the Frequently Asked Questions (FAQ) subsection for the specific vulnerability entry under the next section, Vulnerability Information.

Recommendation. The majority of customers have automatic updating enabled and will not need to take any action because this security update will be downloaded and installed automatically. Customers who have not enabled automatic updating need to check for updates and install this update manually. For information about specific configuration options in automatic updating, see Microsoft Knowledge Base Article 294871.

For administrators and enterprise installations, or end users who want to install this security update manually, Microsoft recommends that customers apply the update immediately using update management software, or by checking for updates using the Microsoft Update service.

See also the section, Detection and Deployment Tools and Guidance, later in this bulletin.

This is more of a GDR level release, but we needed to follow a new version number scheme. The version number doesn't indicate major functionality change or enhancement, but is actually a product of the build process. I'm reading the pages of discussion in our bug database covering this versioning numbering and the reasons why it went to 5.1. It really only makes sense if you're using our internal build tools :)

Note also, that as was the case in the Silverlight 4.0 to 4.1 updates, we reset the build number. This shouldn't be a problem unless you have code that is checking a build number without looking at the version number as a whole.

Release history from http://www.microsoft.com/getsilverlight/locale/en-us/html/Microsoft%20Silverlight%20Release%20History.htm

Silverlight 5 Build 5.1.10411.0 Released May 8, 2012

All updates to Microsoft Silverlight include functional, performance, reliability and security improvements and are backward compatible with web applications built using previous versions of Silverlight.

Fixes Security issue described in the following Microsoft Knowledge Base article: 2636927 MS12-034: Description of the security update for Microsoft Silverlight: May 8, 2012

Fixes an issue where "Best Effort" Silverlight Digital Rights Management Output Protection levels failed on some machines.

Fixed a failure to update OOB applications that are configured to use elevated trust when in browser.

Fixes an issue where persistent license acquisition would fail when a customer upgrades from Silverlight 4 to Silverlight 5.

Fixes an issue where certain character combinations can cause Silverlight application to crash.

Fixes an Access Violation described in the following Connect issue https://connect.microsoft.com/VisualStudio/feedback/details/719572

Fixes an issue where the SL5 plugin displays blank window after installing a font with a font name that starts with "&".

Fixes an issue where moving a focus to TextBox or RichTextBox after moving a focus to ItemsControl causes IME to be disabled.

Fixes an issue where Silverlight would not play content which required Output Protection.

Fixes a Silverlight DRM issue where some customers encounter hardware ID mismatch errors which can only be resolved by re-individualization.

Be sure to let us know if you run into any issues with this release.

Más tiempo para Cell·APP Awards

Juan María Laó Ramos — 2012-05-08T00:05:43

Las plegarias han sido oídas y hemos ampliado el plazo para presentar juegos y aplicaciones a Cell·APP Awards: Desarrolla tu app usando CELL·SDK. Debes rellenar este formulario para participar y enviarnos el formulario de suscripción. Fin de Inscripción: 31/05/2012 Último … Continue reading →

Building Metro style apps with C++ event is now a live webcast

Jaime Rodriguez [MS] — 2012-05-07T11:09:00

Two weeks ago, we announced an all day training for those Building metro style apps with C++..

Event sold out within a few days, and we got a lot of requests for it to be recorded (or broadcasted live)..

I am happy to announce that the event will now be live. Please pencil us in in your calendar. Event will be live on Friday May 18th, from 9 AM PST to 5 PM PST.

We will share details (the link) and the agenda later this week.
We will aim to have two live Q&As (one around noon PST) and one around 4 PM PST, we will take your questions via twitter.. Just follow the #win8C++Camp (Updated on 5/10) #ch9live hash on the day of the event..

Please help us spread the word!! Hope you can join us on the 18th.

Happy Windows 8 coding!!

Teaching kids electronics, electricity, and logic using littleBits

Pete Brown — 2012-05-06T02:57:39

We homeschool our two children. Ben, is kindergarten age, Abby is pre-school age. My wife does, by far, most of the work there, including trucking them to specialized classes (art, music, gymnastics, karate, our homeschool group single day school, etc.) plus all the playdates with the other kids, and special events. Melissa even teaches several of the classes at the home school group. I generally deal with reading, since I'm in charge of story time with my son. Lately, we've split our time between him reading stories to me (I'm proud to say he's at about a 2nd grade level - you have to love personal tutoring) and me reading The Hobbit to him in preparation for the movie this Christmas. (JRR Tolkien is far wordier than I remember.)

Melissa and I also split science duties. I've brought Ben to the Banneker planetarium for a customized class arranged for our homeschool group in concert with one of the astronomy professors. I often bring Ben to SERC (Smithsonian Environmental Research Center) for their bi-weekly homeschool science class. It's nice to leave close to centers like that. Even in the 5-7 year old group, they do serious science. They worked with Microscopes to analyze feathers to explain what holds them together, learned about the scientific method, dissected something (unfortunately we missed that one), searched through oysters shells on the bay looking for shrimp, jellies, and fish, and much more.

There are certain things that I allow the kids pretty much as much as I can afford (within reason): decent books and LEGO. The educational value of them both is apparent the minute the child starts interacting with them. Unlike TV, the computer (the kids share my old netbook), or Leapster (or Nintendo DS in the case of Ben), we don't limit the children's time on either of these. In addition, we keep a cabinet full of paper, markers, glue, paints, stickers, and other craft supplies which the kids can play with pretty much whenever they want. We like to keep things around that encourage creativity. We're not perfect by any means, but we've found that making this stuff easily accessible encourages experimentation (and large paint and glue stains on our kitchen table, and random things stuck together that you may not actually want stuck together).

I tell you all this just to give you an idea of where we are with education in my family, and how important I consider it.

Of course, none of these things are exclusive to homeschooling or to us. I'm proud of what we've done so far, but we just happen to be fortunate enough to live in an area with lots of free museums and programs geared towards home school students. Many others take advantage of these museums and programs as well, they just have to do it on the crowded weekends :).

Note also that we generally teach both children the same things, although they follow their own interests. I tend to focus on Ben in this article not because we're teaching only him electronics and science, but because his age makes these things more appropriate right now.

Electronics and programming

One thing I've been trying to find a good way to teach is electrical/electronics basics and boolean logic. Not only is this an area of interest for me, but boolean logic forms the foundation of everything you do on a computer. I want my kids to have an understanding of this to complement their ability to use the computer (yes, both kids can use a mouse or track pad, Ben can type, albeit not quickly, as well). I've also found boolean logic just about the simplest math/logic you can get. I have no idea why I wasn't exposed to it formally until college (the only math class I've ever aced, besides 10th grade Geometry).

Programming is great, but I know from my own experience, that making something happen *outside* a computer is far more impactful and memorable.

One day, I had Ben in my home office and together we stuck a resistor and an LED in a little breadboard. Ben then touched the wire leads to a 3v battery pack I had around. He thought it was awesome that he could make an LED blink (again with the blinking LED, the gateway drug of electronics <g>). I thought this was great too. However, this type of approach won't go far with a 6yo or 3yo, as it's too easy to let out the magic blue smoke. It doesn't encourage experimentation at their level.

For my two kids, I found the snap circuits kits a little too fine grained in what they do. It's much easier to connect the components compared to discrete leaded components and a breadboard, but you can still connect them incorrectly. The snaps are also bit difficult for the kids to work with, and you're really working with just an easier form factor for discrete components. Getting from empty to blinking LED is just as much work as it is with discrete components. There's still lots of value to these, however, so the set Santa brought for Christmas will simply stay around for a few years until the kids grow into it.

As much as the kids like LEGO, the engineering and programming involved in the Mindstorms kits is also well above them right now. It's marked "10+" as a recall, so we still have time :)

I'm not trying to turn my kids into computer programmers, although I think basic programming is as necessary a skill as any other for their generation. Recently, I ran across a project that started on Kickstarter, and then became its own company.

littleBits

littleBits is a company and a collection of kid-friendly hardware modules ("bits", do a mental substitution ever time I say "modules") that can be connected together to form simple electrical circuits. The starter kit comes with a number of bits including a power module, button, potentiometer, LED bar graph, and more. Shown below is the little bits kit along with seven additional modules I purchased. I ordered the kit from makershed, and the additional bits directly from littleBits.

The overall design is Open Source Hardware, with the schematics available on github.

The connectors are custom fabricated modules which each contain three pins (or three pads) and a set of magnets. The pins are the typical Ground, Voltage, and Signal trio, with +5V as the standard high level. The polarization of the magnets prevents the modules from being connected incorrectly. Modules can be easily pulled apart, but the magnets are generally strong enough to stay connected during use (more on the connectors after I describe a few more things).

Each module is classified as either Input, Output, Power or Wire, and color-coded by its type (input: pink, output: green, power: blue, wire (and logic gates/routing): orange). Each is also supplied with Ground, +5V and the signal through the pins on those colored connectors. Three wires may not seem like much in the way of control, but there's a thriving community doing cool things with this simple standard.

With perhaps the exception of the buzzing motor module (which has the vibrating motor attached with a few thin wires), everything is extremely robust and able to stand up to the use of kids of various ages. Both my son and daughter enjoyed playing with them.

(the photos aren't instagrammed, they just have poor lighting)

Obviously the children each got something a little different from the process. Both enjoyed connecting them up and making something happen. Ben was able to understand the basic flow of electricity, and even a little about "AND" and "OR" logic gates. Abby enjoyed connecting all the pieces in a long chain, but also liked when she was able to test her strength against the pressure sensor (power + pressure sensor + LED bar graph == strength tester).

Ben also liked trying to connect every possible module to make something giant. However, after playing with it a third time, he started to understand a very important aspect of software and hardware design: build in small steps and test after each step. I can think of a number of professional developers who could benefit from this :)

My son's attention span is about the same as mine: 20 minutes. After that, he tends to get pretty antsy. (This is why you generally don't find me attending sessions by other speakers, or you see me sitting in the back and bailing when the session is half over. Nothing personal!) The littleBits did keep him engaged that entire time. More importantly, in the two days I've had these, he has played with them three times. Over time, they will likely only hold his attention if we add on newer modules that do different things. Kids are all about doing, not learning. The way to get them to learn is to get them to do, and the way to get them to do, is to find something that makes it dead simple to do something right off the bat. The littleBits definitely fit the bill here.

During the third time playing with the bits, Ben really started to grasp the concept of the flow of electricity. He wanted to know what exactly it was. I found the water analogy good enough for our discussion here, especially since it helps explain the potentiometer and buttons very well. He even figured out, on his own, how the pressure sensor conceptually works.

Logic

Once you have the basics of electricity down, you can start messing with logic. I had ordered both an AND and an OR module. Each module takes two inputs and has a single output. As you would expect, both inputs must be powered for AND to produce output, and only one in the case of OR.

Here's a simple AND gate made using: Power module, branch module, button and wire modules on top, button and wire modules on the bottom, and then the AND module and an LED module on the other ends of the wires. It demonstrates a logical "AND". That is, the LED will light only if both buttons are pressed.

The other circuits shown have been built by Ben or Abby. In this case, I built this circuit for Ben to show logic. I wouldn't necessarily expect him to come up with it on his own, although he was able to grok the concept of AND very easily from this. This is far more interactive, visual, and intuitive when compared to a truth table.

One issue with littleBits

littleBits isn't without issues, however. There's one design issue which, to me, prevents this from being the perfect learning tool. Their pin design doesn't have much compensation for poorly aligned connectors. Sprung, semi-pointed pins on one side contact flat pads on another. The pins are sprung, but the tolerance for a good connection is still pretty tight, as I found that even a slight amount of deviation from square on multiple modules can lead to connection issues for the circuit.

This very slight deviation from square, as shown here, is enough to cause those connection issues:

Unfortunately, these connectors are rigidly connected to the boards, presumably in some sort of mass manufacturing process. As anyone who has ever developed boards with connectors knows, not all these connectors will be perpendicular to the boards once assembled. In the worst case (which happens to be in the set I have), you end up with a situation that looks like this:

Notice how the boards sit off above the table, arched like a bridge. Right to left, there's the power module, a button module, the RGB LED module, another button module and (off picture) a regular LED module. If you press either of those two button modules, it causes the module to flatten to the table top, and disconnects the connection at the RGB module. Either I got a particularly bad batch, or this is a common issue. Like bank rounding errors famously making a crook rich, the problem compounds based on the alignment of the modules in a given circuit and the number of modules with this problem.

Generally, the impact here is really only with the button modules, and a little with the potentiometer module, and only when you have a few offending modules in a chain. It's the downward pressure required for the button that causes the problem. You can still have lots of fun without the buttons, or perhaps even put a folded bit of paper under the high module. You can also, for smaller circuits, simply pick it up and squeeze the button between your thumb and finger.

With modules this small size, the main issue isn't any warpage on the PCB itself, but the mounting of the plastic connector to the PCB base. The connectors aren't really deep enough to keep square during factory assembly.

If these modules were some inexpensive chinese thing from ebay (they're not. They're designed and assembled in the USA), I'd have expected this. However, at the prices of these modules (I'm in about $230 right now), this is an unexpected and surprising flaw. My RGB module, in particular, is really sensitive to this.

For the ones that are particularly bad, I'm going to request replacements. It may be that some slipped through production in the batch I have. Or it could simply be early production issues from a startup company trying to meet higher than expected demand. I would expect littleBits to make it right for any that are like this; they seem like an upstanding type of company.

Note that the littleBits site seems to show this issue with what I assume is a prototype kit in the slide show on the main page:

If you tried to connect something else downstream from that LED bargraph, you'd run into alignment issues. (In this case, the LED bargraph appears to have a connector incorrectly alignment, but leaning inward instead of outward as mine do).

Caveats of the connectors aside, I still think this is a great kit to get for you and your children, and I do not hesitate to recommend it as a way to teach the things I've mentioned here. My recommendation is to simply check alignment when you get the kit, and ask for replacement of any bits that are particularly out of tolerance. Sometimes you can only tell once you connect them up a few different ways and get the compounded issue of multiple misaligned parts.

Building your own bits

Little bits has been taking ideas on their dreamBits page for some time now. The list sometimes gets overtaken by joke entries (they seem to clean those up regularly), but there are also some good ideas there. But what do you do if you want to just build the bits yourself?

littleBits has been saying for a bit (haha! I crack me up) that they will have their connectors available for sale soon. I have no idea how much they cost, but I'm pretty sure I'll pick up at least a few to try creating my own modules/bits. There are lots of interesting components you could build out, including interfaces to microcontrollers to kick things up to the next level, should you wish.

Once they release the connectors, I'll probably give a few ideas a shot, and not just to show the kids how you can create your own stuff. Why not? The grown-ups can have fun (and learn) too :)

Yet Another Podcast #64–John Papa & Javascript

Jesse Liberty [MS] — 2012-05-03T19:44:03

Jugando con el ApplicationBar en los elementos de una App Panorama

La Liga Silverlight — 2012-05-02T20:00:53

Publicado por LucioMSP en abril 28, 2012 Hola amigos, el día de hoy les quiero compartir un pequeño tutorial sobre como manipular el ApplicationBar en todos los ítems que agreguemos en una aplicación estilo Panorama, es decir, hacer que se muestre el ApplicationBar solo en ciertos elementos de la Aplicación en Panorama y es que me encontré con varios problemas cuando quise realizar esto, ya que no encontré ningún material que me explicara al 100% lo que quería, además de que varias personas me comentaban que no se podía, o que no sabían, es por eso que quiero darlo a conocer. Parte 1 http://luciomsp.wordpress.com/2012/04/28/jugando-con-el-applicationbar-en-los-elementos-de-una-app-panorama/

Delivering Rich Mobile Web Experiences in Windows Phone 7.5 (ESPN.com Case Study)

Windows Phone Dev Blog — 2012-05-02T18:09:42

The Windows Phone Browser team has a goal of delivering the best web browsing experience on a smartphone. This goal has many components within our team: from the UI of the browser, compatibility with a wide array of website layouts, and of course buttery-smooth rendering performance. However, even if we execute flawlessly on our end, we are missing a crucial piece - delivering a great web experience is fundamentally a partnership between our team and web developers. Achieving this goal means working together to ensure that your content and services are delightful for users to consume on Windows Phone.

We understand that web development resources are always limited as you keep up with the increasing traffic from mobile devices, and the elusive "write once, run everywhere" promise of web development has not perfectly materialized. However, with IE9 for Windows Phone 7.5, we took a big step in the direction of this promise. By sharing a codebase with IE9 for the PC, we achieved identical support for new web standards and pushed the envelope on real-world performance with industry-leading hardware acceleration. We wanted to hear about developing for IE9 on WP7.5 from web developers directly, so we decided to collect some feedback and share it on the blog.

ESPN.com recently deployed their premium web experience to Windows Phone, and we thought it would be great to hear what they had to say about developing for IE9 on Windows Phone. As a side note, ESPN started looking into supporting Windows Phone because of a simple request I made on their support page. Lots of folks on my team are sports fans and were asking me about the site's experience on WP7.5, so I just dropped ESPN a note like any user would. The message was quickly routed to the mobile site team; I have immense respect for ESPN’s responsiveness and the system they have place to address user feedback. Here's what Mike Marrone, technical lead, had to say about developing for IE9 on WP7.5:

Overall, it was an easy process. We support only WP7.5 and IE9 thanks to its very good CSS3/HTML5 support. We are in a convenient position of having an existing legacy mobile site that older devices can fallback to. Honestly, development for WP7.5 boiled down to a fairly basic process - IE9 on the PC, being nearly the same browser, was a great dev tool to get most of the way there before final QA on actual devices.

Some other more specific development notes:

The "display: box" CSS style is not supported on WP7.5. We use this in carousel experiences to transition elements left or right 100% of the viewport without having to programmatically determine the viewport size (which means the browser automatically updates the positioning upon device rotation, etc.). On WP7.5, we actually used a better alternative thanks to it being the only browser that currently supports the CSS "vw" unit (VERY useful).
[Amin] See here and here for more information on vw units.

The bulk of our CSS differences between WP7.5 and other supported devices was with gradients. WP7.5 has an easy fallback with filters so it was not a big development issue.
[Amin] See here for information on using Gradient Filters in IE9.

JavaScript touch events would be a nice addition.
[Amin] We hear you, stay tuned!

We look forward to your continued great progress in mobile.

As you can imagine, this was music to our ears! We often use IE on the PC to investigate bugs, and it was great to hear that the tools work well for web development outside of our offices too. We appreciate the feedback (it will inform our plans for future releases) and welcome additional feedback through the comments below.

IE9 on Windows Phone is set up to support rich web experiences with great performance, and often all it takes is updating user-agent logic and using standards based (as opposed to vendor prefixed) HTML & CSS. ESPN invested a reasonable level of resources to do that and delivered a delightful experience to its users. I've definitely started to see the site pinned to Start around here, and I wouldn't be surprised if our senior managers are secretly checking ESPN during meetings.

Here's a before (left) and after (right) screenshot of the ESPN.com experience on Windows Phone 7.5. We want to say thanks to ESPN, and we look forward to seeing more rich experiences light up!

Special thanks to Krys Krycinski, Mike Marrone, and James Ballow at ESPN.

Amin Lakhani
Program Manager, Windows Phone

Neuerdings im Web (April 2012)

Mario Priebe — 2012-05-02T08:41:08

Einen schönen Round-Up bringt uns NETTUTS über derzeitige Features und neuen nützlichen Javascript/jQuery Libraries für die Webentwicklung. Gut finde ich jQuery Scroll Path "jQuery Scroll Path is a plugin that lets you define your own custom scroll path. What this means exactly is best understood by checking out the demo. The plugin uses canvas flavored [...]

Nachlese zur Visual Studio 2011 Beta Roadshow

Kazim Bahar — 2012-05-01T22:01:12

Am 25.April habe ich die Roadshow zu den Neuerungen von Visual Studio 11 in Frankfurt besucht und möchte nun einige der vielen Features, die in der fünfstündigen Veranstaltung erörtert wurden, kurz vorstellen. Auf den ersten Blick fallen die Änderungen am User Interface auf. So wurden alle Icons neu gestylt und die Toolbars aufgeräumt. Beispielsweise wurden die Icons für [...]

Symposium Session: Gadgeteering and the .NET Micro Framework

Pete Brown — 2012-05-01T21:12:13

On April 24th I helped run the patterns & practices Symposium 2012 Online on Channel 9. All of the videos are currently up and viewable on-demand.

As part of the event, I gave a talk on the .NET Micro Framework. I had a ton of fun doing it, and got to show off a lot of great gear. Take a look and let me know what you think.

I'll have the demos and presentation pptx uploaded shortly.

Visual Studio Achievements For Windows Azure Buzz

Karsten Januszewski [MS] — 2012-05-01T19:31:37

Here’s some links to posts and stories about the 15 new Windows Azure achievements added to Visual Studio Achievements:

Visual Studio Adds Windows Azure Achievements
Neowin

Azure Gamified - More Badges!
I Programmer

Visual Studio Achievements Brings Gamification to Windows Azure Development
MSFT post

Announcing Windows Azure Achievements For Visual Studio
Windows Azure Post

Cloud Cover Video
Channel9

Announcing Visual Studio Achievements For Windows Azure
Channel9

Four ways we’re improving Marketplace

Windows Phone Dev Blog — 2012-04-30T23:48:45

Today I’ll outline the latest steps we’re taking in our ongoing effort to keep the quality bar high in our rapidly growing Marketplace. I know most of you share our goal of a great shopping experience and already go out of your way to follow our policies and guidance. For others, I hope this insight into a few near-term changes we’re putting in place helps save you time and reduces your risk of having apps pulled from the Marketplace.

Avoiding trademark trouble

When a trademark or copyright owner contacts us about a suspected violation, we investigate and pull apps when the complaint is valid. Lately we’ve been doing more of this, especially for trademark misuse. Sometimes the requests come from the owners of big, well-known brands. Other times they come from new brands. Either way, we often find trademark violations are unintentional: some developers just aren’t clear on what constitutes a violation. But these investigations—and the time and money they can cost—can be avoided by doing a little homework before submitting or updating your app.

If you’re developing an app, please consult our content policy covering trademarks and this related Q&A. (The U.S. Trademark and Patent Office also has helpful background and a trademark search tool.) Our rules boil down to this: Your registered publisher name and everything about your app—name, logo, description, screenshots—must be unique and free of trademarked content unless (1) you own the trademark, (2) you’ve secured permission from the owner to use it, or (3) you’re using a trademarked name (not a logo) to describe your app’s features or functionality without suggesting that the app is actually published by the trademark owner.

For example, using “Microsoft App Co.” as your publisher name would cause problems because “Microsoft” is a trademarked term. By the same logic, you couldn’t call your app “MSN” or “YouTube”. However, you may be able to make an app called “Reader for MSN,” as long as you don’t use the MSN logo or otherwise suggest that the app is published by Microsoft.

Keeping the quality bar high

I’ve posted before about our efforts to help ensure that apps in Marketplace offer clear value. One of those efforts concerns bulk publishing—developers who send us hundreds of similar apps simultaneously. Today I want to mention two related issues on our radar that could affect developers working on app genres that lend themselves to bulk publishing.

First, we’re seeing developers submit the same app to multiple Marketplace categories, a violation of our policies. Instead, you should pick a single category that best reflects the content and function of your app. This not only helps customers find your app but gives all developers an equal opportunity to have their app discovered where people expect. Developers who submit the same app across multiple categories will have it removed from the catalog.

Second, when you create multiple closely-related apps—say, a series of quote apps that vary by theme—the Marketplace tile images must reflect the unique features of each individual app. They cannot be duplicates or near duplicates of each other. Your branding also shouldn’t dominate the tile. Here are a few examples of dos and don’ts:

Creating unique, easily distinguishable app tiles helps customers see at a glance what’s different about the apps you’re publishing, improving the shopping experience and potential for downloads.

Cleaning up keywords

Some developers have been violating Marketplace policy by entering more than the five allowed keywords for an app. A keyword is a word or short phrase that describes your app. Entered during the App Hub submission process, these words or phrases are always separated by commas.

Starting this week, we’re going to start enforcing the five keyword rule for all current and future Marketplace apps. Any app that exceeds this number will have all its keywords deleted. Affected developers will be notified and can then enter five new keywords in App Hub. We’re taking this action to help ensure that customers are able to find the most relevant set of apps for their search—including yours.

We’re also starting to examine app keywords for relevancy. We’ve noticed some developers have been entering keywords that are popular search terms—“Justin Bieber,” “YouTube”—but are totally unrelated to their app and what it does. If we find a keyword that’s not relevant to your app’s function or content, we’ll delete that keyword. Additionally, if you suspect that other developers are using high-impact keywords unrelated to their app— “Skype” for a tic-tac-toe game, for example—email reportapp@microsoft.com with the details and we’ll investigate.

Refining our approach to content policy enforcement

The final issue I want to discuss is one that affects all major app stores today: the treatment of apps that are “racy” or sexual in nature. We’re committed to offering a diverse selection of safe and quality apps that appeal to a wide range of customer interests. Items that some customers view as entertainment, others may consider inappropriate. This is a challenge for any big retailer, whether they operate online or down the street.

We think the right solution is (a) to be transparent about what’s acceptable and (b) to show the right merchandise to the right customer in the right place. Our content policies are clearly spelled out: we don’t allow apps containing “sexually suggestive or provocative” images or content. What we do permit is the kind of content you occasionally see on prime-time TV or the pages of a magazine’s swimsuit issue.

Admittedly, it’s tricky catering to such a wide range of people and markets. But we take this responsibility seriously and evaluate and discuss questionable cases. Recently we decided that we could improve the shopping experience for all our customers by a more stringent interpretation and enforcement of our existing content policy.

Specifically, we will be paying more attention to the icons, titles, and content of these apps and expect them to be more subtle and modest in the imagery and terms used. Apps that don’t fit our standard will need to be updated to remain in the store. This is about presenting the right content to the right customer and ensuring that apps meet our standards. We will also monitor customer reaction to apps and reserve the right to remove ones that our customers find offensive

While this change might require a little extra work on the part of a small number of developers, there are plenty of creative and appropriate ways to comply: showing male or female models in silhouette, for example, is one possible alternative. Here are a few other examples of app tiles that pass muster:

If you’re one of the handful of impacted developers, we will be reaching out to you within the next few days with more specific guidance on changes you need to make. If you don’t hear from us, there is no immediate action you need to take.

I hope this post has provided some useful tips and helpful insight into our policies, and how they’re evolving to reflect both customer and developer feedback and the growing size and reach of the Windows Phone Marketplace. We’re committed to our developer community and appreciate your feedback on how we can make Marketplace better for you and your customers. I look forward to hearing your thoughts.

Efecto “Gloss” de los iconos en iOS

Juan María Laó Ramos — 2012-04-30T01:00:10

Alguna vez nos ha sido necesario eliminar el "brillito" que iOS introduce en los iconos de nuestras aplicaciones. A ese efecto se le conoce como "Gloss". Tiene este aspecto: Pero imaginad que queremos eliminar ese efecto ya que nuestro diseñador … Continue reading →

CodeFluent Entities. Nunca el DDD fué tan fácil

Juan María Laó Ramos — 2012-04-27T01:00:54

Vamos a ver en este post es un producto que he encontrado y parece muy prometedor. CodeFluent Entities es una herramienta de modelado que nos permite generar y mantener actualizadas todas las layers y capas de nuestra aplicación. Asegurando el … Continue reading →

GridView Control in Windows 8

Jesse Liberty [MS] — 2012-04-26T20:09:26

Cell·SDK y el emulador de Android

Juan María Laó Ramos — 2012-04-26T12:25:59

Hace unas semanas se publicó una actualización del emulador de Android que muchos estábamos esperando. Entre otras cosas, la característica fundamental, y una de las más esperadas, es que esta versión del emulador por fin soporta la aceleración de GPU, necesaria … Continue reading →

Two Marketplace changes; An update on 9 new markets

Windows Phone Dev Blog — 2012-04-25T00:49:34

I wanted to make sure you saw the Windows Phone consumer blog today, because my colleague Mazhar highlights two changes to the Marketplace shopping experience that developers should be aware of.

First, we’re removing the option to browse and buy Windows Phone apps from the Zune PC software, a change that started rolling out this afternoon. Second, in the coming weeks we’ll also start requiring that customers have Windows Phone 7.5 installed on their phone to buy, download, update, or review apps in Marketplace.

Mazhar’s post has more details and background. But I want to highlight one important way the removal of the Windows Phone store from Zune impacts developers.

It’s important to make sure you’re using the correct protocol for direct links to your app in Marketplace. This “deep link,” as it’s also called, makes it easy for customers to pull up your app in the phone and web stores. The correct format is:

http://windowsphone.com/s?appId={GUID}

You’ll find more details on deep links here on MSDN. If you use the older zune:// format for links, customers will see an error message. Just something to keep in mind.

One final update for today: We just released the OS software required to bring Marketplace to customers in Bahrain, Israel, Iraq, Kazakhstan, Qatar, Saudi Arabia, Thailand, UAE and Vietnam. These nine markets—which are already open for app submissions—were part of the larger Marketplace expansion I outlined last month. Our hardware partners can now create phones for these markets and begin their final launch preparations.

Mazhar will have more to say about these new storefronts in the weeks ahead.

Respond to User Input

Windows Phone Dev Blog — 2012-04-24T17:53:00

The fourth of the four principles I mentioned in Optimizing Apps for Lower Cost Devices is Respond to User Input.

A responsive UI is a basic expectation that users have of apps. Failing to respond to user input can frustrate users and can ultimately drive them away to other apps that are more responsive.

The basic guidance here is to keep as much activity off of the UI thread as possible until absolutely necessary. The UI thread is what processes user input for you, so any code you execute on that thread will interfere with this processing. Unless you're updating elements of your UI, you generally should not be executing code on the UI thread.

A quick way to check whether a block of code is running on the UI thread is to call Deployment.Current.Dispatcher.CheckAccess() inside that block of code (Intellisense won't show this method but it is there and useful). This will return true if the code is executing on the UI thread, so if this returns true and you're not updating your UI, then you've found code that could be moved to background threads.

An easy way to move code to background threads is to wrap it in a call to ThreadPool.QueueUserWorkItem().

// Running on the UI thread.
...

// Running on a background thread.
ThreadPool.QueueUserWorkItem((o) =>
{
    ...
}

The ThreadPool is (as its name suggests) a pool of background threads that are waiting to execute work items for you. QueueUserWorkItem enables you to register blocks of code that will execute on the next available background thread in the ThreadPool. Note that use of ThreadPools is common and encouraged across many platforms (including Windows 8) so familiarizing yourself with them will serve you well in future projects.

When you are ready to update your UI, you will need to return to the UI thread. You can return to the UI thread at any time from a background thread by wrapping your code in a call to Deployment.Current.Dispatcher.BeginInvoke().

// Running on a background thread.
ThreadPool.QueueUserWorkItem((o) =>
{
    ...

    // Running on the UI thread.
    Deployment.Current.Dispatcher.BeginInvoke(() =>
    {
        ...
    }
}

If you try to update your UI from a background thread, you will receive an UnauthorizedAccessException with the message "Invalid cross-thread access." In these cases, wrap the offending code in a call to Deployment.Current.Dispatcher.BeginInvoke() as shown above to execute it on the UI thread as required.

In addition to being able to control whether your code executes on the UI thread or on background threads, you also have options to do the same with framework code in several places.

Image decoding is an expensive operation that can harm interactivity significantly if executed on the UI thread, particularly if you're loading many images at a time. The framework allows you to specify BitmapCreateOptions to control whether image decoding executes on the UI thread or on background threads. Be sure to use the BackgroundCreation option to move image decoding to background threads.

The built-in ProgressBar control has known performance problems that can harm UI performance as a result of its animations executing on the UI thread. Use the SystemTray ProgressIndicator for the best performance as the ProgressIndicator is a shell component that will not interfere with your UI thread. A bonus to using the ProgressIndicator is that your UX will more closely match the UX of the built-in experiences.

If you're using animations in your app, use Storyboards wherever possible as these run on an important background thread known as the compositor thread and will not interfere with your UI thread. If you're familiar with Expression Blend, it can be particularly useful for generating Storyboards.

With code now running off of the UI thread for a given page, you should also focus on optimizing navigation between pages.

To keep page load times and in-app navigation responsive, defer loading activities until the first frame is rendered. The guidance for optimizing startup time of your MainPage applies to optimizing the startup time of subsequent page loads as well. Enabling the TiltEffect is a great way to acknowledge user input and indicate that navigation is in progress. This will make your app look and feel more like the first party experiences as well.

Many apps add page transition animations to add style to in-app navigations. While this is a great practice to make your apps more dynamic, excessive use of transition animations can delay load times, particularly when the generation/execution of the animations result in spikes in memory/CPU usage. If transition animations are causing performance problems in your app, disabling them completely, or at least on low-memory devices only, can significantly improve in-app navigation performance.

Maintaining a responsive UI is important regardless of the platform you are targeting. By offloading work to background threads and keeping in-app navigation fast, you'll provide the best possible experience to your users.

Insidious ByRef Legacy Code Issue

Karl Shifflett [MS] — 2012-04-24T15:22:30

The ByRef in the title should give you a hint that this is about legacy VB.NET code. One of my duties at my new job is to maintain our legacy VB.NET codebase until we deploy our WPF software. When I use the term legacy it should not be taken in a negative manner. Our legacy [...]

Announcing the Building Windows 8 apps with C++ Windows camp

Jaime Rodriguez [MS] — 2012-04-23T21:13:00

Join the Microsoft Visual C++ and Windows teams in Redmond on May 18, 2012 for a free, all-day event focused on building Windows 8 Metro style apps with C++.

Whether you are a new C++ developer ready to learn about the writing Metro style apps, an intermediate developer who wants to hone your code and skills, or an experienced C++ developer eager to squeeze every ounce of performance out of your Metro style app and/or push the boundaries of Windows 8, then this event is for you. We will have pragmatic advice for every developer writing Metro style apps and games with XAML or DirectX and C++.

Agenda:

C++ for Windows 8, Keynote by Herb Sutter
Building Windows 8 apps with XAML and C++
Building Windows 8 games with DirectX and C++
Introduction to the Windows Runtime Library (WRL)
Writing Connected apps: Writing networking code with C++
Combining XAML & Direct X in a Metro style apps
Writing WinRT components to be consumed from any language
VC11 compiler flags for getting the most out of C++

Registration:
Register for this event here. If is first-come, first-serve, and we are limited in space, so register soon.
If you want to learn more about other Windows 8 camps check the camps site.

Details:
Location: Redmond WA, Microsoft campus, bldg 92.
Date: May 18th, 2012
Time: 9 AM to 5 PM for sessions, Q&A and a small social event afterwards.
Speakers: We will update the list of speakers early next week, we are still negotiating session times & speakers to cram as much as we can into a single day.
Rest assured most of them are from the product team and yes, Herb Sutter will do the opening keynote and the first session.
Meals: We will have some light breakfast, lunch, snacks and appetizers + drinks at the end of the day.

My personal pitch on this event:
Even if you are already coding your Metro style app, you don’t want to miss this event. All the speakers are product team people, and we will have a very strong pragmatic angle during our sessions; we are aiming to answer a lot of the questions and help you avoid the common pit-falls that we have seen our early partners building Metro style apps with C++ have ran into. There will also be ample Q&A time through out the day.

Happy Windows 8 coding. Please help us spread the word on this event we are really excited to connect with C++ community.

Buch: Perry Rhodan Neo 1 - Sternenstaub - Frank Borsch

Norbert Eder [MVP] — 2012-04-23T14:13:51

Das Jahr 2036: Überbevölkerung, Klimawandel und Terrorismus - die Menschheit steht kurz vor dem Untergang. Zudem steigen die Spannungen zwischen den Machtblöcken. In dieser Lage startet der amerikanische Astronaut Perry Rhodan mit drei Kameraden zum Mond - denn dort geschieht Unheimliches. Mit einer uralten Rakete brechen die vier Astronauten ins Abenteuer ihres Lebens auf. Auf dem Mond treffen sie auf die menschenähnlichen Arkoniden. Rhodan erkennt die Schwäche der Aliens - und er schlägt ihnen einen gewagten Handel vor. Sein Ziel: Er will Frieden für die Menschheit. Sein Preis: Er muss sich gegen alle Regierungen der Welt stellen.

Bis jetzt hatte ich immer einen Bogen um Perry Rhodan gemacht. Warum kann ich nicht genau sagen, unterschwellig müssen wohl dennoch Gründe vorhanden gewesen sein. Mit der Anschaffung eines Kindle habe ich dann aber dann doch den Sprung gewagt und mich via Neo an den Neustart von Perry Rhodan gemacht. Ohne also irgendeiner Altlast aufzusitzen, ohne Vorurteile, ohne den ständigen Vergleich, konnte ich mich daher auf den Inhalt und die Erzählung konzentrieren. Und ich muss sagen: Ich bin begeistert. Die einzelnen Charaktere sind gut herausgearbeitet, die Story selbst ist interessant und modern. Für mich ein gelungener Einstieg und ganz klar empfehlenswert!

Bewertung: 5/5

Weitere von mir gelesene und bewertete Bücher finden sich unter Lesestoff.

2-4-6-8-10

Charles Petzold — 2012-04-23T14:00:00

If you've been following my blog, you know that for the past few months I've been working on the 6th edition of Programming Windows, which focuses on writing Metro style applications for Windows 8 using C# and XAML.

... more ...

Interaction Event-Trigger als Style auslagern

Mario Priebe — 2012-04-23T12:26:31

In einem Caliburn.Micro Projekt setze ich den EventTrigger ein, um meine Commands an einem ViewModel zu binden. Nun möchte ich gerne immer den selben EventTrigger an mehreren Stellen einsetzen und verhindern, dass der Code an “tausend” Stellen redundant eingesetzt wird. Aus diesem Grund, soll diese Interaktion als Style zu Verfügung gestellt werden. Der folgende Code [...]

Maker Geek Roundup 011 for 4/21/2012

Pete Brown — 2012-04-22T02:55:58

The Maker Geek Roundup aggregates information of interest to makers everywhere. Topics include .NET Micro Framework, Arduino, AVR and other MCUs, CNC, 3d Printing, Robotics, Microsoft Robotics Studio, Electronics, General Maker stuff, and more. If you have something interesting you've done or have run across, or you blog regularly on the topics included here, please send me the URL and brief description via the contact link.

Photography

Sometimes It's Just Easier To Flag Your Camera (DIY Photography)
Vintage Color Cross Processing in Lightroom 4 (Getting the Instagram look using an SLR) (DIY Photography) (DIY Photography)

General Maker

An easy to build cat feeder driven by a DIY linear actuator (Hack a Day)
Dust Deputy Cyclone Shop Vacuum Cart CNC (Maker Masters)

Retro Computing and Commodore!

Happy 35th birthday, Commodore PET! (MOS6502)
Camera Matching (The Starry Expanse - Rebuilding Riven)
This Doctor Who RPG Makes Me Wish it Were Real. (this 8-bit life)
Soulless (Preview) (C64) (RGCD)
C64 16KB Cartridge Game Development Competition! (RGCD)
Site 31 of Lon McDonald's Joust Tour (Jeff's Classic Arcade)
Hooking an iPod to a C64 (MOS6502)
Retro Thing: Kickstart A 3/4 Scale Arcade Machine Project! (Retro Thing)
Knight 'n' Grail (C64) (RGCD)
A small tribute to a great man (MOS6502)

Wanted!! Great Windows 8 Metro style apps

Jaime Rodriguez [MS] — 2012-04-20T07:46:00

Tuesday, the Windows Store blog announced that in the next significant Windows 8 preview release they will be expanding
their global coverage with 33 additional app submission locales for developers.

As Antoine Leblond alluded to in the post, our store services are ramping up as planned--and of course the plan includes ramping up developer registrations to enable app submissions to the Windows store. Today, you need an invite “token” to register. This begs the question - How can YOU get a token?

It’s easy! If your app is ready and you want to be among those developers who get to submit to the store early, simply attend one of the 100s of free Application Excellence Labs that DPE and Windows are holding around the world.

Follow these steps to get invited to an App Excellence lab:

Create a really great Windows 8 Metro style app (or game) immediately. Get it as ready as if you were submitting to the store.
If you know your local DPE evangelists (maybe because you attended a Windows camp training), get in touch with them and ask them to nominate your app for a lab.
If you don’t know your local evangelist, then email the following information to win8aefb@microsoft.com:
1. Your name
2. City & country where you are located
3. Brief description for your app (no binary, screenshot is optional, but only send if the screenshot is public, non-confidential stuff )
4. Your pledge that you’ve spent at least 8 hours devouring all the great UX guidelines we have at the design section in the Windows Dev Center¹
5. Wait for our response letting you know where the closest app excellence lab will be and how to get in touch with the right evangelist to nominate you.

Hopefully, there will be a lab near you. Right now, we have labs in 40+ countries and we may be adding more.

Of course, coming to the lab is not all you have to do. I have to go back to step #1: You need to have a compelling, functional app that follows our UX guidelines, our performance best practices, and our store certification requirements²

The lab is a 4-hour engagement with a trained Microsoft Services Engineer. This person will run your app through a series of tests based on a quality checklist to ensure your app is (or will be) in top-notch shape when you submit. You will also get a chance discuss ways to make your app even better and you will get answers to any questions you might have.
If your app meets the criteria, then booyah! You get a token to register your developer account and (once you have been verified and all that) you will be able to submit your app to the Windows store.
If your app does not meet the criteria, nothing is lost. You will still end up with a much better app³ and you will be able to submit it when registration opens for all developers.

Good luck. We are looking forward to seeing your apps and helping you to make them great!
Happy Windows 8 coding!!

¹ Kidding about the pledge but not kidding about highly recommending you review the guidelines and get your app very polished.
² Note: The lab is not a replacement for certification process; that still happens when you submit to the store.
³ Really, the lab preparation will be worth it, you will have a survey with questions, useful advice, links to guidelines, etc. The survey is (by far) not the only criteria we will use at the labs, but if you follow the preparation from the survey, you will likely have a great app.

Using a Style to Simulate TextTrimming on TextBox

Walt Ritscher — 2012-04-20T01:06:59

Synopsis: The WPF/Silverlight TextBox control lacks the TextTrimming property. Use a control template to add TextTrimming to TextBox. Want more Silverlight tips and tricks? Watch my Silverlight 5 Essential Training course We’ve all encountered the textbox that is too narrow to hold the text contents. Here’s an example from Visual Studio 2010 Figure 01: Visual [...]

Can this be true? MSDN subscribers ignoring $4K of free Azure services

Walt Ritscher — 2012-04-19T22:20:52

This statistic, seemed unbelievable. Only one out of ten MSDN subscribers is using their free Azure benefits. According to Microsoft, MSDN subscribers get a boatload of free services each year (~$3700.00 USD) I’m not talking about the free trial download. This is something different. If you have an MSDN subscription you get a lot [...]

Memory Profiling - Launching, Graphs and Markers

Windows Phone Dev Blog — 2012-04-19T20:25:04

It is said that “A point of view is worth 80 IQ points”; the meaning perhaps being that if we can look at things in different ways then we might understand them better. The Memory Profiler that ships with the Windows Phone SDK 7.1 provides, in its own way, multiple views into the memory usage of your application, and in an earlier post we had seen how specific views helped us understand one particular issue with the application better. But even before we got to the specific views, there was a graph and a couple of rows of markers, remember? Let us discuss them briefly.

Launching the Memory Profiler

How do you even know that you need to run your application scenario through the Memory Profiler, especially since there might not be any obvious visual cue? The answer lies in an Execution Profiler warning message. The expectation is that you would run your application scenario through the Execution Profiler for evaluating visual and code performance, and if it suspects any memory related issues it will raise a warning message suggesting running the scenario through the Memory Profiler!

Users of the Execution Profiler will find the interaction model of the Memory Profiler familiar. It launches from the same page, with the difference being that you select the Memory (managed object allocations and texture usage) option. The Advanced Settings option can be ignored for the purpose of this discussion. The following is the launch page for the Memory Profiler:

A warning message is issued if the deployment target happens to be the Windows Phone Emulator. The emulator runs on the desktop, and the desktop has a different hardware architecture than the device, with different performance characteristics across the board. The warning therefore alerts you to this lack of performance fidelity. If you are doing Execution profiling beware! The emulator is still a suitable target for doing memory profiling since in that case we are dealing with (memory) allocation profiling. Clicking on the Launch Application link deploys the application to the target and commences the profiling session.

Stop Profiling

There are two ways to gracefully end the profiling session:

By hitting the Stop Profiling link on the Profiler page.
By hitting the back button on the target (device or emulator) until you exit the application.

If the connection from Visual Studio to the target is broken for any reason (for example, if the emulator instance is closed, or the device is untethered, or the device shuts down, the connection is broken) the session is aborted.

Once the session is gracefully ended, the data gathered during the run is processed and presented graphically for analyses, starting with a Memory Usage graph plotting memory usage over time, and two rows of markers indicating image loads and GC runs as shown below:

Memory usage graph

The memory usage reported is that of private bytes: exclusive bytes allocated by the process being profiled. Some variance in memory usage is normal and not indicative of a problem. However, memory usage that keeps rising bears examination.

Image load markers

A tooltip on the image load marker indicates the encoding format, the ID of the executing thread on which it got loaded, the point in time when it was loaded, and how long it took to load. A spike in memory usage corresponding to an image load marker might indicate a large sized image being loaded (larger than 2000 x 2000 pixels). Windows Phone imposes this limit, and larger images will be sampled at a lower resolution, and will take longer to load. If you must use large images consider displaying only a portion that meets this limit by loading the image into a System.Windows.Media.Imaging.WriteableBitmap and using the LoadJpeg(WriteableBitmap, Stream) extension method as shown below:

int width = (int) this.image1.Width;
int height = (int) this.image1.Height;
Uri uri = new System.Uri("image.jpg", UriKind.Relative);
StreamResourceInfo sri = Application.GetResourceStream(uri);
WriteableBitmap wb = new WriteableBitmap(width, height);
System.Windows.Media.Imaging.Extensions.LoadJpeg(wb, sri.Stream);
this.image1.Source = wb;

The ID of the executing thread can be used to check if the image load computation is happening on the UI thread (the UI thread’s ID can be got from the CPU Usage analysis from the earlier Execution Profiling session). To keep the UI responsive it is essential to keep the UI thread relatively free, and if you notice that the image load computation is indeed happening on the UI thread, consider moving it to a background thread using the BackgroundCreation option. From XAML, this can be done as shown below:

An exercise to try out at this point it to memory-profile an application that loads in a large image; do you see a spike in memory usage corresponding to the image load marker? What was the duration of the image load? On what thread was it getting loaded? Try using the BackgroundCreation option; now what was the thread on which the image got loaded? Did the duration of the image load change? Let us know your experience.

GC markers

Memory is a limited resource on the phone, and although you are programming in a managed environment where the GC takes care of collecting unused memory you still wield control over allocation and referencing, and must monitor them to trim working set. The GC mediates all allocation requests from your code, and operates on a heap that it has partitioned into 2 regions (generations), with allocations happen in the ephemeral “Gen0” region and objects surviving a GC collection possibly promoted to an older “Gen1” region. The GC markers correspond to collections and a tooltip indicates it’s kind ("ephemeral", "Full"), the point in time when it started, and how long it took to run. An “ephemeral” GC collects only from Gen0 while a “Full” GC collects from both Gen0 and Gen1. Furthermore a “Full” GC can do a “compaction” of the heap if it happens to be significantly fragmented, and even go on to empty the system’s cache of JIT compiled code.

A GC is triggered using several heuristics:

When the amount of managed memory allocated since the last GC is deemed significant (1 MB). This is typically an “ephemeral” GC. However it can turn into a “Full” GC under the following circumstances:

When the managed memory held by objects promoted to Gen1 is deemed significant (5 MB).
When the application’s total memory usage is deemed significant (i.e. close to the maximum allowed by the OS).
When there is significant native-memory pressure - native-memory associated to managed objects (quite common in Silverlight) contributes to total memory usage!

When user code calls System.GC.Collect(). This is always a “Full” GC.
After any resource allocation failure. This is always a “Full” GC.
When the system as whole is running low on free memory. This is always a “Full” GC (that will go all way to emptying the cache of JIT compiled code).

The GC’s decision of deeming a threshold “significant” is based on internal heuristics and mentioned here for informational purposes only. The point to note though is that a “Full” GC is much more performance intensive than an “ephemeral” GC.

Insight

Armed with the graph, the markers and your own intuition, you can now get some insight into your scenario’s appetite for memory:

Does memory usage cross the 90 MB technical certification requirement threshold?
Is memory usage steadily growing?
Do you see a spike in memory usage? Is there a corresponding image load marker? That could be the likely cause (are you using large sized images when a smaller sized image would do?)
Are image loads taking long? (Again, this could be due to using large images).
Are image loads happening on the UI thread (consider moving that to a background thread).
Are there too many GCs? The GC on the Phone is a stop-the-world GC, and therefore the time taken by the GC to run is time taken away from your application! In general strive for little to no GC activity during application startup.
The frequency distribution of the GC markers indicates the rate of memory allocation in the scenario, as well as the time ranges when most GC activity happened. If you are writing a game try to concentrate the GC activity during a level change.
Are there multiple adjacent “ephemeral” GCs? That indicates short lived and/or temporary objects.
Is memory usage not coming down even after one or more “Full” GCs? That is indicative of long lived objects.
Are you explicitly causing “Full” GCs by calling System.GC.Collect()? That is rarely required, and often a bad idea.

An exercise to try out at this point it to profile an application that has various memory allocations patterns; can you correlate the graph and markers with your own intuition? Let us know your experience.

Summary

The graph and markers provide basic information about your application’s memory usage and when combined with your own intuition of the application scenario, be used to infer several characteristics. Further drill down through the various Views can then be used to understand these characteristics better.

Would you like to know more about the Views? Let us know.

Crear y manipular un menú contextual en Silverlight

La Liga Silverlight — 2012-04-18T18:20:47

Una funcionalidad básica de prácticamente cualquier aplicación de escritorio es el uso del clic derecho para el común despliegue de un menú contextual, una funcionalidad que extraño mucho en las páginas web, afortunadamente en Silverlight podemos aprovechar la posibilidad de usar esta herramienta. Comienza por crear una nueva solución, después, al hacerlo, crea una nueva carpeta llamada Controles, ahí por último crea un nuevo UserControl llamado MenuContextual, al terminar, tu proyecto deberá verse de la siguiente manera. Ahora en ese UserControl llamado Menu Contextual, coloca el siguiente XAML. <usercontrol x:Class="Menu_Contextual.MenuContextual" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Width="150" Height="70"> <grid x:Name="LayoutRoot"> <rectangle Fill="#FF666666" Margin="0" Stroke="Black"/> <textblock x:Name="txtOpcion1" Height="20" Margin="8,8,8,0" TextWrapping="Wrap" Text="Opción 1" VerticalAlignment="Top" Foreground="White" TextAlignment="Center" FontSize="14.667" MouseLeftButtonDown="txtOpcion_MouseLeftButtonDown"/> <textblock x:Name="txtOpcion2" Height="20" Margin="8,0,8,8" TextWrapping="Wrap" Text="Opción 2" VerticalAlignment="Bottom" Foreground="White" TextAlignment="Center" FontSize="14.667" MouseLeftButtonDown="txtOpcion_MouseLeftButtonDown"/> </grid> </usercontrol>[/sourceode] Nada complejo, simplemente un rectángulo de fondo y dos TextBlock que servirán como opciones. Cada uno de estos últimos tiene un manejador de eventos igual, este evento debes colocarlo en tu code behind. [sourcecode lang='csharp']private void txtOpcion_MouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e) { this.Visibility = Visibility.Collapsed; } Listo, ese es el menú, ahora solo compila el proyecto para poder hacer reconocible el control que acabas de crear, al haberlo hecho ve a tu MainPage y primero [...]

Outlook als GTD Applikation

Mario Priebe — 2012-04-18T09:05:57

GTD steht für Getting Things Done und beschreibt Methodiken, seinen täglichen Aufgaben produktiv und effizient zu erledigen. Lesenswerte Artikel zum Thema GTD stehen am Ende des Tutorials. Zieldefinition Ziel ist es, im Outlook ein Dashboard bereit zu stellen, welches einem alle Aufgaben, den Posteingang, den Kalender, Notizen und die Kontakte anzeigt. Das Besondere dabei ist, [...]

Using Parallel.ForEach To Aggregate Results From JSON Files Stored in Windows Azure Blob Storage

Karsten Januszewski [MS] — 2012-04-18T00:24:35

I love NoSQL, except when it comes to reporting. Then I miss those handy SQL aggregation calls. I recently had a situation where I needed to look at a whole bunch of JSON files stored in Windows Azure Blob Storage and aggregate values from within those JSON files. The exact scenario was to get a count of how many people had achieved each achievement as part of the Visual Studio Achievements project.

Turned out to be an ideal use case for using some of the parallel programming features in .NET 4.0. Rather than download and process N JSON blobs linearly, I could throw the loop in a Parallel.ForEach block and gain speed from the multi-core machine I was using. The code was pretty straightforward, especially once I discovered the System.Collections.Concurrent namespace with its handy ConcurrentDictionary.

And, most significantly, it increased performance by 400 percent!

Below is the code in it’s entirety; I’ll walk through it here:

For JSON deserialization, I’m using a library provided by the WCF team up on CodePlex which is now part of the ASP.NET Web API. It provides some nifty features for turning JSON into dynamic objects.

The first thing I do is download a JSON file that has all the achievements, which is publically available (line 25).

I then put all the achievements in a ConcurrentDictionary<string, int> which I’ll use to build my report (line 33).

Then, I get the blobs and start my Parallel.ForEach loop (line 41). Inside the Action(TSource), I walk the list of the user’s earned achievements, incrementing the count in the ConcurrentDictionary of each achievement (line 57).

Finally, once I exit the loop, I turn the dictionary into an Excel spreadsheet (line 69) – folks tend to like that format.

You’ll notice the remmed out code; that’s the old non-parallelized code if you’d like to compare.

 1 using System;
 2 using System.Collections.Concurrent;
 3 using System.IO;
 4 using System.Json;
 5 using System.Net;
 6 using System.Threading.Tasks;
 7 using Microsoft.WindowsAzure;
 8 using Microsoft.WindowsAzure.StorageClient;
 9 
10 namespace AchievementsReporting
11 {
12     class Program
13     {
14 
15         static void Main(string[] args)
16         {
17             var cloudBlobClient = new CloudBlobClient(new Uri("https://---.blob.core.windows.net", UriKind.Absolute),
18                                                       new StorageCredentialsAccountAndKey("---",
19                                                                                           "---"));
20             var container = cloudBlobClient.GetContainerReference("users");
21 
22             string masterJson = string.Empty;
23             using (var webClient = new WebClient())
24             {
25                 masterJson =
26                     webClient.DownloadString(new Uri("http://channel9.msdn.com/achievements/visualstudio?json=true"));
27             }
28             dynamic masterList = JsonValue.Parse(masterJson);
29             var statisticsDictionary = new ConcurrentDictionary<string, int>();
30             //var statisticsDictionary = new Dictionary<string, int>();
31             foreach (var achieve in masterList.Achievements)
32             {
33                 statisticsDictionary.GetOrAdd(achieve.Name.ToString(), 0);
34                 //statisticsDictionary.Add(achieve.Name.ToString(), 0);
35             }
36             BlobRequestOptions options = new BlobRequestOptions();
37             options.UseFlatBlobListing = true;
38             options.BlobListingDetails = BlobListingDetails.Snapshots;
39             Console.WriteLine("Starting...");
40             DateTime start = DateTime.Now;
41             Parallel.ForEach(container.ListBlobs(options), blobListItem =>
42            //foreach (var blobListItem in container.ListBlobs(options))
43                     {
44                         CloudBlob blob =
45                             container.GetBlobReference(
46                                 blobListItem.Uri.AbsoluteUri);
47                         string json = blob.DownloadText();
48                         if (!string.IsNullOrEmpty(json))
49                         {
50                             dynamic achievementsDynamic =
51                                 JsonValue.Parse(json) as dynamic;
52                             foreach (
53                                 var achieve in achievementsDynamic.Achievements)
54                             {
55                                 if (achieve.DateEarned != null)
56                                 {
57                                         statisticsDictionary[achieve.Name.ToString()] =
58                                             statisticsDictionary[achieve.Name.ToString()] + 1;
59                                 }
60                             }
61                         }
62                     }
63                 );
64 
65             using (StreamWriter writer = new StreamWriter("report.xls"))
66             {
67                 foreach (var key in statisticsDictionary.Keys)
68                 {
69                     writer.WriteLine(key + "\t" + statisticsDictionary[key].ToString());
70                 }
71             }
72             TimeSpan diff = DateTime.Now - start;
73             Console.WriteLine("done - took: ");
74             Console.WriteLine(diff.TotalMinutes);
75         }
76     }
77 }
78

Mobile Web Apps : les bonnes pratiques

Olivier Dewit — 2012-04-17T21:46:00

Encore une bonne session du W3C aujourd'hui au www2012 pour présenter les bonnes pratiques du développement d'applications Web mobiles avec HTML5. D'ailleurs, la variété des formats d'écrans est telle aujourd'hui que ces conseils s'appliquent au développe...

Workaround for CA0055 Error with Silverlight Projects in Visual Studio 2010

Pete Brown — 2012-04-17T21:07:46

This connect bug describes an issue with creating certain types of Silverlight projects in Visual Studio. If you're referencing Silverlight 4 DLLs from a Silverlight 5 project, you may run into this code analysis/FXCop issue yourself if code analysis is part of your process. The core of the problem is a versioning decision in Silverlight 5 which results in compile-time violation due to loading two different versions of mscorlib in the same project. It manifests as the following error:

Error 2 CA0055 : Could not unify the platforms (mscorlib, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e, mscorlib, Version=5.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e) for 'MyProject.Silverlight\obj\Debug\MyProject.dll'.

More information on CA0055 may be found on MSDN.

How to Reproduce the Issue … in theory

In theory, all you need to do to reproduce the issue is reference a SL4-targeted DLL from an SL5 application. However, in practice, there are other factors in play. For example, it may matter which mscorlib version gets loaded first.

These steps won't repro the problem on my installation, but I'm putting them out here in case they help you visualize the issue (and also because I had already written them up when I realized they don't repro here -- I don't want all these bits to go to waste).

Create a Silverlight 4 class library. Make sure you target Silverlight 4. I named mine SL4ClassLibrary. The actual code is unimportant, but I set it to the following:

namespace SL4ClassLibrary

{

    public class Class1

    {

        public string Foo = "Bar";

    }

}

Next, add a Silverlight 5 Application project. Make sure it targets Silverlight 5. Here's what my solution looks like:

Build the solution.

Next, add a File Reference (not a project reference) from the Silverlight 5 client app to the Silverlight 4 DLL.

If you build it now, everything works fine. The key step here is to add code analysis. Many organizations have code analysis as a required part of their build process, using the compiler command-line arguments. If you don't, you can turn it on via the menu:

Then check the "Enable Code Analysis on Build" checkbox.

Now build the solution. In theory, you'll get a CA0055 error, but as I mentioned at the top, that doesn't happen on my install. Most of the people who have reported this issue on the connect bug have mentioned it in the context of the Business Application Template or third party controls.

Remember, this is a code analysis compile/build issue, not a runtime issue, so if you get past compiling your application, you're good.

The Workaround

This is already planned to be fixed in Visual Studio 11 RC. However, we do have a manual workaround for this to help you continue working if you're running into this scenario today. This will unblock using FxCop in Visual Studio 2010.

A high level walkthrough of how this works from the command line is:

We will tell FxCop which version of the runtime it will be using by pointing it to Silverlight 5's installed mscorlib.dll using the /platform argument
Tell FxCop where to find all of the referenced assemblies using /d (short for /directory) arguments: Use as many /d:<folder> arguments as necessary for FxCop to find all of the referenced assemblies.
Use either /console to tell FxCop to output the results to the console window, or /out:<file> to tell FxCop to write the results to an .xml file

To run FxCop from the command line for a default Business Application:

Add the %Visual Studio Install Directory%\Team Tools\Static Analysis\FxCop folder to PATH
Run "fxcopcmd.exe /file:<SL Business Application binary> /platform:<SL5 Reference Assemblies Directory\mscorlib.dll> /d:<SL4 Reference Assemblies Directory> /d:<SL4 SDK Client Libraries Directory>"

An example of what this looks like on an x64 operating system with all of the default install directories is:

SET PATH=%PATH%;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop
fxcopcmd /file:BusinessApplication1.dll /platform:"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\Silverlight\v5.0\mscorlib.dll" /d:"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\Silverlight\v4.0" /d:"C:\Program Files (x86)\Microsoft SDKs\Silverlight\v4.0\Libraries\Client" /out:results.xml
NOTE: If you receive a CA0001 error: "The following error was encountered while reading module 'XXXX.YYYYY' : Assembly reference cannot be resolved…" this means that you need to find where that assembly is installed to on your machine and add an additional /d:<installed directory> argument pointing FxCop to where those assemblies are installed.

My thanks to the Silverlight Team and to Andrew Hall for the information on this workaround.

Of course, the easiest and best solution, if you can do it, is to use libraries that specifically target Silverlight 5, and make sure all references from your Silverlight 5 project are to libraries targeting Silverlight 5. We know that's not possible in all cases, including the specific reported business application case, which is why we documented this workaround.

Handle Feature Reductions

Windows Phone Dev Blog — 2012-04-17T18:28:00

The third of the four principles I mentioned in Optimizing Apps for Lower Cost Devices is Handle Feature Reductions.

With the Windows Phone 7.5 Refresh, we refactored the OS in several areas to reduce memory usage and free up more RAM for apps. Part of this exercise included assessing the memory usage of features in the developer platform and assessing which, if any, we could afford to live without.

To free up the most RAM while also being as minimally disruptive as possible, we disabled generic background agents (PeriodicTasks/ResourceIntensiveTasks).

On today’s devices, users can disable background agents for an app manually via the Settings control panel, and the system can disable background agents for an app if the maximum number of supported background agents is exceeded. These conditions are surfaced to the app via an InvalidOperationException which the app must handle. On 256MB devices, the app receives the same InvalidOperationException received in the maximum exceeded case above when trying to schedule a background agent (since the maximum number of supported background agents is 0). This means if an app is written today to handle the maximum exceeded case, it will continue to work on 256MB devices unchanged. Make sure your apps handle this exception path and degrade gracefully when these features are unavailable. This will benefit your app experience both on today’s generation of devices as well as on new lower cost devices. The 256MB emulator introduced in the WPSDK 7.1.1 enables you to easily test this code path.

If you're using PeriodicTasks today to power your live tiles, there are a few options available to you. The first option is to switch to push notifications. A second option is to create ShellTileSchedules to update your tiles with remote images. A third option is to leverage the ShellTile API's from your foreground app to update your tiles whenever the app is launched. While technically the tiles wouldn't be live in this last case, the content would be refreshed, which can give the impression of live tiles. If you allow users to flag content, for instance, you could turn your tiles into a permanent reminder space and update them to reflect the most recently flagged content (or toggle through flagged content with every app launch). If these options aren't feasible for you, then you can still always take advantage of secondary tiles to provide convenient access to deeper experiences in your apps.

In addition to PeriodicTasks and ResourceIntensiveTasks being disabled, the lower cost 7x27a chipset itself has reduced media playback capabilities that may impact playback of some of your content. Attempting to playback unsupported content on the device will result in either (1) a "Sorry, we can't play this file on your phone" error, if played via the MediaPlayerLauncher, (2) a MediaFailed event if played via MediaElement, or (3) suboptimal video playback in some cases. While most apps in our testing during the Windows Phone 7.5 Refresh were not impacted by these reduced capabilities, you may be impacted if you do exceed them. Be sure to understand the new baseline and encode your content to work well across all Windows Phone devices. To conditionally offer higher quality vs. lower quality content depending on the device, leverage the MediaCapabilities.IsMultiResolutionVideoSupported flag. This flag will be false on devices with reduced media capabilities, so be sure to fall back to the baseline specs in this case.

While feature reductions are never ideal, these reductions bring with them an opportunity to reach a large new audience with your apps. Be sure to account for these reductions when targeting lower cost devices to provide the best possible experience to your users.

Free Microsoft Azure Trial for your application

Walt Ritscher — 2012-04-17T00:02:00

According to major vendors like Amazon and Microsoft, the cloud is our future. No matter what type of application, it could benefit from cloud storage, cloud DB or cloud services. I believe there is a lot of truth in these ideals. But no technology is perfect for every scenario. That’s why its cool that you [...]

XAML Snippets and Visual Studio

Walt Ritscher — 2012-04-16T22:25:58

Visual Studio has a long history of supporting Code Snippets on the Toolbox. You can drag a code chunk to the toolbox, and instantly have a reusable code resource. So easy. I’ve found that some XAML developers are not aware that this technique works with XAML blocks. It does. Select your XAML in the text [...]

www2012 : atelier HTML5

Olivier Dewit — 2012-04-16T21:51:00

A la conférence www2012 cet après-midi, Michel Buffa, enseignant à l'université de Nice, a animé avec des étudiants un atelier sur HTML5. Là encore, ce fut très intéressant. Au-delà des caractéristiques de base, l'accent était mis sur des fonctionnalités ...

Where to get .NET Gadgeteer and Netduino GO compatible 10 pin IDC sockets, and how to solder them

Pete Brown — 2012-04-16T21:58:12

When creating modules for the .NET Gadgeteer or Netduino GO, one of the harder parts to source is the 10 pin IDC socket. This is the tiny 1.27mm pin pitch socket you see on the boards.

Manufacturers will get those by the reel in most cases, directly from China. There are several places the average hobbyist can get them from:

Digikey Part 609-4054-ND. Quantities as low as 1.
Samtec Part SHF-105-01-L-D-SM (you need to use their part builder tool to specify this number). You can usually get them to ship you a 10pc sample order as well.
Through-hole version if you'd rather use it than the SMD version (large quantities only)
Community-provided parts (including sockets and cables). Valentin ordered by the reel and is selling them cheap.
GHI Electronics is selling them individually.
GHI is also selling them by the reel of 800.

All of these sockets are black. The Netduino blue sockets were a custom run by them, and so are not available to us mere mortals :)

Sockets may come in tape, tube, or loose. In a section of cut tape, it looks like this (purchased from community member Valentin):

Samtec tends to ship in tubes, and most sellers selling individual sockets will ship them in bags or loose. It looks like Digikey ships in tubes as well. It takes a fair bit of effort to unzip these and sell them individually, so expect to pay quite a bit more for small quantities.

A comparison of socket implementations

Although they are completely compatible for our purposes, there are some physical differences between the Samtec sockets and the other widely available sockets. The Samtec parts are more expensive, but for hand-soldering, they're friendlier. Why? Because they have a slight undercut or bottom bevel which makes it easier to get a soldering iron in to heat the pad and pin.

In the pictures below, the generic part is on the left, the Samtec part on the right.

You can clearly see the undercut on the Samtec part on the right. You can also see that the sides of the part extend down further than the body, enabling it to sit on the plastic and not just on the pin headers. This second feature is nice, but probably overkill for most modules. IOW, it's quality, but I'm not sure it's worth the price premium. The extra bump/key on the outside is helpful for positioning during assembly, but doesn't serve any mechanical purpose on an assembled Gadgeteer or Netduino GO board. All you need is the notch. Note that every commercial module and main board I've bought all use the more generic chinese parts.

The undercut is helpful, though. Just look at how much more of the pin it exposes to your iron.

So, if you are new to soldering, I recommend using the more expensive Samtec part. If you have a reasonable amount of soldering experience and/or can make the pad a little longer than the stock footprint (see next section), you can get the inexpensive sockets.

Techniques for designing and soldering the connector

For your own modules, I recommend making the size of the pads a bit longer than the specifications. This will take up a tiny bit more room on the board, but make it easier for you to get your iron. Below are the two profiles: default on left, my current one on the right. Note that I intend to adjust the hand-solder one a bit to make the pads longer so they come into the center a bit better. As they are right now, you can't get a fillet on the heel of the pins. That's hard to do anyway, but I want as strong a connection as possible.

When hand-soldering, first apply flux to all the pads. You may also want to apply flux to the pin bases on the socket -- it certainly won't hurt, especially if the pins look a little dirty/oxidized.

Step 1: Tin one pad

I recommend then tinning one pad in the corner with a little solder. You don't want a giant blob here. As long as you get the whole pad tinned, less is better.

Step 2: Install the socket

Then, holding the socket in place with your fingers (by the plastic), melt the solder to wet the one pin and hold the socket in place while applying downward pressure to make sure it seats flat. I used to tin all the pads, but I've found it much easier to tin a single pad. You're not looking to make an electrically sound connection here, just something to hold the socket flat.

If you need to adjust the position of the socket, make sure you completely melt the solder on that pad. If it's only half-melted, the leverage you have with the socket will rip up the pad. I did this once. Not good!

Look at the board edge-on and make sure the connector is seated flat and the pin is touching the pad, not suspended above it on a blob of solder.

Step 3: Secure the socket at the opposite corner

Then, once the socket is in the correct position and all pins are centered on the pads (or close) and sitting completely flat, solder the opposite pin to firmly hold the connector in place. Don't apply too much pressure, or you'll move the socket and possibly tear up the first pad you soldered. Once you get past this part, all the tricky parts are done.

Step 4: Solder the remaining pins (including the first one)

Then, solder each pin, including the first one you tinned. The pins are a bit chunky for drag soldering, so you really need to do one pin at a time.

I do this by using a relatively fine chisel tip on my iron. I touch the side of the pin along with the pad at the same time and then add enough solder to ensure a strong connection. Make sure you heat both the pad and the pin. You can see here how the larger pads really help with hand-soldering. If you have a larger tip, you will end up heating more than one pin at a time, but it will be more difficult to get the pads. In that case, apply a bit of downward pressure to try and transfer heat between the pin and the pad.

The sockets are pretty robust, but try not to touch the plastic with the iron. It's normal for flux to smoke a little, but you don't want that extra special kind of smoke that comes from burning plastic.

Step 5: Inspect and Check

I tend to use a little too much solder on these joints. You can use a bit less than what I have here. Getting a nice fillet with these sockets is hard, though. Even the commercial modules and main boards tend to have a bit too much solder here, so I wouldn't worry too much about it as long as the connection is sound and the solder isn't adhering to the plastic.

That's it! Visually inspect the board from a number of angles to make sure everything is soldered correctly and that there are no bridges. Using a multimeter, you can check each pin against some other connected part of the board to ensure continuity.

Coding Signing Internal Applications and a Gotcha

Karl Shifflett [MS] — 2012-04-16T21:25:42

This blog post explains one way to code sign your internal applications along with their installers. Code signing your applications and installers provide a UAC friendly user experience during installation, uninstall, and when your legacy applications may need to run with administrative privileges (more about admin privileges below). UAC Friendly Installation Experience The below image [...]

www2012 : tour d'horizon de CSS3

Olivier Dewit — 2012-04-16T19:36:00

www2012, la conférence internationale du Web, se tient cette année à Lyon . Et le 1er tutoriel W3C, animé par Bert Bos et Eva Kasal, était une réussite (malgré quelques problèmes de forme). Les caractéristiques de CSS3 y ont été présentées de façon dé...

Win 8 Page Navigation

Jesse Liberty [MS] — 2012-04-16T19:27:21

¡¡¡Normalízate!!!

Juan María Laó Ramos — 2012-04-16T01:00:31

¿Porqué respiramos? Respirar es algo normal que hacemos sin pensar. Parpadeamos sin darnos cuenta. Pues lo mismo debería pasar cuando vas a crear una tabla en una base de datos. ¿Cual es el primer campo que se añade a toda tabla? … Continue reading →

WPF-Blogger.com [Complete Feed]

Listbox, Why Art Thou Blanking?

Programming Windows 6th Edition Preview Ebook Is Here!

La “locura” de las optimizaciones en los juegos.

Primer camino para alcanzar el Nirvana del Garbage Colector

¿Veremos en The Windows Phone Developer Conference a WP Apollo?

MSDN Webcast series on building Metro style apps

Programming Windows 6th Edition Preview Ebook Coming!

Memory Profiling - The Heap Summary View

Heap Summary View

Summary

Silverlight 5.1.10411.0 Released Today

Más tiempo para Cell·APP Awards

Building Metro style apps with C++ event is now a live webcast

Teaching kids electronics, electricity, and logic using littleBits

Electronics and programming

littleBits

Logic

One issue with littleBits

Building your own bits

Yet Another Podcast #64–John Papa & Javascript

Jugando con el ApplicationBar en los elementos de una App Panorama

Delivering Rich Mobile Web Experiences in Windows Phone 7.5 (ESPN.com Case Study)

Neuerdings im Web (April 2012)

Nachlese zur Visual Studio 2011 Beta Roadshow

Symposium Session: Gadgeteering and the .NET Micro Framework

Visual Studio Achievements For Windows Azure Buzz

Four ways we’re improving Marketplace

Efecto “Gloss” de los iconos en iOS

CodeFluent Entities. Nunca el DDD fué tan fácil

GridView Control in Windows 8

Cell·SDK y el emulador de Android

Two Marketplace changes; An update on 9 new markets

Respond to User Input

Insidious ByRef Legacy Code Issue

Announcing the Building Windows 8 apps with C++ Windows camp

Agenda:

Buch: Perry Rhodan Neo 1 - Sternenstaub - Frank Borsch

2-4-6-8-10

Interaction Event-Trigger als Style auslagern

Maker Geek Roundup 011 for 4/21/2012

3d Printing, Laser Cutting, and CAD/CAM/CNC

.NET Gadgeteer and Netduino GO

Other .NET Micro Framework General (Netduino Classic, GHI FEZ, etc.)

Arduino

Other Microcontrollers (PIC, AVR, ARM, BeagleBoard, and more)

General Electronics and Hardware Hacking

Robots and Robotics Studio and *Copters

Synthesizers, Music, and MIDI

Photography

General Maker

Retro Computing and Commodore!

Wanted!! Great Windows 8 Metro style apps

Using a Style to Simulate TextTrimming on TextBox

Can this be true? MSDN subscribers ignoring $4K of free Azure services

Memory Profiling - Launching, Graphs and Markers

Launching the Memory Profiler

Stop Profiling

Memory usage graph

Image load markers

GC markers

Insight

Summary

Crear y manipular un menú contextual en Silverlight

Outlook als GTD Applikation

Using Parallel.ForEach To Aggregate Results From JSON Files Stored in Windows Azure Blob Storage

Mobile Web Apps : les bonnes pratiques

Workaround for CA0055 Error with Silverlight Projects in Visual Studio 2010

How to Reproduce the Issue … in theory

The Workaround

Handle Feature Reductions

Free Microsoft Azure Trial for your application

XAML Snippets and Visual Studio

www2012 : atelier HTML5

Where to get .NET Gadgeteer and Netduino GO compatible 10 pin IDC sockets, and how to solder them

A comparison of socket implementations

Techniques for designing and soldering the connector

Step 1: Tin one pad

Step 2: Install the socket

Step 3: Secure the socket at the opposite corner