WPF-Blogger.com [Complete Feed]

Two Outstanding Documentaries

Charles Petzold — 2013-05-17T21:00:00

In December 2008 — between the election of Barack Obama and his inauguration — the Bush administration decided to give a farewell present to the oil industry by selling off drilling rights on parcels of public land in Utah's pristine redrock area. A 27-year-old environmental activist and University of Utah student named Tim DeChristopher showed up at the auction, was asked if he had come to bid, said that he was, and was given a bidding paddle with the number 70.

... more ...

XAudio2 Performance and Battery Considerations for Windows Phone 8

Windows Phone Dev Blog — 2013-05-17T20:50:31

This blog post was authored by Joao Lucas Guberman Raza, a program manager on the Windows Phone team.

- Adam

In this post we cover important information for Windows Phone 8 developers who use the XAudio2 APIs, including best practices for battery performance. XAudio2 is a high-performance audio API available in Windows 8, Xbox 360, and Windows Phone 8. An app developer can use XAudio2 to create audio graphs in which they can treat each audio source in the graph as a distinct “voice.” The developer can apply different effects to each of the “voices.”

In Windows Phone 8, the XAudio2 engine must be aligned with the life cycle of the app. This means that if an app is suspended, the app that’s using XAudio2 must force the XAudio2 engine to stop. When the app resumes/rehydrates, if it is designed to resume sounds using XAudio2, it must restart the XAudio2 engine. Significant battery drain can occur if an app doesn’t stop the XAudio2 engine when the app is suspended, and the engine continues to run.

To avoid this scenario, an app must call IXAudio2::StopEngine when the app is suspended as described in the Native audio APIs for Windows Phone 8. When the app resumes, it should call IXAudio2::StartEngine. For Silverlight and Direct3D with XAML apps, the suspend/resume APIs are the Suspended and Activated events. For Direct3D native-only apps, the suspend/resume APIs are the Suspending and CoreView Resuming events.

The following code examples show you how you can do this in a pure native Direct3D app.

First create the XAudio2 object, which handles the XAudio2 sound APIs.
C++
1. IXAudio2* pXAudio = NULL ;
3. if( FAILED(XAudio2Create(&pXAudio, 0, XAUDIO2_DEFAULT_PROCESSOR) ) )
4. return false ;
6. if ( FAILED(pXAudio->CreateMasteringVoice( &pMasterVoice ) ) )
7. return false;
Then, on the suspending/resume events, set up the XAudio2 object to call StopEngine and then StartEngine. In the following example, we use the default events in the Windows Phone 8 SDK template for Direct3D native-only apps.
C++
1. void WindowsApp::Initialize(CoreApplicationView^ applicationView)
2. {
3. applicationView->Activated +=
4. ref new TypedEventHandler<CoreApplicationView^, IActivatedEventArgs^>(this, &WindowsApp::OnActivated);
6. CoreApplication::Suspending +=
7. ref new EventHandler<SuspendingEventArgs^>(this, &WindowsApp::OnSuspending);
9. CoreApplication::Resuming +=
10. ref new EventHandler<Platform::Object^>(this, &WindowsApp::OnResuming);
11. }
13. void WindowsApp::OnSuspending(Platform::Object^ sender, SuspendingEventArgs^ args)
14. {
15. pXAudio->StopEngine() ;
16. }
18. void WindowsApp::OnResuming(Platform::Object^ sender, Platform::Object^ args)
19. {
20. pXAudio->StartEngine() ;
21. }

With these steps, you can design your app to follow best practices for battery consumption when you use the XAudio2 APIs. It’s important to note that this is one of many best practices you can use in your app. To learn more, see also local folder best practices for Windows Phone, localization best practices for Windows Phone, and background agent best practices for Windows Phone.

Tips to grow your app revenue through in-app purchase

Windows Phone Dev Blog — 2013-05-16T19:28:18

Your Windows Phone 8 app presents three potential sources of revenue: app sales, in-app advertisement, and in-app purchases.

In a previous blog post I wrote about what you can sell in your Windows Phone 8 app by adding in-app purchase. You can:

Sell digital items.
Offer consumables (items that are used a set number of times per purchase) and durables (items purchased and then owned by the buyer).
Extend app features: add game levels, app features, and game currency, for example.

Today, I want to share recommendations and guidance to optimize the experience and effectiveness of in-app purchase in your Windows Phone app.

In-app purchase trends in the Windows Phone store

In-app purchase was added with the launch of Windows Phone 8 as a way to expand the value of apps and offer the possibility of additional revenue. It represents a growing revenue source in the Windows Phone Store: already 40% of the top 15 highest-grossing developers have apps that use in-app purchase.

Consumer adoption of in-app purchase varies by market, depending on regional trends, consumer preferences, and other regional differences. Central Europe, China, France, Middle East and United States are the markets where consumers purchased most in-app items, as a percentage of app downloads, compared to other markets.

In-app items are used in all categories of Windows Phone 8 apps in the Store. The categories with highest use of in-app purchase are Games, Tools and Productivity and Books & Reference. So in-app purchase can be used in all types of apps.

Use of in-app purchase by app category

Insight from the apps with highest in-app revenue

We analyzed the 30 apps and games with the highest in-app purchase revenue in the Windows Phone Store, and found some interesting trends, common characteristics, and best practices. Here’s what we discovered.

In-app purchase can add value to both games and non-game apps: the top grossing list includes 20 games (shooters, puzzles, racing, family, and other types of games) as well as 10 non-game apps (audio book, health/fitness, tools/productivity, navigation, and sports).

Start with a great app: All these top 30 apps are high quality, engaging apps with beautiful graphics and compelling sounds and music. All apps have 4-star ratings or higher, and user comments posted in the Store show that users love these apps, and therefore are willing to purchase the in-app items to enhance their experience. All these apps are easy to use and intuitive.

Use the ‘freemium’ business model: Most of these apps are free and offer in-app purchase extends the value of the app (90% of the apps are free and 10% are available in a paid version only). There are a few apps that are not free, and these apps are from developers with a brand name strong enough that users will know the quality or utility of the app. Very few of the apps, less than 5, use advertisement in the apps: most of these top developers focus only on in-app purchase to generate revenue.

Offer value even without purchase, and extend the app through in-app purchase: 28 of the 30 apps are useful even without in-app purchase. The apps provide great value even if no in-app purchase is used. In-app purchase is used to improve the app experience:

The games use in-app consumables to offer game currency, which in turn is used to purchase items in the game. Users can earn this currency through gameplay, or accelerate gameplay through purchase.
Non-games offer content through consumables and durables (audio books, book chapters, navigation maps, more sounds) or offer additional features through durable in-app purchase (for example additional features like online backup).
Three of the five apps that have ads use in-app purchase as an option for the user to remove the ads.
Two apps use in-app purchase to unlock the full version or new levels. These apps require in-app purchase to provide value beyond the introductory level or content.

Integrate in-app purchase seamlessly: The app developers use in-app purchase as a natural extension of the app, not as an afterthought. When using these apps, users feel that they are getting a significant additional value of value through the in-app purchase, and don’t feel forced to buy the app items to be able to use the app. In-app purchase is shown on simple, clear screens that show the value of what is being purchased, and frequently offer many options so the user can choose the best one for their budget and needs.

Make the app available also on Windows Phone 7: In-app purchase is only available on Windows Phone 8, so many of these top apps have created a XAP for Windows Phone 7 and a XAP for Windows Phone 8, to offer the app on Windows Phone 7:

10 of these apps are available for free on Windows Phone 7, providing the same functionality as the Windows Phone 8 versions, without in-app purchase. A few of these apps added mobile ads to provide ad revenue in place of the in-app revenue.
5 of these apps have a paid Windows Phone 7 version that offers the capabilities of the Windows Phone 8 version with all the in-app purchases.

Rebellion: Dredd vs Zombies and Guns 4 Hire

I interviewed Chris Kingsley, CTO of Rebellion, to understand more about their Windows Phone games and how they use in-app purchase. Rebellion has two shooter games on Windows Phone: Dredd vs Zombies and Guns 4 Hire. Both games use in-app purchase, and are among the highest grossing free Windows Phone games.

Rebellion makes games for many platforms, including PC games and Windows Store games. Chris shared with me the principles that he thinks have made in-app purchase successful in their Windows Phone games:

The game has to be great.
The game has to be designed with in-app purchase from the ground up.
The game has to balance free versus paid content.
Test, test, test, with as many people as possible.

Dredd vs Zombies was designed for in-app purchase from the ground up: the game is playable from beginning to end without in-app purchase. In-app purchase is used to sell credits that are used to purchase items that make the game more fun and which accelerate leveling up.

The items are designed so they genuinely feel like they are part of the game, and they provide a better play experience.

Dredd also offers items to try out, so players can get a feel for the game items that can be purchased. This also helps increase player engagement.

Guns 4 Hire offers a variety of in-app purchase items. The player has different options to choose from, and isn’t required to purchase to play the game.

The game shows the items for purchase in a very effective way: a large display for each item, a price, and a short and clear description of what you get with the purchase.

Chris from Rebellion mentioned they have another game coming up this month for Windows Phone – Zombie HQ – which builds on the shooter template by allowing players to customize their own HQ between missions.

Adding in-app purchase to your app

In-app purchase can enhance the app experience and increase your revenue, so if you think that you have a great app or game that is a good candidate for in-app purchase, add it today! Here’s how to get started:

Understand what can be sold through in-app purchase and how to add it.
Define how you would add in-app purchase to your Visual Studio project:
- Add it to an existing Windows Phone 7 project (through reflection) or create a new Windows Phone 8 project that uses in-app purchase natively.
- Offer a trial/paid version for Windows Phone 7 users.
Add the in-app purchase to your code.
Add the in-app purchase items through Dev Center.
Test using the different available testing techniques, and share the game with as many users as possible to polish the in-app purchase experience.
Publish your app in the Store!

Please post your feedback or questions about in-app purchase.

[Evento CartujaDotNet] Wave Engine

Juan María Laó Ramos — 2013-05-15T12:12:16

Imagina que quieres hacer un juego, pero sólo quieres programarlo una vez y desplegarlo en la mayoría de plataformas posibles. Deja de soñar y aprende a usar Wave Engine y podrás desplegar tus juegos en iOS, Android, Windows 8 y Windows Phone. Los grandes Marcos Ligthyear y David Woody nos enseñarán todo lo necesario (y quizás [...]

Yet Another Podcast #98–Jeff Fritz and ASP.NET, HTML5, more…

Jesse Liberty [MS] — 2013-05-14T21:29:12

Don’t Just Read “The Great Gatsby”

Charles Petzold — 2013-05-10T14:00:00

Something like the fifth movie version of The Great Gatsby is opening today, but it's silly to actually go see such a thing. The novel itself is quite short. You can probably read it in less time than it would take to go and see the movie, and you'll emerge from the experience much more fulfilled and satisfied because you'll have read F. Scott Fitzgerald's original novel rather what appears to be — at least judging from the trailers — a crazed 3D monstrosity by Baz Luhrmann.

... more ...

Latest Windows Phone app submission improvements

Windows Phone Dev Blog — 2013-05-10T20:12:43

As Todd mentioned in his post last week, I’d like to share some details about the latest improvements we’ve made to Dev Center to address your feedback.

Multiple XAP management during app submission

As more developers update their apps to take advantage of new Windows Phone 8 functionality, managing multiple XAP files for a single app becomes an increasingly common scenario. Many apps have different XAPs for Windows Phone 7.x and Windows Phone 8.0. Dev Center allows each to be serviced independently. Many of you asked for a simplified way to manage XAPs, so we set out to streamline the experience, make it easier to keep track of which XAPs exist for your app, and to clearly identify which XAP you’re acting on when you make a change. Here’s the new UI for managing XAPs in an app submission:

When you update an existing app, you’ll see that all of the XAPs for your app are already present in the submission. You can replace or delete one or more of the existing XAPs, add new ones, or leave them unchanged. Typically you’ll only want to add a new XAP when you’re either submitting a new app or adding support for a new platform version to an existing app. (For more details, see Guidance for app management for Windows Phone). Be careful when you delete a XAP in a submission because it will be removed from your app and no longer available in Store after the submission is published. You can think of this table as showing all XAPs that will be available for your app when the submission is published.

After you’ve established the XAPs that you want for your app, you can select each XAP individually by clicking the button beside its name, and then add/edit the Store listing info for each language that the XAP supports.

MPNS certificate management

To use authenticated push notifications from the Microsoft Push Notification Service (MPNS), your app needs to be associated with the authentication certificate that’s used by your service. You can manage certificates at an account level in Dev Center and then choose from those certificates when you submit a new app or update an existing app.

We’ve refreshed the certificate management UI to make it easier to see all of the certificates that you’ve uploaded, and to differentiate between them:

We’ve also updated the certificate selection UI on the App info submission page to help you select the correct certificate. Remember that if you’re updating an app to associate it with an updated certificate, MPNS requires that the Subject Name CN value remains the same. Dev Center will enforce this restriction to ensure that push notifications continue to work after your update is published.

Review submission

When you create a submission for a new or existing app in Dev Center, that submission will remain until you submit or delete it. This means that you can make changes to a submission on different days and from different browser windows and we’ll keep track of them. This can be a powerful feature as you don’t have to worry about losing changes by closing your browser or switching computers. However, this also makes it important to check your work before final submission to make sure you’re aware of all of the changes. We’ve created a new review page to help you do just that. Now you’ll have the opportunity to check the review page for a submission to be sure you are satisfied with the changes that you’ve made before you submit your app. Here’s an example:

The review page is organized into three sections:

Submission: Displays the publish option chosen, along with errors and warnings if applicable.
App: Displays the changes made at the app level. By default, this section shows only the changes you made, but you can clear the Only show changes I made box to see the full summary.
XAPs: Displays a list of XAPs that will be published for your app.

Here’s how the page looks if you choose to see the full summary of app-level information:

We made these changes to enhance your experience with Dev Center. As always, please keep adding your feedback to the Windows Phone Dev Center UserVoice forum. We appreciate hearing from you and your feedback helps us shape future development priorities.

Inside Windows Phone – Windows Phone and HTML5

Windows Phone Dev Blog — 2013-05-09T20:41:20

This blog post was authored by Matthias Shapiro, a technical evangelist at Microsoft.

- Larry

One of the exciting things and lesser known features in Windows Phone development is how it’s the perfect place to develop apps using HTML5. Jeff Burtoft, an HTML5 technical evangelist with Microsoft, joins us this week to talk about the flexibility and cross-platform power of HTML5 in Windows Phone. The in-depth example that we cover in the video is a project called YetiBowl, a standards-compliant HTML5 game that runs flawlessly on the web, as a Windows 8 app, and as a Windows Phone 8 app. For more information, see Developing in HTML5 and Javascript for Windows Phone.

Back in Israel after 40 years

Jesse Liberty [MS] — 2013-05-05T15:20:39

Testing your Windows Phone app – Part 1

Windows Phone Dev Blog — 2013-05-03T22:44:27

This blog post was authored by Craig Horsfield, a Senior SDET on the Windows Phone Test and Operations team.

- Adam

Testing your app throughout the development process helps to ensure that your app has a high level of performance and quality. Testing also helps to make sure your app is effectively represented in the Windows Phone Store. A small investment in the key areas described in this post can give your app positive results in your market, and help bypass common errors early in the development process. This document will outline testing approaches for key test areas that you should consider.

Beta testing

After you have thoroughly tested your app using the emulator and on a Windows Phone device, it’s important to also test your app as a beta app. Submit your beta app for beta distribution, where you can continue to test your app based on the beta and code flow experience. Additionally, you can include beta tester to help review your app. For more info, see Beta testing your app and in-app products.

Installation and launch

Testing your app’s install and launch process is a vital area that can often be overlooked. By following these steps, you can minimize installation and launch issues that are not handled by your app. There are a few scenarios to consider when testing the initial launch experience and resume paths scenarios. One of these is the new Windows Phone 8 fast app resume scenario that a Windows Phone 8 app can opt into.

The following tests can help verify your app’s install, launch, and resume functions.

Test scenario	Details
1. Verify the app on the first launch.	Note any End User License Agreement (EULA) and any other one-time notifications that appear in the launch UI.
2. Reinstall the app.	Verify that all one-time notifications appear again on a subsequent install and launch.
3. Start the app, and then return to the Windows Phone Start screen.	Launch the app again from a Live Tile, or from the phone’s App list. · Verify the default scenario, in which the old app is terminated, and a new instance of the app starts. · For Windows Phone 8 apps, if the app uses fast app resume for Windows Phone 8, in which ActivationPolicy="Resume", then the app resumes instead of starting a new instance. Verify that the app returns to the correct page in the app.

Fast Application Switching (FAS) and tombstoning

When a Windows Phone app is moved to the back stack based on the app’s navigation history, the app is suspended. When the app resumes, it returns to the foreground. Apps on the back stack are tombstoned when there is resource pressure on the device. The exception occurs when running location-tracking apps in the background for Windows Phone 8. Windows Phone 8 location-tracking apps continue to run in this scenario. Your app needs to handle both of these cases, and you should test this function in your app. FAS occurs when the user leaves the app to go to Start, Search, or some other path based on the launchers and choosers you’ve used in your app to support navigation. For more info, see Multitasking for Windows Phone and App activation and deactivation for Windows Phone.

The following tests can help verify your app’s FAS and tombstoning functions.

Test scenario	Details
1. Test the phone’s Start button and Back button.	Launch the app, and then press the Start button to verify that the Windows Phone start page appears. Press the Back button to resume the app. Verify that the app resumes in the required time, and in the state it was in before you navigated away from the app.
2. Test the Camera button.	Launch the app, and then press the Camera button to verify that the camera starts. Press the Back button to resume the app. Verify that the app resumes in the required time (10 seconds) and that is in the state it was before you navigated away from the app.
3. Test locking the phone using the Power button.	Launch the app, and then press the Power button to lock the phone. Unlock the phone, and then verify that the app resumes in the required time, and that the app is in the state it was in before you locked the phone.
4. Perform the same test cases for FAS and tombstone state.	To force a tombstone path, in Visual Studio, in the project Properties windows, click the Debug tab, and then select Tombstone upon deactivation while debugging.
5. Test deactivating and closing your app.	Make sure the app doesn’t take too long to process the Application_Deactivated and Application_Closing events, so that the app can save its state correctly. Avoid doing a lot of work in the Application_Closing code path, because processing time and access to the UI thread are limited.
6. Test background execution of your app.	For continued background execution in location tracking apps, you’ll want to test the app’s RunningInBackground event handler. In addition to running the preceding tests, check for the following conditions: · Background execution occurs when the app enters the back stack. · Start the app and move it to the back stack and resume the app. Verify that the app was not suspended and that it continued to run.

App navigation

You should navigate all paths in the app to test its navigation. You especially want to be sure that your app exits and handles navigation interruptions as intended.

Test scenario	Details
1. Test the Back button.	Your app should exit when you press the Back button on the top most page.
2. Test navigation interruptions.	Your app should not try to initiate new navigation while your app is currently navigating. Test rapid navigations in the app, and navigating in the app while pages are loading.

Don’t throw unhandled exceptions to exit the app at a page that isn’t at the top of the page stack. Instead, navigate over the page by removing it from the back stack; you don’t want to display the page on the exit path, or call API available in Application.Terminate in Windows Phone 8 apps. This triggers an app crash, and a Watson error report. You might see the crashes indicated in the app reports available in the Store.

Launchers and choosers

Launchers in your Windows Phone app give users the ability to perform common tasks, such as launching the Bing Maps app, launching Media Player, or launching the Store or Marketplace. Launchers do not return data or status to your app. With a chooser, on the other hand, users can return data to your app. For instance, users can choose return info from the Contacts app. For all launchers and choosers, test your app to be sure the launcher or chooser works correctly, and that it doesn’t trigger related errors.

Test scenario	Details
1. Test navigating to and from the launcher or chooser.	In the app, navigate to the launcher or chooser. Immediately go back to the previous page or screen. The app should return to the page and state the navigation was initiated from.
2. Test the complete scenario when using the launcher or chooser.	In the app, navigate to the launcher or chooser. Complete the scenario, i.e., select a photo or send mail. When the action is completed, the app should return to the preceding app state.
3. Test FAS scenarios when navigating to a launcher or chooser.	Navigating to a launcher or chooser can triggers an FAS scenario. See the related section earlier in this post for additional test scenarios related to FAS.

UI and layout

You need to test to make sure all elements of your UI and their layout work as intended, and meet app submission requirements, such as supporting Light Theme and Dark Theme. Test each control you use in your app, and the overall appearance of your app on the phone.

The following tests will help verify your app’s UI and layout.

Test scenario	Details
1. Test your app in the Light Theme.	Ensure all text is readable and all UI is visible.
2. Test your app in the Dark Theme.	Ensure all text is readable and all UI is visible.
3. Test the UI for text clipping.	You may need to set the text to wrap or make other layout changes.
4. Test your Splash screen display.	If you use a splash screen in your app, verify that it’s visible when the app starts, and that it displays for the expected time.
5. Test each animation.	Ensure all animations are smooth. If they appear slow or stop unexpectedly, see if the app is doing excessive work on a background task or thread.
6. Test each screen orientation.	Verify that the layout looks as you intended in portrait and landscape orientations, and that each page can display and move between orientations.

In part 2 of this series, we’ll discuss additional areas and testing approaches to consider related to push notification; Live Tiles; background agents; media, audio, and video; geolocation, and resource usage and performance.

Expanded developer opportunity – new payout markets and billing connections

Windows Phone Dev Blog — 2013-05-03T18:02:00

We continue to take steps forward on the path to establish a Windows Phone ecosystem characterized by quality, scale, and developer opportunity. We are seeing strong results for the ecosystem since the launch of Windows Phone 8 with more than a 100% increase in app downloads and nearly 140% increase in paid app revenue. Today I have a few enhancements to announce that can help you expand your app distribution reach and revenue opportunities.

Diverse phone offering and distribution

Nokia’s Lumia 720 and 520/521 phones have just begun to ship across the globe, giving potential Windows Phone customers additional choices in form factor, phone capabilities, and price points. This review from CNET (Nokia Lumia 520 review: One of the best budget phones around) pretty much sums up the sentiment on the new device, stating the Lumia 520 packs an “impressive punch” both in terms of hardware quality and value for the money.

These phones will be available in new markets and distribution channels, given their budget-friendly pricing. In fact, this week the Nokia Lumia 521 paired with an offer from US mobile operator T-Mobile to make its debut on the popular US Home Shopping Network, a first for Windows Phone.

The industry continues to recognize Windows Phone steady growth. According to Kantar Worldpanel ComTech, Windows Phone has already increased its share of all smartphone sales by nearly 2% compared to last year and is attracting first-time smartphone buyers. With over half of the US market (and much of the world) still owning a feature phone, it’s likely many will upgrade over the coming year, which ultimately will contribute to growth for Windows Phone.

Six new developer payout markets

This week we will enable developer payout in 6 new markets via Dev Center bringing the total markets supporting developer payout to 122. The new markets include: Afghanistan, Iraq, Montenegro, Serbia, Timor-Leste, and Ukraine. Developers in these 6 markets will now be able to submit both free and paid apps to the Windows Phone Store to reach customers in 191 markets.

New Mobile Operator Billing Connections

We have added 15 new mobile operator billing partners since August 2012, bringing the total number of supported partners to 25 in 19 markets, surpassing Google Play. Mobile operator billing gives consumers a payment option with significantly higher conversion rates than credit cards. On average, an app developer earns 3x more per active user on a paid app published in a mobile operator billing-enabled market than a market that only supports credit card. We will continue to expand this footprint and you’ll be seeing many more connections in the near future.

Simplified app submissions

Finally, I want to point out that we continue to incorporate your feedback and streamline the app submission process. Recently the Dev Center team enabled cancelling submissions, rotating screenshots and automatic screenshot resizing – all items you indicated needed improvement. You can read more about these enhancements on the Windows Phone Developer blog. Next, we’ll add the ability to review your app submission, giving you a chance to make sure everything looks right, before you actually submit. I encourage you to watch for a post from Rushmi Malaviarachchi in the coming week that will provide details on all the latest improvements.

If you haven’t yet developed an app for Windows Phone or if you haven’t updated your app recently, I’d like to encourage you to visit the Dev Center to download the SDK and get started. There’s never been a better time to develop for Windows Phone.

Inside Windows Phone – Data binding

Windows Phone Dev Blog — 2013-05-02T22:48:33

Data binding is one of the fundamental concepts used for good Windows Phone application design, but can be difficult to grasp for newcomers. The core concept is this: No one wants to manually update the user interface elements. It’s best to have the UI automatically reflect the state of the application. Data binding helps us do this. We can work exclusively on our Windows Phone UI, bind the values in the UI and then work on the inner logic of the application knowing that all the updates are being reflected to the user. Because of the power in the model, as you see in this video, there are some really great "fringe" benefits in terms of interaction and design that we get, along with the core benefits. For more information, see Data binding for Windows Phone.

Getting Twitter Avatar Via C# With 1.1 API

Karsten Januszewski [MS] — 2013-05-01T20:23:26

If you know someone's Twitter handle and would like to display their twitter avatar on your website, here's some code to get the URL of their avatar. First, you'll need to register at http://dev.twitter.com and acquire a ConsumerKey, ConsumerSecret, Token and TokenSecret -- now that Twitter supports application only authentication, there isn't any handshaking involved; you just need to craft up the right OAuthCredentials for a ProtectedResource, which the Hammock library does for you. Love that library: you can get it here: https://github.com/danielcrenna/hammock or grab it as a NuGet package: http://nuget.org/packages/Hammock

Here’s the code; nothing too fancy:

using System;
using Hammock;
using Hammock.Authentication.OAuth;
using Hammock.Web;
using Newtonsoft.Json.Linq;

namespace ExternalServices
{
    public class TwitterAvatarLookup : ITwitterAvatarLookup
    {
        const string ConsumerKey = "";
        const string ConsumerSecret = "";
        const string Token = "";
        const string TokenSecret = "";

        public string GetTwitterAvatarUrl(string twitterHandle)
        {
            string avatarUrl = string.Empty;
            var request = new RestRequest
            {
                Credentials = new OAuthCredentials
                {
                    Type = OAuthType.ProtectedResource,
                    SignatureMethod = OAuthSignatureMethod.HmacSha1,
                    ParameterHandling = OAuthParameterHandling.HttpAuthorizationHeader,
                    ConsumerKey = ConsumerKey,
                    ConsumerSecret = ConsumerSecret,
                    Token = Token,
                    TokenSecret = TokenSecret,
                }
            };
            request.Path =
                string.Format(
                    "https://api.twitter.com/1.1/users/lookup.json?screen_name={0}&include_entities=0&include_rts=0",
                    twitterHandle);

            request.Method = WebMethod.Get;
            RestClient client = new RestClient();
            try
            {
                RestResponse response = client.Request(request);
                JArray jArray = JArray.Parse(response.Content);
                avatarUrl = (string)jArray[0]["profile_image_url_https"];

            }
            catch (Exception)
            {
                return "default.png";
            }
            return avatarUrl;
        }

    }
}

If you know more than one handle whose avatar you need to get, the API supports passing multiple user handles; see https://dev.twitter.com/docs/api/1.1/get/users/lookup

Yet Another Podcast #97–Chris Sells and the last 20 years

Jesse Liberty [MS] — 2013-04-29T20:26:44

Published 3rd Pluralsight Course: WPF For the Enterprise From Scratch

Jesse Liberty [MS] — 2013-04-26T19:35:13

Using the Windows Phone 8.0 SDK to localize Windows Phone OS 7.1 projects

Windows Phone Dev Blog — 2013-04-24T21:00:17

This blog post was authored by Dan Zucker, a program manager on the Windows Phone team.

- Adam

Here are the quick steps you need to take to set up a Windows Phone OS 7.1 Visual Studio project to use the techniques and features described in the blog posts Tips for Localizing Windows Phone 8 XAML Apps - Part1 and Tips for localizing Windows Phone apps – Part 2 to localize apps. Note that throughout these steps, you must replace <PROJECT_NAME_SPACE> with your project name.

Follow the steps in the Standard Localizing Steps section described in Tips for Localizing Windows Phone 8 XAML Apps - Part1 to make your single-language app ready for localization.
Update the <Application.Resources> node in the App.xaml file with the following code, where <PROJECT_NAME_SPACE> is replaced with your project name:
XAML
1. 
2. <Application.Resources>
3. <local:LocalizedStrings xmlns:local="clr-namespace:<PROJECT_NAME_SPACE>" x:Key="LocalizedStrings"/>
4. </Application.Resources>
The LocalizedStrings Application Resource, along with the LocalizedStrings class added in the next step provides a globally accessible means for your app to access its project’s localized resources. Although there are simpler ways to achieve that goal, the method described here provides the benefits of strong typing, including resource visibility in IntelliSense and compilation validation during coding.
Add a new class file named LocalizedStrings.cs to the project. Replace the existing code with the following, where <PROJECT_NAME_SPACE> is replaced with your project name:
C#
1. using <PROJECT_NAME_SPACE>.Resources;
3. namespace <PROJECT_NAME_SPACE>
4. {
5. /// <summary>
6. /// Provides access to string resources.
7. /// </summary>
8. public class LocalizedStrings
9. {
10. private static AppResources _localizedResources = new AppResources();
12. public AppResources LocalizedResources { get { return _localizedResources; } }
13. }
14. }
Search the entire project for localized string resources. Update the project namespace as needed by including the following code, where <PROJECT_NAME_SPACE> is replaced with your project name:
C#
1. using <PROJECT_NAME_SPACE>.Resources;
Add a folder named Resources to the project.
Add a new resources file named AppResources.resx file to the new Resources folder.

Add the language initialization resource strings ResourceFlowDirection and ResourceLanguage to AppResources.resx, as described in Tips for Localizing Windows Phone 8 XAML Apps - Part1. Typically, the value of the resource strings should be set to meet the traditional flow direction and locale of the neutral language (the one that a viewer of your app will see if they have selected a phone language that is not supported by your app).

Name	Value	Comment
ResourceFlowDirection	LeftToRight	Controls the FlowDirection for all elements in the RootFrame. Set to the traditional direction of this resource file's language.
ResourceLanguage	en-US	Controls the Language and ensures that the font for all elements in the RootFrame aligns with the app's language. Set to the language code of this resource file's language.

Change the access modifier of AppResources.resx to "Public" by using the Access Modifier drop-down list at the top of the resource editor.
Save and rebuild the solution.
Add the following references to App.xaml.cs, where <PROJECT_NAME_SPACE> is replaced with your project name:
C#
1. using <PROJECT_NAME_SPACE>.Resources;
2. using System.Threading;
3. using System.Globalization;
4. using System.Diagnostics;
5. using System.Windows.Markup;
Add the InitializeLanguage function and call to the constructor of the App.xaml.cs file. Include the following using statements to reference System.Threading and System.Globalization at the beginning of the file. Also, add the declaration for the appForceCulture global variable to enable the international testing feature described in Tips for localizing Windows Phone apps – Part 2.
C#
1. // . . .
2. public partial class App : Application
3. {
4. // Global variable to set app locale at launch for International testing
5. // An empty value causes the app to following users phone language culture
6. public static String appForceCulture = "qps-ploc";
8. /// <summary>
9. /// Provides easy access to the root frame of the phone app.
10. /// </summary>
11. /// <returns>The root frame of the phone app.</returns>
12. public static PhoneApplicationFrame RootFrame { get; private set; }
14. /// <summary>
15. /// Constructor for the Application object.
16. /// </summary>
17. public App()
18. {
19. // Global handler for uncaught exceptions.
20. UnhandledException += Application_UnhandledException;
22. // Standard XAML initialization
23. InitializeComponent();
25. // Phone-specific initialization
26. InitializePhoneApplication();
28. // Language display initialization
29. InitializeLanguage();
30. // . . .
Add the InitializeLanguage method to App.xaml.cs:

C#

// Initialize the app's font and flow direction as defined in its localized resource strings.

//

// To ensure that your apps font is aligned with its supported languages and that the

// FlowDirection for each of those languages follows its traditional direction, ResourceLanguage

// and ResourceFlowDirection should be initialized in each .resx file to match these values with that

// file's culture. For example:

//

// AppResources.es-ES.resx

//    ResourceLanguage's value should be "es-ES"

//    ResourceFlowDirection's value should be "LeftToRight"

//

// AppResources.ar-SA.resx

//     ResourceLanguage's value should be "ar-SA"

//     ResourceFlowDirection's value should be "RightToLeft"

//

// For more info on localizing Windows Phone apps see http://go.microsoft.com/fwlink/?LinkId=262072.

//

private void InitializeLanguage()

{

    try

    {

        // Change locale to appForceCulture if it is not empty

        if (String.IsNullOrWhiteSpace(appForceCulture) == false)

        {

        // Force app globalization to follow appForceCulture

            Thread.CurrentThread.CurrentCulture = new CultureInfo(appForceCulture);



// Force app UI culture to follow appForceCulture

            Thread.CurrentThread.CurrentUICulture = new CultureInfo(appForceCulture);

        }

        // Set the font to match the display language defined by the

        // ResourceLanguage resource string for each supported language.

        //

        // Fall back to the font of the neutral language if the display

        // language of the phone is not supported.

        //

        // If a compiler error occurs, ResourceLanguage is missing from

        // the resource file.

        RootFrame.Language = XmlLanguage.GetLanguage(AppResources.ResourceLanguage);

        // Set the FlowDirection of all elements under the root frame based

        // on the ResourceFlowDirection resource string for each

        // supported language.

        //

        // If a compiler error occurs, ResourceFlowDirection is missing from

        // the resource file.

        FlowDirection flow = (FlowDirection)Enum.Parse(typeof(FlowDirection), AppResources.ResourceFlowDirection,false);

        RootFrame.FlowDirection = flow;

    }

    catch

    {

        // If an exception is caught here it is most likely due to either

        // ResourceLangauge not being correctly set to a supported language

        // code or ResourceFlowDirection is set to a value other than LeftToRight

        // or RightToLeft.

        if (Debugger.IsAttached)

        {

            Debugger.Break();

        }

        throw;

    }

}

As the comments in the code explain, the InitializeLanguage method initializes the app's font and flow direction as defined in the localized resource strings.

As described in the blog posts Tips for Localizing Windows Phone 8 XAML Apps - Part1 and Tips for localizing Windows Phone apps – Part 2, when you add a language to your app using the Windows Phone 8.0 SDK, a resource file for that locale is created. In that .resx file, the ResourceLanguage and ResourceFlowDirection values are initialized for the locale of the language you added. When the app is launched, InitializeLanguage() uses the values of ResourceLanguage and ResourceFlowDirection to initialize the xml:lang and FlowDirection of the app’s Rootframe.

Typically the culture used by InitializeLanguage() is the culture the system chooses to most closely match to the user’s phone language setting. The appForceCulture clause allows you to override this with the culture of your choice, so that you can deploy and review your app in the language of your choice without the time-consuming process of changing settings or restarting the device or emulator. If you use this convenient method, don’t forget to also test the app to be sure that everything works as expected when you modify the Phone Language setting and reboot.

Yet Another Podcast #96–John Papa on SPA and Public Speaking

Jesse Liberty [MS] — 2013-04-22T12:47:00

31 días de Windows 8 | Día 16: Menú contextual

La Liga Silverlight — 2013-04-21T22:09:38

Este artículo es una traducción de “Día 16: Menú contextual” de Jeff Blakenburg. Puedes encontrar aquí la versión en inglés. Hoy nuestro foco es en menús contextuales. Estos son aquellos pequeños comandos que se muestran ocasionalmente en tu aplicación cuando das un clic derecho o algo similar. Microsoft ofrece una guía muy especial en cuanto al uso de menús contextuales y cuando usar un control de AppBar en su lugar y seguiremos estas reglas en este artículo. ¿Qué es un menú contextual? Si has usado Windows 8, probablemente los hayas encontrado. Comúnmente ellos se muestran al momento de dar clic derecho en algo que no puedas seleccionar o texto con el que quieras interactuar. Aquí hay un ejemplo de menú contextual: (imagen de: http://msdn.microsoft.com/library/windows/apps/Hh465308) Podrías también lanzar un menú contextual desde un elemento en tu página que no sea seleccionable como esta imagen en mi aplicación de ejemplo: Dar clic derecho en la imagen lanza el menú contextual a la derecha. (Te mostraré como hacer que esto suceda a continuación). Cada uno de los comandos tendrán una función asignada a ella, el cual es ejecutado cuando el elemento sea presionado. Determinando la ubicación de un elemento. Quizá hayas notado que [...]

Inside Windows Phone – code samples

Windows Phone Dev Blog — 2013-04-19T20:05:05

What Windows Phone code samples are available to you, and how do you get them? We publish a large number of code samples that cover a solid range of Windows Phone developer scenarios. In this video, we touch on some of the code samples we’ve created to help you design and develop great Windows Phone apps, and where to find them.

Here’s where you can find some of the Windows Phone code samples and resources we discuss in the video.

Matthias's blog post that highlights some awesome Windows Phone samples, and where to get them
The Windows Phone Dev Center samples page – the complete list of samples created by the Windows Phone developer content team, by developers for developers
The Lens sample (check out Lenses for Windows Phone 8 for an overview and walkthrough of how to build your Lens app)
The photo extensibility sample (see Photo extensibility for Windows Phone for more info about how to use the sample and how to create your app)
The Twitter search infinite scrolling sample using the LongListSelector control in Windows Phone (check out the topic on how to display data in a grouped list using LLS)
The People Hub LongListSelector sample, with jump lists (be sure to see the topic on how to display data in a grouped list using LLS for info about using LLS for this sample, too)
A speech recognition sample that covers using a custom grammar (see Voice commands for Windows Phone 8 for more info about how to use this feature in your app)

Please send us any questions or feedback – we’d like to hear from you.

Tweet to @LarryALieberman or @matthiasshap

Recovering a deleted site from IE Frequent List

Walt Ritscher — 2013-04-19T02:11:47

For those of you still using Internet Explorer. This is the page I see when I create a new Tab in IE. The other day I accidently click on the Remove this page button in the corner of one of the items on this page. Unfortunately, it was a link to a testing page I [...]

Facebook SDK for .NET - Featured in the Facebook Technology Partner program

Windows Phone Dev Blog — 2013-04-18T19:01:25

This blog post was authored by Sanjeev Dwivedi, a developer evangelist for Microsoft working with Facebook.

- Adam

Today we are pleased to share with you that Facebook has announced the Facebook SDK for .NET as part of the Facebook Technology Partners program. This is a C#/XAML–based SDK that makes integrating your Windows Phone and Windows 8 style apps with Facebook a breeze. The SDK is an open-source project owned and released by the Outercurve Foundation. The Outercurve website for the SDK is http://facebooksdk.net, which hosts tutorials for both Windows 8 and Windows Phone, and has links to the GitHub repository where the source is hosted.

You can easily integrate the SDK into your project using NuGet, which automatically downloads and installs the SDK in your project. To do this, launch the Package Manager Console from the toolbar:
Tools > Library Package Manager > Package Manager Console

Install the Facebook NuGet package as part of your app by running the following command:

Install-Package Facebook

The Facebook SDK for .NET makes your life easier by providing two key functionalities:

It takes away all of the complexity of logging on with Facebook. Based on the provided samples, all you need to do is use a bit of boilerplate code, add your Facebook app ID to the mix, and voila! You can have people logging on to your app with Facebook.
It allows you to focus on your Facebook-related scenarios by abstracting away the low-level details such as HTTP connections and query parameters. This way you can plan and develop around Open Graph APIs and objects, which is where you want to spend your development resources.

An added benefit of using this SDK is that it provides very similar APIs on both the Windows Phone and the Windows 8 platforms, so code-sharing between the two platforms becomes very easy. Here is a snippet that showcases retrieval of a Friends list from Facebook on Windows Phone. As you can see in the code example, setting up the client and making the call to retrieve your Friends list requires just a few lines of code. The rest of the code is your logic around picking the data that is of interest to you.

Code Snippet
 // Instantiate the Facebook client
FacebookClient fb = new FacebookClient("<Supply Access Token here>");
 
// Make the friends list Open Graph API request
var friendsTaskResult = await fb.GetTaskAsync("/me/friends");
 
var result = (IDictionary<string, object>)friendsTaskResult;
var data = (IEnumerable<object>)result["data"];
foreach (var item in data)
{
    var friend = (IDictionary<string, object>)item;
    // Pick out the properties from the dictionary without the need for writing deserializing classes
 
    string name = (string)friend["name"];
    string id = (string)friend["id"];
}
 

You can find more details about the SDK on the Outercurve Foundation website: http://facebooksdk.net/docs/. You can also follow the development of the SDK at its Facebook page, report any issues on Github issue tracker, and ask any follow-up questions on the StackOverFlow forum. For details about how to obtain an Access Token, see the Authenticate section in the Windows Phone tutorial.

The offerings and resources presented may be relevant to developers. However, this post is for informational purposes only and Microsoft is providing this information "as is" with no warranties. Each contribution is licensed to you under an agreement by its provider, not Microsoft. It is your responsibility to evaluate if these resources are suitable for your usage.

trello-burndown 0.8.0 verfügbar

Norbert Eder [MVP] — 2013-04-18T13:01:06

trello-burndown ist ab sofort in der Version 0.8.0 verfügbar. Es hat wieder zahlreiche Bugfixes, Anpassungen und Erweiterungen gegeben, die in diesem Beitrag näher beschrieben werden.

Weiterführende Informationen finden sich auf http://devtyr.github.com/trello-burndown/. Das Node-Modul kann auch via NPM installiert werden, Informationen siehe https://npmjs.org/package/trello-burndown.

Fehlerbehebungen

Der Sprint wurde einen Tag zu früh deaktiviert und konnte somit am letzten Tag nicht mehr aktualisiert werden
export und config Ordner werden nun beim Startup erstellt, sofern diese nicht existieren
d3.js wurde als NPM-Modul entfernt (Kompatibilitätsprobleme mit Node 0.10.x) und als statische Ressource eingebunden
Wurden Tasks an Tagen abgeschlossen, die nicht aktiv im Burndown angezeigt werden, dann wurden deren Werte nicht berücksichtigt.
Burndown-Chart wurde an die restlichen Charts angepasst

Features

Hover-Informationen in den Charts
Es werden nun mehrere Finished Lists unterstützt
Sprint-Ansicht wurde um eine Liste der offenen Punkte erweitert
Sprint-Ansicht wurde um die Anzeige der Statistik-Daten erweitert

Viel Spaß damit!

WLAN verliert unter Windows 8 ständig Verbindung

Norbert Eder [MVP] — 2013-04-17T20:53:30

Die WLAN-Verbindung auf meinem neuen Laptop verliert - wenn ich via Tethering online bin - laufend die Verbindung. Das ist durchaus nervig wenn man alle Minuten neu verbinden darf. Also muss dafür eine Lösung her. Insgesamt fallen mir hierzu zwei Möglichkeiten ein, die helfen können (wohl nicht müssen, aber wir werden sehen).

Energieverwaltung

Für einige Geräte besteht die Möglichkeit, dass der Computer unter dem Deckmantel der Energieverwaltung das jeweilige Gerät deaktivieren darf. Dies ist gerade bei Laptops die auf Akku laufen hilfreich um Ressourcen zu sparen. Dies kann jedoch unter Umständen zu ungewollten Verhaltensweisen führen. Um dies für die WLAN-Karte zu deaktivieren ist der Geräte-Manager zu öffnen und das Stück Hardware unter Netzwerkadapter zu finden. In den Eigenschaften findet sich nun die Lasche Energieverwaltung. Um eine Deaktivierung durch den Rechner zu verhindern ist der Haken von Computer kann das Gerät ausschalten, um Energie zu sparen zu entfernen.

Treiber aktualisieren

Hat die Änderung der Energieverwaltung nicht funktioniert, sollte überprüft werden, ob ein neuer Treiber zur Verfügung steht. Hierfür sind die selben Schritte, wie oben beschrieben, durchzuführen. Anstatt der Lasche Energieverwaltung ist hingegen die Lasche Treiber zu öffnen. Dies ergibt in etwa folgendes Bild:

Nun ist die Schaltfläche Treiber aktualisieren zu wählen. Man wird nun gefragt, ob automatisch nach einem Treiber (online) gesucht werden soll, oder aber am Rechner (so man bereits zuvor Treiberdateien herunter geladen hat). Hier ist die erste Wahl zu treffen. Wird ein neuer Treiber gefunden, ist dieser zu installieren. Natürlich kann es nun sein, dass kein neuer Treiber gefunden wurde. Dies bedeutet jedoch nicht, dass es keinen neuen gibt. Hierfür ist die Hersteller-Seite (in meinem Fall die Seite von Intel) aufzurufen und für die entsprechende Hardware nach einem Treiber zu suchen. Wie auf dem obigen Screenshot ersichtlich, ist die notwendige Information hierfür angeführt. Wichtig ist hier die korrekte Typbezeichnung und die aktuell installierte Version (hierbei ist darauf zu achten, ob es sich um 64-Bit oder 32-Bit System handelt - dies kann via System herausgefunden werden).

Die Treiber kommen im Normalfall mit einem Installer, der auszuführen ist. Etwaige Anweisungen sind zu befolgen.

Bei Intel ist mir aufgefallen, dass sich der Installer ohne Meldung verabschiedet. Ein kurzer Blick auf die Treiberversion hat jedoch gezeigt, dass der Treiber installiert wurde. D.h. dies vor Ausbruch einer Panik überprüfen :)

In meinem Fall hat es ein Treiber-Update getan - Problem gelöst, allerdings stellt sich mir die Frage nach der Aktualität der Treiberdatenbank von Microsoft. Liegen zwischen der ursprünglich installierten Version und der nun installierten doch über zwei Monate. Da würde ich mir gerade für den nicht technikaffinen Endverbraucher eine Verbesserung wünschen.

Defining your app’s requirements for a great customer experience

Windows Phone Dev Blog — 2013-04-17T20:30:48

One of the things I really enjoy about developing for Windows Phone is being able to reach a diverse audience across the globe. Windows Phone users access my apps on phones from different manufacturers, all with varying capabilities and price points to meet local needs. While I benefit from the diverse audience, it does take a little planning on my part to create a great user experience and to ensure that my apps comply with the Windows Phone technical certification requirements.

In this post I’ll help you identify the phone features and hardware your app requires, and then provide guidance on how define these needs in Visual Studio.

Capabilities and requirements

Windows Phone uses the app manifest file to identify the software capabilities, hardware required, and memory each app requires to run correctly:

Software capabilities: indicate that an app accesses the phone identity, camera, maps, media libraries, networking, Near-Field Communication (NFC), push notifications, sensors, wallet, web browser, and other software capabilities. Windows Phone grants access to these capabilities, and customers are informed before purchasing the app which capabilities are used.
Hardware requirements: indicate phone features that the app must have to function correctly. The operating system uses the list to prevent apps from being installed on phones that don’t meet these requirements.
Functional capabilities: indicate that your app is requesting more memory at run time, if it is available.

Your app must enable the relevant capabilities and hardware requirements

Make sure your app is not marking capabilities and requirements that it doesn’t need. Users see your app’s capabilities and requirements when they install the app, and may decide not to move forward with installation if they see that your app uses capabilities that they don’t want to enable, or that are not related to the purpose of the app.

In a scenario in which your app can provide value even when some hardware is absent, use API checks to first detect the presence of the hardware, and then to inform users if some features are disabled because of missing hardware.

The following steps explain how you can modify support for different Windows Phone capabilities in your app.

Open your project in Visual Studio, go to the Solution Explorer, and then in the Properties folder, open WMAppManifest.xml. Then, add or remove the capabilities as illustrated here:

Windows Phone 7 project

Windows Phone 8 project

Add hardware and functional capabilities to the manifest file

If the hardware or functional capabilities you need are not listed in Visual Studio, you must manually edit the manifest file. To do this, first understand all the capabilities available, and then edit the manifest file in a text editor, such as Notepad, or directly in the code. Right-click the file in Solution Explorer, click Open With, and then edit through Notepad or ‘view code’. You turn these on by adding the correct flag:

Requirement	Short description
ID_REQ_MEMORY_90	App requires at least 90 MB of RAM
ID_REQ_MEMORY_300	App requires at least 180 MB of RAM
ID_REQ_FRONTCAMERA	App requires the front-facing camera
ID_REQ_REARCAMERA	App requires the rear camera
ID_REQ_NFC	App requires a phone with NFC chip
ID_REQ_MAGNETOMETER	App requires a compass
ID_REQ_GYROSCOPE	App requires gyroscope to measure rotational velocity

Here’s an example of the manifest flag that shows the software, hardware, and functional capabilities:

Capabilities required when using the Microsoft Ad Control

If your app uses the Microsoft Ad Control, be sure to enable the following capabilities:

Windows Phone 7 Silverlight	Windows Phone 7 XNA	Windows Phone 8 project
ID_CAP_IDENTITY_USER	ID_CAP_IDENTITY_USER	ID_CAP_IDENTITY_USER
ID_CAP_MEDIALIB	ID_CAP_NETWORKING	ID_CAP_MEDIALIB_PHOTO
ID_CAP_NETWORKING	ID_CAP_PHONEDIALER	ID_CAP_NETWORKING
ID_CAP_PHONEDIALER		ID_CAP_PHONEDIALER
ID_CAP_WEBBROWSERCOMPONENT		ID_CAP_WEBBROWSERCOMPONENT

Additional considerations

In some scenarios, capabilities are added automatically. Here are some examples:

During debugging, when running the app in the Windows Phone Emulator, the Network Capability is set to ‘on’ by default. You should always test your app on a phone instead of on the emulator if your app uses any of the Windows Phone Software or Hardware capabilities, to ensure you are getting correct test results.
For Windows Phone 8 projects, it is your responsibility to ensure all the correct Software capabilities are identified and added to the manifest file.
For Windows Phone 7 projects, the submission process looks for software API calls and, if found, will add the Software capabilities to ensure that the app has the correct permissions to run.
Third-party libraries could make calls to some APIs, for example, to network or sensor APIs.

Having a variety of phones with different price points creates opportunities to reach out to more users. Take the time to set the correct information and get your app ready to be successful on a variety of Windows Phone devices.

How capabilities are displayed to Windows Phone users

The following table shows examples of how capabilities appear to consumers in the web Store and on the phone:

How capabilities are shown in app details page of an app on the Windows Phone web Store

How capabilities are shown in the app details page of an app on Windows Phone

Using the Store Test Kit (for Windows Phone 7 projects)

If your app targets Windows Phone 7.1, you can use the Store Test Kit to verify the capabilities that are being detected, to confirm they align with what you are expecting. The Windows Phone 8.0 SDK includes the Store Test Kit, and the Windows Phone 7 SDK requires you to install a stand-alone tool to run these tests.

Take the following steps to run the Store Test Kit for Windows Phone 7 project:

INSTALL AND START THE TEST KIT. Install and run the Store Test Kit. In the latest version of the SDK you can open the Store Test Kit directly from within your project: on the Project menu, click Open Store Test Kit.
RUN THE AUTOMATED TESTS. The Store Test Kit can detect and add software capabilities based on API calls for Windows Phone OS 7.x managed projects (not on native projects or Windows Phone OS 8.0 managed projects). Note You probably will need to update the test cases the first time you run the Test Kit, because we update them frequently. You can do this easily from the blue alert bar you might see across the bottom of the Test Kit window.

Use the Automated Tests tool to identify the capabilities that your app is using. Verify that these are the capabilities your app actually requires.

Windows Phone users appreciate having visibility into my app requirements, so that they can make an informed choice about downloading and purchasing your app. In the end, the user gets an app that performs well on their phone, and you get a better review for your apps. Everyone wins.

I’d like to hear from you. Please let me know your questions about defining capabilities, as well as suggestions for topics you’d like me to cover in future blog posts.

Windows Phone: Verbindung zu SkyDrive aufbauen

Norbert Eder [MVP] — 2013-04-17T15:57:19

Viele Windows Phone Apps ermöglichen das Arbeiten mit Dokumenten oder Daten die sinnvollerweise mit anderen Anwendungen geteilt werden. Vielfach kommt dabei Dropbox zum Einsatz und weit seltener SkyDrive. Dabei ist eine Integration mittlerweile recht einfach möglich. Dieser Beitrag zeigt was dafür notwendig ist und wie es funktioniert.

Im ersten Schritt wird das Live SDK benötigt. Darin enthalten sind Steuerelemente und Schnittstellen für den Zugriff auf SkyDrive via Single Sign On durch den Microsoft Account (vormals Windows Live ID). Nach der Installation sind zwei Referenzen einzubinden:

Wer gerne über die Toolbox arbeitet kann sich die Steuerelemente via Choose Items einbinden:

Hier ist dann (je nach zu Grunde liegender Version) der SignInButton zu wählen. Nach Bestätigung erscheint das Steuerelement in der Toolbox und kann dort praktisch ausgewählt und auf die View gezogen werden:

Berechtigungen

Für den Zugriff auf SkyDrive sind unterschiedliche Berechtigungen notwendig. Hierbei sind insgesamt 5 Scopes definiert, die jeweils mit einer unterschiedlichen Berechtigung ausgestattet sind:

wl.sigin: Single Sign On, d.h. ist der Benutzer bereits angemeldet, wird diese Session übernommen
wl.basic: Lesezugriff auf die grundlegenden Profilinformationen und der Liste der Kontakte
wl.offline_access: Benutzerprofil kann zu jeder Zeit gelesen und aktualisiert werden. Ist dieser Scope nicht aktiviert kann auf die Profilinformationen nur in eingeloggtem Zustand zugegriffen werden.
wl.skydrive: Lesezugriff auf Dateien
wl.skydrive_update: Lese- und Schreibzugriff auf Dateien

Alle verfügbaren Scopes können hier eingesehen werden. Die gewünschten Scopes sind bei Verwendung des SignInButton-Steuerelementes über die Eigenschaft Scopes anzugeben:

     <Controls:SignInButton Scopes="wl.basic wl.signin wl.offline_access wl.skydrive_update"/>

Damit der Zugriff grundsätzlich funktioniert, muss im Live Connect Developer Center eine Anwendung erstellt werden. Daraus resultiert eine ClientId, die in der gleichnamigen Eigenschaft zu setzen ist.

Es ist zu beachten, dass für den Zugriff mittels Windows Phone in den API-Einstellungen zur Anwendung im Developer Center diese als mobile Anwendung deklariert werden muss.

So sollte die Deklaration der Schaltfläche schlussendlich aussehen:

    <Controls:SignInButton Scopes="wl.basic wl.signin wl.offline_access wl.skydrive_update" SessionChanged="OnSkyDriveSessionChanged" ClientId="[ClientId]" Branding="Skydrive" TextType="SignIn"/>

Es gibt weitere Eigenschaften, die gesetzt werden sollten:

Branding: Das Icon und das Theme welches für die Schaltfläche gesetzt werden sollen. Im obigen Beispiel ist dies auf Skydrive gesetzt. Weitere Möglichkeiten sind Hotmail, Messenger und Windows.
TextType: Hierfür stehen unterschiedliche Varianten des anzuzeigenden Textes zur Verfügung. Eine Übersicht wird hier gegeben.

Verbindung aufbauen

Um eine Verbindung aufzubauen ist lediglich auf die angezeigte Schaltfläche zu klicken. Wie bei der obigen Deklaration zu sehen ist, ist ein Ereignishandler auf das Ereignis SessionChanged zu setzen. Dieses Ereignis wird ausgelöst, wenn es dahingehend eine Änderung gibt.

    if (e != null && e.Status == LiveConnectSessionStatus.Connected)

    {

        ViewModel.ConnectClient(e.Session);

    }

    else

    {

        ViewModel.DisconnectClient();

        if (e.Error != null)

        {

            // Error handling

        }

    }

Hier wird auf ein ViewModel verwiesen, welches in meiner Anwendung verwendet wird. Dieses stellt eine Methode ConnectClient zur Verfügung. Darin wird unter anderem folgendes vorgenommen um den Client zu initialisieren:

    private LiveConnectClient skydriveClient = null;

    public void ConnectClient(LiveConnectSession session)

    {

        this.skydriveClient = new LiveConnectClient(session);

    }

Ab nun können weitere Operationen ausgeführt werden. Eine genaue Beschreibung hinsichtlich Ordner und Dateien findet sich im Beitrag Working with Microsoft SkyDrive folders and files.

Hinweis: Sehr hilfreich ist das interaktive Live SDK. Darüber kann die API ohne echtes Setup kennengelernt werden.

Fazit

Mit Hilfe des Live SDK kann sehr einfach eine Verbindung zu SkyDrive aufgenommen werden. Die Verwendung selbst ist einfach, allerdings mit einigen kleinen Gemeinheiten deren Lösung an unterschiedlichsten Stellen allerdings gefunden wird.

Controlling a hardware prototype with your Windows Phone

Windows Phone Dev Blog — 2013-04-17T00:54:54

This blog post was authored by Erik Reitan, a programming writer on the Windows Phone developer content team.

- Adam

You’re already familiar with creating great apps for Windows Phone, and porting your apps from iOS or Android, but did you know that you can build .NET hardware prototype devices to integrate with your Windows Phone?

Using a prototyping platform for small electronic devices, such as .NET Gadgeteer or Netduino, you can create interesting hardware projects. Using C#, the .NET Micro Framework‎, and Visual Studio, you can develop your own hardware prototype and use the capabilities of your Windows Phone to interact with the hardware.

The following video shows how Matt @RogueCode used his Windows Phone to control a maze using Bluetooth and Netduino.

For more details about Matt’s project, read Greg Duncan’s Coding4Fun blog post on Channel 9.

Here’s another video that shows how Marco Minerva @MarcoMinerva used his Windows Phone to control a rover with Bluetooth and.NET Gadgeteer. Very cool!

For complete details about Marco’s project, see the related Coding4Fun blog post on Channel 9.

Here’s another video by Matt that shows how you can combined Windows Phone, Netduino, a sonar sensor, and Bluetooth for some interesting results.

For more details about Matt’s project, see the following Coding4Fun blog post on Channel 9.

Each of these Windows Phone projects provide the steps, code, and details necessary to build the project yourself, through the above links. Possibly, these examples could lead to your own hardware prototype. Let us know what you create.

A Data Binding to the Text Property of Run?

Charles Petzold — 2013-04-15T14:03:23

Sometimes a programmer will encounter a situation where it's convenient to embed a changeable data value in a paragraph of text, and for this paragraph to re-wrap itself when the text representation of this data value acquires a different character width.

... more ...

Team Foundation Services - Scrum-Template im Einsatz

Norbert Eder [MVP] — 2013-04-15T09:08:00

Im Beitrag “Team Foundation Services - Unterstützung für Git unter der Lupe” habe ich mich bereits mit den Team Foundation Services beschäftigt - genauer gesagt mit der Unterstützung für Git. Dieser Beitrag wendet sich nun der Scrum-Prozessvorlage zu. Die Team Foundation Services bieten mehrere Prozess-Vorlagen, für mich ist zum aktuellen Zeitpunkt jedoch nur die Scrum-Vorlage wirklich interessant. Zu den weiteren Vorlagen wird es daher in diesem Beitrag keine zusätzlichen Informationen geben. Dabei ist für mich von Interesse, welche Funktionalitäten diese Vorlage tatsächlich anbietet und wie der Umgang damit hinsichtlich Verwendbarkeit ist.

Im Menüpunkt WORK finden sich die Zugänge zum Product Backlog, zum aktuellen Board und der mir zugeordneten Work Items.

Product Backlog

Im Product Backlog können sämtliche User Stories verwaltet werden. Dieses ist sehr einfach gehalten und zeigt neben der Reihenfolge auch den Titel, den Status, den Aufwand, den Iterationspfad und gesetzte Tags an:

Die Spalten der Liste können nach eigenem Bedarf angepasst werden. Es stehen zahlreiche Möglichkeiten zur Verfügung:

Einträge können in dieser Liste der Drag & Drop verschoben und so die Reihenfolge angepasst werden. Über das Zeilenmenü kann ein gewähltes Element geöffnet werden um Detailinformationen erfassen zu können:

Die Möglichkeiten an dieser Stelle sind vielfältig. Erfasst werden kann:

Iteration
Zugewiesene Person
Status
Grund
Aufwand
Business-Wert
Backlog Priorität
Beschreibung
Storyboards
Testfälle
Aufgaben
Akzeptanzkritierien
Historie
Links
Anhänge

Bei der Eingabe von neuen Items wird eine Unterscheidung zwischen Backlog-Eintrag und Bug vorgenommen.

Auf Basis der eingetragenen Aufwände (Schätzungen whatever) kann auch eine Prognose erstellt werden. Diese ist in der Standardeinstellung deaktiviert, lässt sich jedoch durch einen einzigen Klick sofort aktivieren:

Im Standard wird eine Velocity (also Teamgeschwindigkeit) von 10 angenommen (in meinem Fall mit einer Person im Team des Tests). Dieser Wert kann entsprechend angepasst werden. Alle Backlog-Einträge werden daher entsprechend ihrer Reihenfolge in Sprints unterteilt. Dadurch ergibt sich natürlich auch eine schöne Sicht, wie viele Sprints für die gesamte Umsetzung des Backlogs benötigt werden.

Für das Product Backlog steht ebenfalls eine Board-Ansicht zur Verfügung. Diese zeigt die Einträge aus dem Backlog und ihren Status an:

Auch hier können die einzelnen Listen (Spalten) konfiguriert werden.

Auf diese Einstellungen sollte unbedingt ein Blick geworfen werden, da wohl nicht sehr viele mit einem vordefinierten WIP-Limit arbeiten wollen.

Sprints verwalten

Über das Kontextmenü oder aber das Zeilenmenü können einzelne Einträge bestimmten Iterationen zugeordnet werden (eine Mehrfachauswahl scheint nicht möglich zu sein). Die Änderung wird sofort im Product Backlog ersichtlich. Gleichzeitig wird der gewünschte Sprint aktualisiert. Ein mögliches Ergebnis kann wie folgt aussehen:

In der Headerleiste ist nun zu sehen, dass noch keine Sprintdaten erfasst wurden. Unter Set Date können nun das Start- und Enddatum des aktuellen Sprints gesetzt werden. Ebenfalls ist zu beachten, dass diese Liste eine weitere Ausprägung Capacity hat. Darunter können die Ressourcen für diesen Sprint geplant werden:

In diesem Beispiel ist schön zu sehen, dass die Ressourcen für die Umsetzung nicht ausreichen. Dies wird sofort zur Ansicht gebracht und kann für die Anpassung der Planung verwendet werden.

Eine Gesamtplanung der Releases und dazugehörigen Sprints ist auf der Overview unter dem Menüpunkt Configure schedule and iterations verfügbar. Dies sieht dann so aus:

In der ersten Liste besteht nun die Möglichkeit, jedem Backlog-Item Tasks hinzuzufügen, dies erfolgt über das + Icon. Die auszufüllenden Felder entsprechen denen eines Backlog-Eintrages, anstatt eines Aufwandes wird der verbleibende Aufwand eingetragen (diese erfolgen in Stunden):

Aus den vorhandenen Backlog-Einträgen und den dazugehörigen Tasks wird automatisch ein Board generiert:

Dieses zeigt übersichtlich den aktuellen Stand an und kann natürlich dazu verwendet werden, den Status der einzelnen Punkte zu verändern.

Eine für mich interessante Frage ist nun: Muss ich als Entwickler die Punkte im Board verschieben, oder funktioniert das auch direkt via Visual Studio. Der Vorteil läge natürlich darin, dass ich mein Hauptwerkzeug nicht verlassen muss. Ein weiterer Vorteil läge darin, dass dieser Schritt bei einer automatischen Durchführung nicht vergessen werden kann und das Board somit tatsächlich immer aktuelle sein würde.

Team Foundation Services via Visual Studio

Um nun mit den Work Items etc. der Team Foundation Services arbeiten zu können, ist das Service zu verbinden. Hierzu ist ein “Team Foundation Server” hinzu zu fügen. Die URL entspricht dem Link zum eigenen Workspace:

Im Anschluss ist das gewünschte Team Project auszuwählen:

Nun kann via Team - New Query eine Abfrage auf den aktuell geplanten Sprint vorgenommen werden:

Alle relevanten Work Items können damit abgegriffen werden.

Es werden automatisch Shared Queries angelegt, welche über Visual Studio abgegriffen werden können. Diese betreffen den aktuellen Sprint, d.h. eine obige Query muss nicht zwingend vorgenommen werden. Zu den Queries gelangt man via Team Explorer und Work Items.

Mit den Work Items kann nun direkt aus Visual Studio gearbeitet werden.

Änderungen werden nicht automatisch an ein Changeset gehängt, dies kann aber sehr einfach durch einen Link vom Work Item auf das jeweilige Changeset (oder mehrere) vorgenommen werden.

Alle gemachten Änderungen sind sofort online ersichtlich.

Fazit

An einigen Stellen hakt es schon noch ein wenig. So würde ich mir wünschen, dass sich ein Work Item automatisch an das jeweilige Changeset (oder an die Changesets) hängt. Auch die Git-Integration im Team Explorer braucht definitiv noch Verbesserungen hinsichtlich der Usability. Insgesamt lässt es sich aber ganz gut damit arbeiten. Jetzt fehlt noch ein Test mit einer Real-World-Solution und der Preview Funktionen hinsichtlich Build und Test Cases. Bis jetzt sehe ich jedoch keinen Grund der gegen die Nutzung der Team Foundation Services mit Git-Repository spricht.

TechEd India, the India developer communities, and the Taj Mahal

Pete Brown — 2013-04-15T07:07:41

In the second half of March, I traveled to India (Bangalore, Delhi, and Pune) to speak at TechEd India and TechDays Delhi about Windows 8 app development.

I flew from Dulles International in VA to Charles De Gaulle in France, where I met up with my colleague Nisha Singh, who had flown from Seattle. From there, we flew Air France to Bangalore for TechEd India Bangalore, then hopped a Jet Airways flight to New Delhi for TechDays Delhi. While there, I took a car to Agra over the weekend (more on that shortly). Then another Jet Airways flight from Delhi to Pune for TechEd India Pune. And finally, a short flight from Pune to Mumbai before the 16 1/2 hour flight from Mumbai to Newark NJ, and the prop plane from Newark to Dulles.

What I had expected

Before I went away to India, my only experience with developers in India was the lowest-price outsourcing companies I often had to clean up after as a consultant, the outsourced call center tech support folks I'll sell a kidney to avoid, and the numerous "send me the codes" emails I get. So, I had some pre-conceived notions as to what to expect from the developer community.

I'm happy to say I was completely wrong.

The developer community in India is strong, professional, and enthusiastic. The people I met at TechEd India were serious developers, building awesome apps and the usual bevvy of line of business apps internal to companies. The developer community in Pune, for example, is huge. The Pune .NET user group community (PUG) has membership in the mid 4 digits. Yep. That's pretty big. I was lucky to have been able to meet with the leads (my flight was delayed, so I arrived at the hotel just in time.)

Photo by Vikram Pendse

TechEd and TechDays

TechEd India covered Bangalore and Pune. TechDays India happened in Delhi in between the two.

These events are smaller than TechEd US and TechEd Europe, but the production values are just as high, with even a few extras thrown in. A couple years ago, a monkey snuck in the back door of an event hall and perched on top of the screen, watching the demos. The original code monkey :)

Here's the keynote hall for TechEd Bangalore. This was located in an outside stand-alone building.

TechEd Pune was even larger, located inside a hotel: the JW Marriott Pune. Here's Nisha presenting to a full house:

I think this was from my talk on XAML performance. I must have been explaining something pretty serious when this photo was taken :)

(This photo from Bangalore was shared to me without attribution. If you are the photographer, please let me know.)

The "Stump the Speaker" panels were my favorite part. In this photo, from Bangalore, I had so much Q&A at the end of my session, I arrived late to the panel, and got the honorary tall seat.

Photograph by Microsoft, India

TechDays Delhi was a free event, so it attracted a lot of local students. I was pleased to speak with this audience, as getting our tools, and our guidance on quality apps in front of them is really important. Students are responsible for some of the most exciting startups and some of the coolest apps.

Finally, one thing that I thought was done extremely well at TechEd India was the keynote by four children. Take a moment and watch it now.

The must-see demo from TechEd India

My session decks for the TechEd events are available here: https://india.msteched.com/ Click on "downloads" at the top right. My three sessions were:

Addressing Performance in Windows 8 XAML apps (day 1, architect track)
Tips and Techniques for Building High Quality Windows 8 apps (day 2, Windows 8 track)
Smoothly Navigating the Windows Store Submission, Certification, and Listing Process (day 2, Windows 8 track)

Recordings will be up soon, as I understand it. I'd recommend watching Bangalore, as Pune had to squeeze sessions to account for keynote overrun, so the sessions are a bit compressed.

PCs and phones: an observation

Here are some interesting observations about PCs, phones, and tablets in India:

Almost all developers have a smart phone
iPhone is not the number one smart phone, or even the number two smart phone in India, despite their advertising there.
- Look who's doing well in India and more recent news here
- I saw only a single iPhone at the events, and not a single iPad. This includes the event the students attended.
- Total phone ownership is approximately 12x any sort of PC or Mac ownership
For car drivers and non-IT folks, that little indestructible Nokia was what I usually saw. Feature phones still dominate in India.
I saw a number of high end Android tablets and some Surface w/ Windows RT

This data all came from the local folks and my personal observations, so use it only as anecdotal data. I did see a number of Windows Phones out in the wild, outside of the events. The HTC 8x in blue seems to be quite popular there (this also happens to be the phone I own).

Students generally get new PCs before they go to university, but (anecdotally) rarely have them available to them at earlier grades.

All of this helps to show why India is more of a producer of PC software than a consumer.

Apps

There are some really well-designed apps which have come out of India. I'm not going to list them all in this post, but here are a couple I found compelling:

Sweet 'N' Spicy

And Tarla Dalal

The fact that I absolutely love Indian food played no part in me picking these two specific apps. Honestly ;) You can find them both listed in most regions, including the US Windows Store.

Being a tourist

There is a lot to see in India, especially near New Delhi.

I arranged ahead of time to have a driver pick me up at 4am at the hotel on Saturday with instructions to bring me to the Taj Mahal and the Red Fort of Agra, and to make sure it was a driver who could speak and understand English. He then drove me the 4+ hours from Delhi to Agra. Once we arrived in Agra, he picked up my tour guide for the day (I didn't know I was getting one, but this turned out to be a good idea). They tried to stop for breakfast at a place where the guide obviously had some business interests, but it was too early, I convinced them to skip breakfast and to just bring me right to the Taj. (I left at 4am, but if taking the Delhi->Agra highway, I recommend leaving even earlier, like 3:30, depending on traffic etc.)

The Taj Mahal was everything I had hoped it would be, and much larger. It always looks so small in the photos.

The Taj Mahal is also full of people looking to tap your wallet a little. Just know it's all part of the experience and keep lots of rupees on you. The photos, for example, will run you 10,000 to 20,000 rupee. They say it's 100 rupee per photo, but then take close to 20 of them. Don't worry about whether or not you got the best price or someone else was able to negotiate off 100 rupee more than you. These folks are providing a service to tourists and by western standards, it's pretty inexpensive regardless.

The whole time the tour guide brought me around the Taj, he was talking up the marble inlay. This is interesting, but understand it's also them priming the pump for the trip to the state-owned marble shop afterwards.

TIP

When you're brought to the marble shop, you'll be face to face with one or more extremely talented sales people. In my case, they sat me down with hot tea and showed expensive marble tops first, and afterwards the inexpensive stuff. Then, it was off to jewelry, and then textiles, and (I insisted they leave this part out) rugs. In the case of the marble, unless you really want a table top, just ask to be shown the small things like statues, coasters, etc. Seriously, these sales people are good. I've had less pressure at a car dealer.

Some of the marble goods are nice, though, especially at the state-owned/certified shops. The one I was brought to was an emporium. I tried negotiating for a bit, but they wouldn't do any better than a small discount off the top. From speaking with others, the emporiums are generally fixed price. The one I went to was Cottage Industries, but oddly it also seems to go by the name Cauvery Emporium, as I had receipts from both places for my purchases inside the same building.

Before going in the shop, set a firm budget in your mind, and convert it to rupees so you don't have to do the math in front of the sales people. That's the best way to avoid the pressure as you can firmly say something is outside your budget. Remember, these folks are good.

The trip around the Taj Mahal took around 2 1/2 hours. I was there nice and early, before the majority of the crows. The photo above was taken on the way out as the place filled up. It was also getting pretty hot by then.

It also gets pretty hazy as the day goes on. Air pollution is pretty bad, as is the dust.

After the trip to the Taj, we stopped for breakfast (extremely inexpensive compared to the hotels, and very good) and then headed over to the red fort.

This part of the Agra fort had a fire on the inside, set by invaders. That burned all the painting off the walls, and left a smoky colored marble. Note the translucent marble near the windows.

The "forts" in India are the castles. Don't let the name "fort" put you off, as these aren't US-style forts, and are fully worth the trip. The Agra Fort, in particular, is impressive both in construction and in history. Read up a bit on it before visiting.

The drive back from Agra took quite a bit longer due to traffic. It was over 5 hours as I recall. We also had to dodge, of all things, stray cattle lying in the gutter in Agra. Imagine stray cats and dogs in another nation and then add like 600-800 pounds. They were just there, lying down in the street, in the middle of the city. It was amusing mostly in that it seemed so normal. :)

TIP
Don't get hung up over whether or not you tipped too much for your tourguide, driver, etc. Tip what you think is fair for the service you received, and if you go by Western standards, you'll almost certainly be tipping more than enough. Keep small bills and coins around for the dude in the bathroom who won't let you out without a tip.

While in Delhi, I also took an evening tour "Sound and lights show" of the Delhi Fort. Seeing the Agra Fort afterwards helped complete the story.

You can find all of my photos from this trip on my Flickr page.

Poverty

Before I point out a few helpful tips, I wanted to mention the poverty. I've seen slum-level poverty in the United States, but I was unprepared for the type of poverty I saw on the outskirts of the cities in India. Even the Delhi Airport had slum villages right up against the walls. These villages are made from piles of debris, trash, old signs, mud, dung and more. Basically, if it can be used to put a roof over one's head, it will be. I was never able to get a good photo as cars/planes never stop near the slums. The only real photos I got were these washed out hazy ones (did I mention the pollution?) from inside the plane at Mumbai Airport (click for larger version). These were at least made of building materials. Many were just hobbit holes in what appeared to be piles of trash held together by mud along the side of the road.

You'll also see a LOT of buildings in various stages of construction. Many seem abandoned before completion. Many are concrete skeletons with exposed rebar on top, and bamboo scaffolding. Such is the nature of a developing country.

Here is an image search showing more of these slums.

Some advice for fellow westerners visiting India

I've been to a number of places in Europe, but this was my first time this far east. The culture really is quite different from European culture, so be prepared.

Dress
- Purchase really light cotton khakis before your visit. I brought jeans (too hot) and shorts (not recommended, as only kids wear shorts)
- Women should dress conservatively, especially at monuments. The Taj Mahal grounds include an active mosque and a lot of local and short shorts or low tops will likely get you unwanted attention from folks who think you're being disrespectful or tacky, or from people who want a closer look.
- Men, if you intend to visit any mosque, arms and legs must be covered.
Food
- Unlike the US, don't expect to find water/snack vendors all over the place. If you have Type 1 or other blood sugar control issues, be sure to carry stuff with you, but also know that Taj Mahal will not allow most of this in the monument
- If you don't like Indian food, you're really missing out. :)
- Always drink bottled water. Even in the hotels, stick to bottled. Avoid salads which have been washed in local water. Even my India friends who have been away from India for a while found the local water really upset their stomachs
- - Brush with bottled water as well.
Purchasing
- If you look western, expect the starting price for everything on the street to be at least 2-3x what locals would even consider paying. Negotiate what you can, but also keep in mind that this is a relatively poor country, and you're doing your part to help out in a fair exchange of goods and cash. Don't get taken, but don't worry about nickels and dimes.
- Keep rupees on you. Outside of the western-style hotels, most places are cash-only. Keep lots of small amounts too, as you'll find 100 INR is far too large a tip for some things, and too small for others.
- Use a credit card, not your debit card. You want some protection.
Airports and Travel
- Airport screenings segregate male / female
- Most airports require that you have a printed boarding pass before you can even enter the airport. Some will take a PDF on your phone, but that varies. Web check-in at the hotel.
- Use a hired car and driver. Don't even think of driving yourself. Hired cars (from a reputable company - I used Car Club) are very inexpensive. My whole trip to Agra (4am to 8pm) was around $150 US plus tips. Considering I monopolized a driver from 4am to 8pm, that's pretty good. Trips between hotels and airports typically ran around $15-$20 USD.
- If you use a video camera, realize that the monuments require you to pay extra to bring them in, and some like the Taj Mahal, make you pay to lock them up before entering the monument proper (they do not allow them on the grounds). I use my video camera as my still camera, but that didn't matter. Smart phones are fine as it doesn't seem that Indian officials have caught on to the idea that smart phones are also video cameras.
- If going on a business trip, make a point of seeing the monuments close to where you're staying. There are lots of great things around India, and the beauty can be breathtaking.

Yet Another Podcast #95–Rey Bango on Testing IE

Jesse Liberty [MS] — 2013-04-14T20:42:09

Transferring to an new Windows Phone 8 device

Walt Ritscher — 2013-04-11T18:04:00

I’ve been using my HTC 8x Phone for about six months. I had to get a replacement for the phone last week, due to some issues with the microphone. After a brief call to customer support Verizon replaced it, sending me another phone via next day air. This is the saga of my what happened [...]

Team Foundation Services - Unterstützung für Git unter der Lupe

Norbert Eder [MVP] — 2013-04-12T12:54:07

Nachdem das Tooling beim Team Foundation Server 2012 sehr vielversprechend ist und mit reinen Git bzw. Mercurial-Mitteln zwar möglich, aber durchaus mit zusätzlichen Schritten für Entwicklern oder gar Kontextbrüchen einher geht, möchte ich mir dieses Thema genauer ansehen. Zwar gibt es durchaus Lösungen die eine gesamtheitliche Abbildung des Entwicklungsprozesses inkl. Einbindung von beispielsweise Scrum ermöglichen, allerdings sind die gefundenen Varianten kostenpflichtig, der TFS ist jedoch bereits In-Haus verfügbar, ohne Mehrkosten.

Visual Studio kann ja durch die Visual Studio Tools for Git recht passabel mit Git-Repositories arbeiten. Auch die Team Foundation Services (die “Cloud”-Variante des Team Foundation Servers) bietet die Möglichkeit der Git Team Projects. Innerhalb dieser Projekte wird mit Git-Repositories gearbeitet. Das bringt den Vorteil eines echten Distributed Version Control Systems (DVCS) mit den Templates des Team Foundation Servers zusammen. Soweit so gut. Das Ziel wäre jedoch der Einsatz der On-premise Variante. Hierzu gibt es viele Ankündigungen und Hinweise, dass ein Git-Support bald verfügbar wäre. Die Annahme, dass dies mit dem Update 2 nun endlich soweit ist, hat sich als falsch heraus gestellt. In einem Kommentar zu Visual Studio 2012 - Update 2 RTM musste ich erfahren, dass ein Git-Support kommen wird, jedoch erst im nächsten Major-Release. Also wohl nicht so schnell. Schade eigentlich.

Um für mich selbst ein Bild zu bekommen, ob die Services in Frage kommen (unabhängig der “Cloud”-Geschichte), warf ich einen Blick darauf. Auf meine Erkenntnisse möchte ich nachfolgend eingehen.

Pricing

Aktuell kann dieses Service kostenlos verwendet werden, Preise werden im Laufe 2013 veröffentlicht. Hierbei ist jedoch anzumerken, dass die Verwendung für MSDN Abonnenten wohl kostenlos bleiben dürfte (diesbezügliche Informationen finden sich hier). Derzeit läuft alles auf den Free Plan hinaus, der für bis zu 5 Benutzer verfügbar ist. Eine Verwendung mit mehr als 5 Benutzern ist möglich, wird aber nach Einführung von kostenpflichtigen Plänen (ohne MSDN Abonnement) wohl verrechnet werden. Die diesbezügliche Aussage auf der Webseite:

Just sign up for the Free Plan today and you can use the service for free. When we begin charging in 2013, access to the service will be offered as a benefit—at no additional charge—for paid MSDN subscribers at these levels:

Visual Studio Ultimate with MSDN

Visual Studio Premium with MSDN

Visual Studio Test Professional with MSDN

You get all the benefits of your MSDN subscription plus you can store your work and collaborate with your project team in the cloud.

Wer also ein kleines Team oder ein MSDN-Abo hat, dürfte da auch zukünftig kein Problem haben. Zusätzliche Informationen über das Pricing habe ich nicht. Mal sehen was genau da noch kommen wird.

Test der Services

Für mich stellt sich nun die Frage, wie gut der Git-Support mit den Team Foundation Services wirklich funktioniert. Dazu sind die oben erwähnten Visual Studio Tools for Git notwendig und eine Anmeldung auf http://tfs.visualstudio.com.

Wenn erledigt hat man nun zwei Möglichkeiten:

Für mich ist die Variante mit Git-Unterstützung von Interesse.

Interessant ist hierbei, dass beide Schaltflächen die gleiche Funktionalität bieten, lediglich die Auswahl “Version control” entsprechend gesetzt wird. Projektname ausfüllen, das gewünschte Prozesstemplate wählen und anschließend per Create Project die Anlage starten.

Die Anlage dauert ein paar wenige Momente. Navigiert man im Anschluss zum Projekt wird man gleich mit den üblichen Scrum-Verdächtigen konfrontiert. Vorerst interessiert mich jedoch die Code-Verwaltung. Dazu ist auf den Menüpunkt CODE navigieren und man erhält die Clone-URL. Ein Wechsel zu Visual Studio steht also an.

Der Team Explorer bietet nun die Möglichkeit an, ein Git-Repository zu klonen. Wir holen uns also die entsprechende URL aus den Services und starten dies mal:

Im Zuge dieses Vorgangs wird ein Fenster zur Eingabe der Credentials geöffnet.

So erledigt, kann nun ein neues Projekt erstellt und im Clone-Folder abgelegt werden. Über den Team Explorer sind die Changes sofort ersichtlich. Per Kontextmenü können (und das ist auch notwendig) Dateien aus der Source Verwaltung exkludiert werden.

Hierbei ist mir aufgefallen, dass es mit den Visual Studio Tools for Git offensichtlich nicht möglich ist (oder ich habe es übersehen) eine .gitignore-Datei zu verwalten. Das könnte vielleicht ein wenig lästig sein. Deshalb habe ich mit TortoiseGit ein wenig nachgeholfen und eine entsprechende Datei angelegt, die darin gemachten Einträge werden - wie es aussieht - durch die Visual Studio Tools for Git berücksichtigt.

Edit: Eine .gitignore-Datei kann auch über den Team Explorer und der Git-Integration hinzugefügt werden. Dabei sind bei geöffnetem Repository die Git Settings zu öffnen. Danz unten unter Repository Settings kann ein entsprechendes File hinzugefügt werden.

Im nächsten Schritt folgen das erste Commit als auch ein Push, damit das Projekt im Remote-Repository verfügbar ist.

Ein Blick auf den Online-Zugang zeigt, es hat funktioniert:

Soweit der erste Test via Visual Studio. Zur Sicherheit möchte ich jedoch eine Änderung außerhalb machen und mit dem Git-Client meiner Wahl pushen.

Beim Push-Vorgang kommt nun ein Fehler - nach Eingabe der Credentials - der eigentlich auch nicht weiter verwundert, jedoch vielleicht ein wenig missverständlich ist:

Um dies zu beheben, muss man auf der Webseite zu den Team Foundation Services ins Benutzerprofil wechseln und unter Credentials alternative Daten angeben (bis dato wird ja lediglich mit einer Live ID gearbeitet):

Ein erneuter Push-Versuch resultiert in einem Erfolg:

Auch die weiteren Funktionen arbeiten ohne Probleme.

Fazit

Der erste Eindruck ist gut. Alles arbeitet gut zusammen, es gibt keine Hürden die unerwarteter Weise auftreten, es gibt auch nichts wo man großartig nachlesen müsste. Interessant wird es dann wenn es weiter geht in Richtung der Scrum-Templates und der Builds bzw. Testpläne etc. Aber dafür wird es eigenständige Blog-Beiträge geben, die näher darauf eingehen werden. Es ist sicherlich noch einiges zu tun, aber es lässt sich gut arbeiten, sowohl von Visual Studio heraus, als auch mit anderen Tools. Damit rückt der TFS definitiv wieder in die engere Wahl.

Accelerate cool app development with the Coding4Fun Toolkit

Windows Phone Dev Blog — 2013-04-11T21:11:25

The Coding4Fun Toolkit is a set of powerful controls and libraries that you can use, free, to add rich features and functionality to your XAML Windows Phone apps (and also to your Windows 8 Store apps).

I recently talked to Clint Rutkas, the toolkit creator, about some of the thinking behind building the toolkit, and some of the cool things you can do with it.

Here are some links to related info:

Coding4Fun on CodePlex
Clint Rutkas' page on Channel 9
Windows Phone Development for Absolute Beginners
Portable HttpClient for Windows Phone (in beta)
Windows Phone Toolkit on CodePlex
Info on using transitions from the toolkit (from the Code Project)

Questions:

Tweet to @LarryALieberman

Mercurial-Repository nach Git konvertieren

Norbert Eder [MVP] — 2013-04-11T16:00:36

Git wird immer populärer und gefühlsmäßig gerät Mercurial ins Hintertreffen. Die Gründe dafür dürften wohl in der besseren Performance von Git und der breiten Akzeptanz von GitHub sein. Zusätzlich ist es auch teilweise mühsam, mehrere Clients installiert haben zu müssen (bei einigen ist eine Unterstützung des jeweils anderen DVCS in Vorbereitung, sonst wäre mir SmartGit/Hg bekannt). Wer nun von Mercurial auf Git wechseln möchte bekommt in diesem Beitrag eine Schritt für Schritt Anleitung.

Prerequisits (Mercurial -> Git)

Folgende Werkzeuge und Erweiterungen kamen zum Einsatz:

Als Mercurial-Client wird TortoiseHg verwendet. Dieser Client lässt sich einfach erweitern, was auch für dieses Vorhaben notwendig ist. Als Erweiterung dazu wird hg-git benötigt. Die Installation und Einrichtung sieht wie folgt aus:

Als ZIP herunter laden und in ein beliebiges Verzeichnis entpacken
Via TortoiseHg die Einstellungen für das zu konvertierende Repository öffnen
hg-git als Erweiterung eintragen

Der Eintrag wird direkt in der Datei hgrc vorgenommen und soll wie folgt aussehen:

[extensions]
hggit=C:\Temp\hg-git\hggit

Hier ist natürlich der tatsächliche Pfad einzusetzen. Damit die Erweiterung verwendet wird, müssen alle offenen TortoiseHg-Anwendungen geschlossen werden.

hg-git hat neben der Abhängigkeit zu Mercurial (diese ist durch die Installation von TortoiseHg als erfüllt anzusehen) eine weitere zu dulwich. Hier ist das entweder das ZIP herunter zu laden, oder das Repository zu klonen. Im Root-Verzeichnis befindet sich ein Verzeichnis dulwich. Dieses Verzeichnis muss nun den Libraries von TortoiseHg hinzugefügt werden. Diese befinden sich üblicherweise in:

%ProgramFiles%\TortoiseHg\library.zip

So muss das dann innerhalb der ZIP-Datei aussehen:

Damit sind alle Vorarbeiten abgeschlossen und es kann mit der Konvertierung gestartet werden.

Und natürlich muss Git installiert sein. Hierbei ist unerheblich welche Implementierung. Wer beispielsweise GitHub for Windows installiert hat, ist bereits bestens gerüstet, sonst kann auch http://git-scm.com/ verwendet werden.

Aus Mercurial mach Git

In den nächsten Schritten werden wir ein bestehendes Mercurial-Repository in ein Git-Repository konvertieren. Hierzu sind folgende Schritte notwendig:

Git-Bash öffnen (dieser Schritt ist notwendig, damit die hg-git-Erweiterung angezogen wird)
Ein leeres Git-Repository anlegen (hier wird durch die Erweiterung ein Pack-File eingespielt). Dazu ein Verzeichnis an beliebiger Stelle anlegen und folgenden Befehl innerhalb dieses Verzeichnisses ausführen:
git init --bare
Nun ist ins Mercurial-Repository zu wechseln und dieses in das Git-Repository zu pushen (zu beachten ist, dass dieser Vorgang durchaus recht lange dauern kann, es werden keine Konsolen-Ausgaben geschrieben, daher nicht abbrechen, sondern warten; Es erfolgt jedoch schlussendlich eine Meldung wie viele Commits etc. übernommen wurden):
hg push path/to/Git-Repository
Im Git-Repository liegt nun unter objects/pack ein Git-Pack-File, welches alle notwendigen Informationen enthält.

Damit ist die Migration eigentlich abgeschlossen, sofern man mit dem Pack-File zufrieden ist. Ist dies nicht der Fall, kann man mit den folgenden beiden Schritten alle Objekte in separaten Dateien ablegen:

Ein weiteres Verzeichnis anlegen und in dieses wechseln
git clone -l path/to/Git-Pack-Repository ausführen. Dabei ist nicht das Pack-File zu referenzieren, sondern das Repository-Stammverzeichnis

Damit ist nun ein Git-Repository mit allen Objekten als separate Dateien vorhanden und kann für weitere Schritte verwendet werden.

Fazit

Die Migration kostet zwar ein wenig Zeit (vor allem, wenn man sich die einzelnen Schritte und Lösungen für einige Fallen zusammensuchen muss), geht aber sonst weitestgehend problemlos von Statten. Nach dem Umstieg steht die gesamte Historie zur Verfügung und es kann wie mit Git gewohnt gearbeitet werden.

Das Geheimnis der Kommunikation

Norbert Eder [MVP] — 2013-04-09T21:25:15

Vor einigen Tagen habe ich zum Thema Arbeiten wir an der Kommunikation geschrieben. In diesem Beitrag hatte ich einige Punkte aufgelistet, die ein Team zu einer besseren Kommunikation führen, wohlgemerkt, auf mein Team abgestimmt. Gestern hatten wir einen Workshop-Tag mit Ilker Centikaya zum Thema Scrum (hierauf folgt ein separater Post). In diesem wirklich sehr inspirierenden Workshop hatten wir auch ein wenig Systemtheorie zum Thema. In seiner Rohform nichts für schwache Nerven. In der durch Ilker aufbereiteten Form dauerte es nicht lange und mir fiel es wie Schuppen von den Augen.

Ich hatte den Grund erkannt, warum die Kommunikation innerhalb meines Teams und auch mit angrenzenden Bereichen nun wesentlich besser funktioniert als noch vor einigen Monaten. Intuitiv hatte ich eine Entscheidung zu einem Vorgehen getroffen und diese umgesetzt. Nie wäre ich jedoch auf den Gedanken gekommen, dass dieser Punkt wesentlich stärker wiegt als alle im letzten Beitrag zum Thema Kommunikation aufgelisteten Punkte. Das Stichwort ist

Transparenz

Jawohl! Transparenz!

Das hat mit Kommunikation nun was genau zu tun?

Mit einer mangelnden Kommunikation geht meist auch noch ein weiterer Punkt einher: Mangelnde Motivation, oder besser formuliert, stark einwirkende Demotivation. In zahlreichen Quellen wird betont:

Wahre Motivation kommt von innen.

Das heißt im Umkehrschluss, dass von Extern demotivierende Kräfte wirken. Da gibt es viele Faktoren, einer ist fehlende Information. Dies bedeutet natürlich, dass der eigene Entscheidungsfreiraum eingeschränkt wird, das Ziele, Visionen nicht erkannt werden und somit auch kaum Weiterentwicklungspotential gesehen wird. Das resultiert wiederum darin, dass der Einzelne nicht weiß wohin der Weg führt und wo auf diesem Weg er selbst Platz findet. Das löst Existenzängste aus. Eine logische Folgerung: Es findet eine Einigelung statt, eine Abgrenzung. Typisch dafür ist, dass selbst wiederum keine Informationen weitergegeben werden, um sich selbst unentbehrlich zu machen.

Um dieses Problem zu beheben, kommt nun die Systemtheorie ins Spiel (bitte beachten, dass meine Kenntnisse der Systemtheorie als sehr gering einzustufen sind, bei Fehlbeschreibungen bitte mich zu verbessern). Speziell die Selbstreferenzialität. Salopp gesagt bedeutet dies, dass sich ein System (eine Person, ein Team, ein Unternehmen etc.) nur auf sich selbst bezieht, sich selbst reguliert. Einflüsse aus der Umwelt können angenommen werden, müssen aber nicht.

Möchte ich als Person einen Vorteil zu vermitteln, muss ich ihn also zuerst bei mir selbst anwenden, zeigen dass es funktioniert und kann somit angrenzenden Systemen ein Angebot unterbreiten, dies ebenfalls einzusetzen. Diese Systeme entscheiden selbst ob sie das tun werden oder nicht. Wird der Vorteil erkannt und für gut befunden stehen die Chancen dazu natürlich gut.

Mein Vorgehen war nun, für Transparenz in meinem Tun zu sorgen. Meine Team-Mitglieder wurden verstärkt zu Entscheidungen herangezogen, bekamen Informationen zu dem “Wie geht es weiter?” usw. Durch die gelebte Transparenz haben meine Team-Mitglieder offensichtlich den daraus resultierenden Vorteil erkannt und selbst umgesetzt. Die Informationen wurden mehr, jeder konnte seinen Platz finden, die Sicherheit ist gestiegen, ebenfalls die Motivation. Die “neue” Motivation hat dazu beigetragen, dass mit vielen Informationen freizügiger umgegangen wird. Es stieg der Kommunikationsanteil. Und plötzlich läuft das Werk …

Fazit

Transparenz ist ein Faktor der nicht unterschätzt werden darf. Mitarbeiter möchten wissen wie es um ein Unternehmen, die Projekte, ihre Zukunft steht. Nur mit diesem Wissen können sie sich wirklich einbringen und für Mehrwert sorgen. Ich selbst habe durch Ilker einen kleinen Einblick in für mich neue Themen erhalten die mir sofort geholfen haben, einige meiner Entscheidungen reflektieren und weitere Maßnahmen setzen zu können. Was folgt ist sicherlich ein weiteres Studium dieser Gebiete um mein Wissen zu festigen. Ebenfalls verstehe ich nun, dass dies der wahre Grund war, warum die Kommunikation innerhalb meines Teams nun ordentlich funktioniert. Die anderen Maßnahmen waren gut und sicherlich hilfreich, jedoch nicht ausschlaggebend.

Congratulations to Wikipedia by Rudy Huyn, Windows Phone Next App Star

Windows Phone Dev Blog — 2013-04-09T19:18:04

Our focus this year is on raising awareness for the amazing apps you develop for Windows Phone. We’ll accomplish through new programs, app promotions, and increased opportunities for app discoverability in the Windows Phone Store on the phone and on the web. So far we’ve launched:

Daily promotion of new and trending apps – follow us: Windows Phone blog, Facebook, and Twitter
New weekly app deal program – Red Stripe Deals – to drive engagement and downloads of a select group of apps and games each week at 50%+ off the original price
Continued improvements to our search algorithms, merchandising, and web Store, where many potential customers who are considering buying a Windows Phone come to see if an app is available before they purchase. We’ve recently added an overview page to the web Store we’ll use to deliver key app messages, for example
And, let’s not forget the Windows Phone Next App Star contest, designed to bring attention to 64 finalists and give consumers an opportunity to vote for their favorites, and for one lucky developer to have the opportunity to see their app featured in a prime-time television commercial in the US*

Today I’m pleased to announce the winner of the Windows Phone Next App Star competition. We started this journey with 9,137 entries from 79 markets. With so many competitors it took both strong user review scores during the ratings period and very formidable app quality to be selected. At the end of the judging, 64 finalists emerged, with apps from developers across the globe – Australia, Bangladesh, Brazil, Canada, China, Czech Republic, Egypt, France, Germany, India, Italy, Poland, Russia, Spain, Ukraine, United Kingdom, and the United States. As we narrowed the field through rounds of voting, our developer finalists earned prizes (Nokia Lumia 920 phones, wireless chargers, Microsoft Signature Sony Ultrabooks, an appearance in a special episode of Hot Apps, and trips to //build, among other prizes) and gained exposure for their apps with over 615,000 contest votes. Meanwhile, voters participated in a sweepstakes** to win a Nokia Lumia 920 – a new phone was awarded every day of voting.

The championship round between ProShot by Eddie Kezeli and Wikipedia by Rudy Huyn was highly competitive. To give you insight into these two apps: ProShot is a feature-packed lens app with such an intuitive UI it can be enjoyed by the professional photographer and the weekend warrior alike. Wikipedia takes rich web content and brings it to life with Windows Phone design elements and features like NFC, speech, and Live Tiles.

In the end there can be just one grand prize winner and it is my pleasure to announce that the Windows Phone Next App Star is Wikipedia by Rudy Huyn, of Rennes, France. Take a look at this short video and visit us on Facebook to learn more about the Wikipedia app.

As the grand prize winner, Wikipedia will have the opportunity to be featured in a Windows Phone prime-time television commercial in the US. Congratulations Rudy!

Today we’re focused on celebrating Rudy and the achievements of all our Next App Star finalists. In the coming weeks you can expect posts with learnings from the competition that you can apply to your situation – from app creation to marketing tips. And you’re all stars in our book.

Windows Phone Next App Star Finalists

* See official developer rules for details.

** See official sweepstakes rules for details.

More Dev Center features – we’re listening

Windows Phone Dev Blog — 2013-04-06T00:16:33

Hi everybody! I’m Rushmi Malaviarachchi, lead program manager for the Windows Phone Dev Center. I work on the engineering team that’s responsible for the Dev Center website, the Dev Center app, and the app ingestion system that gets your apps into the Windows Phone Store. I’ll be posting here on a regular basis to share improvements that we’re making to Dev Center.

Over the past few months we’ve had the opportunity to meet with some of you in person and discuss what’s top of mind. We’ve also been reading the posts in our UserVoice forum to understand what you’d like to see from Dev Center. This week we updated Dev Center with several features to address your feedback.

Canceling submissions

Previously, after you clicked the Submit button on an app submission in Dev Center, you couldn’t edit it again until it had finished processing. After clicking the button, if you realized that something needed to be changed or there was one more bug that you needed to fix, you’d have to wait until the app submission completed before you could address it. Frustrating.

Providing a way to cancel a submission is one of the top-ranked requests in our UserVoice forum. I’m pleased to announce that now from the lifecycle page you can cancel an app submission, make changes, and then submit again. Here’s what you’ll see in Dev Center:

After you click cancel, you’ll see the following confirmation. You can click the Edit submission link to make changes and submit again.

Rotating screenshots

Dev Center already supports both portrait and landscape screenshots, but sometimes we receive landscape screenshots in portrait orientation. This may not be such a big deal when viewed on the phone, but it certainly makes a difference when customers browse apps on the web Store. Instead of rotating screenshots in an image editor, you can now rotate them directly in Dev Center after they’ve been uploaded. Here’s what it looks like:

Automatic screenshot resizing

For apps that support multiple screen resolutions, you can now choose to upload only screenshots with the highest resolution and let Dev Center automatically create the others. If you want the flexibility of submitting a set of screenshots per supported resolution, you still have that option. Here it is in Dev Center:

We really appreciate your ongoing feedback; please keep it coming! The Windows Phone Dev Center UserVoice forum is the best way to do that. You’ll be hearing from me again soon when we have more news about Dev Center improvements to share with you.

Windows Phone Next App Star: The final four apps and the developers behind them

Windows Phone Dev Blog — 2013-04-05T23:29:38

It’s hard to believe we’re down to the final 4 in our Windows Phone Next App Star contest. But from 9,000 apps submitted by developers in 79 countries, then narrowed to 64 apps, then voted by the public down to 32, 16, and 8… here we are. We’d like to introduce you to the impressive talents of the final four developers and the exceptional apps they’ve created. And you’ll be seeing one of these apps in action as part of our contest grand prize—the top app will be featured in a nationwide Windows Phone TV ad in the US. Voting on this round continues through 11:59pm PST tonight, Friday, April 5, 2013. Learn about these apps and decide who to vote for to push forward to the championship round. Oh, and did I mention every vote is an entry to win a Nokia Lumia 920*?

Three brothers — Emad, Iyad, and Zeyad Ejielat — working out of Australia and Jordan via Skype, created Amazing Weather HD, which is well named. All three are involved professionally in computers and electronics (Zeyad is studying medicine, too). Their first app, created several years ago, was Stormy 7, which eventually became a full-fledged weather app. Amazing Weather HD takes vast amounts of weather info, then beautifully integrates it with the Windows Phone design. Amazing Weather HD also offers a dynamic lock screen, Live Tile, and has fluid, natural app navigation. This app offers in-depth weather info, served up as eye candy.

Their app is matched up against Eddie Kezeli of Roseville, California, and his app ProShot. As Eddie describes his app, “ProShot brings a range of professional enhancements to the exceptional cameras found on Windows Phone 8 devices. So your already very smart smartphone becomes a DSLR camera — complete with adjustable shutter speeds, ISO, white balance, aspect ratio, and more. ProShot offers pro-level photography options, encouraging exploration and discovery from users at any skill level.” Eddie, who thinks of himself as a “computer doctor” and is both a Windows Phone enthusiast and karaoke champion, says of ProShot, “big features should not be limited to big cameras.”

Rudy Huyn of Rennes, France, is a Windows Phone expert and big fan of the Microsoft mobile platform. He’s also a Windows Phone Development MVP and founded a French community of Windows Phone developers. Rudy loves Wikipedia so much that he wanted to create the ultimate Wikipedia app. Having “a complete encyclopedia in your pocket” was Rudy’s goal. His Wikipedia app uses location features to find articles relevant to where you are. You can search in more than 100 languages, with easy sharing on Facebook, Twitter, email – even through a QR code.

That pocket encyclopedia is up against VoiceTranslator, an app developed by Sergey Svinolobov of Waltham, Massachusetts. Sergey won his first software contest – for programming calculators – in his home country of Ukraine at the young age of 15, and nearly 30 years later, he’s still developing and entering contests. Using the Windows Phone speech feature and integrated with the cloud, VoiceTranslator listens to you say a word or phrase, then says it back to you in almost any language you choose – more than 60 different languages are available. Sergey loves his “Star Trek gadget.” He said he’s released translator apps in the past, but recently thought, he said with a smile, “Why do I have to type?”

If you still can’t make up your mind on which to vote for, check out Laura Foy’s Hot Apps show, which highlights each of these top apps.

Congratulations to our final 4, and thanks to all of our amazing Windows Phone Next App Star participants for their innovation and creativity.

* No purchase necessary. Open to registered Facebook account holders 18+. Ends 4/8/2013. See Official Rules for details.

Published Second Pluralsight Course: Windows 8 From Design to Delivery

Jesse Liberty [MS] — 2013-04-05T21:47:53

How to debug pointer capture

Bea Stollnitz — 2013-04-04T07:08:25

In our previous blog post, we mentioned some of the challenges developers face in creating keyboard-friendly applications, and we presented our FocusWatcher class for debugging these issues in Windows Store apps. The keyboard is just one way an app may receive input; Windows Store apps can also get input from mouse, stylus, and of course, touch. Modern tablets and touch screens often support multiple simultaneous touch inputs, in fact. All these different inputs can make it tough for developers to figure out what’s going on, especially when combining...

Spinning a Record Like a DJ in Windows 8

Charles Petzold — 2013-04-02T12:44:18

Windows 8 has some exceptionally powerful facilities for working with sound, and in the latest installment of the DirectX Factor column in MSDN Magazine I show how to display a file picker that allows you to select an MP3 or WMA file from your Windows 8 Music Library, display cover art as well as album and artist information, load and decode the file using the Media Foundation APIs, and shovel the resultant audio buffers into XAudio2 voices to play back the file.

... more ...

Follow Up - Hochwertiger Content für Entwickler - Machen wir doch was!

Norbert Eder [MVP] — 2013-04-02T10:54:14

Vor einigen Tagen hatte ich im Beitrag Hochwertiger Content für Entwickler - Machen wir doch was! aufgerufen, eine einfache Möglichkeit zu schaffen, an hochwertigen Content aus der Community zu kommen. Das Echo war recht groß und schnell ergab ich ein äußerst fruchtbares Gespräch mit Ralf Westphal. Aber auch viele andere aus der Community teilten ihre Meinung mit mir. Teils mit Zustimmung, teils mit konstruktiven Hinweisen auf bestehende “Lösungen”.

Warum überhaupt?

Im letzten Beitrag ging das Warum nicht eindeutig hervor. Daher möchte ich dazu ein paar Worte teilen, die erklären warum ich der Meinung bin, etwas Neues müsste her.

Mir ist durchaus bewusst, dass es zahlreiche Blogs gibt, die wirklich gute Beiträge liefern, mitunter finden sich auch an anderen Stellen feine Artikel, oder auch Grundlagendiskussionen, die ein jeder gelesen haben sollte. Das ist positiv und gut so. Für aktive und langjährige Mitglieder der Community ist das Finden dieser Ressourcen kein Thema, hat doch ein jeder die entsprechenden Quellen aktiv am Radar, oder ist sogar selbst dafür verantwortlich. Dennoch brauchen auch hier die einen oder anderen Perlen einige Zeit, gefunden zu werden.

Der Einsteiger hat es da schon schwieriger. Thema auswählen, Google oder Bing auf Treffer durchforsten und die gefundene Lösung wird schon in Ordnung gehen. Eine tiefergehende Prüfung hinsichtlich Auswirkungen etc. kann erfahrungsbedingt oftmals nicht durchgeführt werden. Er muss sich also auf das Gefundene verlassen, oder bei schlechtem Bauchgefühl dem nächsten Link vertrauen. Dabei zählt nicht immer Qualität. Wer mehr Content produziert (und die passenden Keywords) steht weiter oben, nicht zwangsweise der empfehlenswerte. So einfach, so schlecht.

Gab es vor 10 Jahren noch ein paar zentrale Player, die Content anzubieten hatten, findet sich dieser nun an allen Ecken und Enden. Guter, wie auch Schlechter. Das Problem dabei: Der gute Content ist durch vermehrte Werbebeiträge etc. teilweise ganz gut versteckt. Blogs haben in der Regel auch vielfach nicht die Suchmaschinenrelevanz von größeren/großen Verlagen, teilweise jedoch weit bessere Inhalte.

Für mich ist das der Punkt an dem eine Lösung her muss. Sowohl für mich als auch für andere, besonders Einsteiger, die es wirklich sehr schwer haben. Das mag der eine oder andere noch nicht nachvollziehen können, aber dazu komme ich gleich.

Bestehende Lösungen

In den Kommentaren des ersten Beitrags wurden einige deutschsprachige Alternativen genannt, die gerade der eingeschworenen Community wohlbekannt sind. Viele werden diese Dienste auch zu schätzen wissen. Es liegt mir fern diese als schlecht hinzustellen, dennoch möchte ich sie hinterfragen und Problemstellen aufzeigen.

DotNetGerman Bloggers(und Aggregate im Allgemeinen)
Das ist wohl das Community-Feed-Aggregat der ersten Wahl für ausreichend Inhalte. Wenn ich korrekt gezählt habe, dann sind zum jetzigen Zeitpunkt 109 mehr oder weniger aktive Blogger gelistet. Das ist schon eine ganz schöne Menge, an Bloggern und gelieferten Content. Wunderbar. Dennoch bietet dieses Aggregat (wie alle anderen) einige Nachteile:

Zuviel Rauschen. Zu nahezu jedem Thema finden sich zahlreichende Blogger. Da viele nicht abgeneigt sind, News zu ihrem Fachgebiet zu verfassen, erscheint dieselbe News zigfach in der Liste auf. Ebenso verhält es sich mit Themen, die eigentlich nicht für das Aggregat von Relevanz sind. So finden sich Beiträge anderweitigen - teils branchenfremden - Themen, teilweise auch private. Das interessiert mich nicht, wenn ich mich zu aktuellen .NET Themen informieren möchte.
Fehlende Wartung. Aggregate haben es an sich, dass keine oder kaum Wartung statt findet. Aufgenommen wird, was aktuell ins Schema passt. Die Ausrichtung eines Bloggers (dahinter steckt in unserem Fall ja meist ein Entwickler) ändert sich jedoch im Laufe der Zeit. Dies hat meist berufliche Hintergründe. So findet oft sehr schnell eine Verlagerung in gänzlich unterschiedliche Themengebiete statt. Oftmals wird überhaupt die Plattform gewechselt. Beiträge gehen dann am eigentlichen Thema vorbei. Das führt wiederum zum ersten angeführten Problem: Zuviel Rauschen.
Keine Kategorisierung. Ich als Leser des Aggregats habe keine Möglichkeit nach Themen zu filtern, die mich aktuell interessieren. Hier kann ich nur mühsam die einzelnen interessanten Feeds nehmen und meine eigene Liste pflegen. Damit entferne mich jedoch vom Dienst und nutze ihn nur als Input-Geber. Zukünftige empfehlenswerte Beiträge bleiben mir verborgen, da diese natürlich nicht in meinen abonnierten Feeds enthalten sind (so ich nicht zufällig auf diese Quelle stoße).
Kurze Vorhaltezeit. Das genannte Aggregat (wie auch die meisten Alternativen) hält Beiträge nur für kurze Zeit im “Angebot”. Ältere Beiträge können weder durch eine Suchfunktion noch anderweitig gefunden/angezeigt werden. Somit hat dieses Medium lediglich tagesaktuelle Relevanz für mich. Heute interessiere ich mich für dieses Thema, morgen für ein anderes. Wofür ich mich morgen interessiere, kann ich heute jedoch nicht beurteilen. Ergo fällt es auch schwer die richtigen Beiträge für eine spätere “Behandlung” zu markieren.
Kein Qualitätshinweis. Ich muss einen interessant klingenden Beitrag lesen um ihn beurteilen zu können. Es gibt kein Bewertungssystem an dem ich mich festhalten kann, welches quasi als Leitschienen fungiert. Das kostet Zeit und birgt die Gefahr in sich, den am Schluss des Beitrags formulierten Mehrwert nicht als solches zu erkennen (weil ich beim ersten “Scannen” gar nicht so weit komme).

dotnet-kicks.de
Auch dieses Projekt ist der Community gut bekannt. Mittlerweile werden keine weiteren Beiträge mehr eingestellt. Ob das Projekt eingestellt wurde, oder einfach kein Interesse mehr besteht, kann ich nicht sagen. Fakt ist, dass es ein Klon von vor Jahren boomender Bewertungssysteme ist (welches genau können die Betreiber sicherlich beantworten). Ein einfaches System Internetinhalte zu “bewerten” und zu kategorisieren. Die immer geringeren Benutzerzahlen zeigen jedoch, dass derartige Dienste überholt sind.

Kein Qualitätshinweis. Aber hey, ich habe es “gekickt”. Das zeugt doch von Qualität. Nein, das tut es nicht. Ich als “Leser” kann nicht erkennen warum diese Quelle empfohlen wurde. Ist es ein Freundschaftsdienst, oder ist der Inhalt wirklich so gut. Viele “Kicks” bekommt oft auch, wer über ein trendy Thema berichtet hat. Kommentare und Kategorisierung sind zwar möglich, werden jedoch nicht oder kaum genutzt, da dies kein Teil des Rating-Systems ist. Für mich als Leser wenig hilfreich.
Fehlende Accountability. Beiträge können unter Pseudo-Benutzern oder gar anonym eingereicht werden. Dadurch entsteht ein gewaltiges Rauschen. Wer mit seinem Namen einsteht und (daher) auf seine Reputation bedacht ist, wird besonders darauf achten, guten und sinnvollen Content einzustellen.
Fehlende “Mitmach-Motivation”. Gamification ist das Stichwort. Oftmals fehlt es an einem Anreiz Inhalte einzustellen. Self-Marketing steht hier ganz weit vorne. Weitere Kriterien sind aber die persönliche Profilierung, die nicht nur durch eigene Inhalte zustande kommt, sondern auch als Quell empfehlenswerter Inhalte.
Mangelnde Usability. In den meisten Fällen muss Titel und Beschreibung der einzustellenden Beiträge manuell eingetragen werden. Dies kann auf Basis der URL automatisch geschehen. Der Fokus wird hierbei auf die falsche Stelle gelegt. Wichtiger wäre eine sinnvolle Bewertung, weniger die Erfassung ohnehin verfügbarer Informationen.

Beide Lösungen haben auch gemeinsam, dass es wenig Personalisierungsmöglichkeiten gibt. Integrationen zu “Read later”-Diensten oder gar als eigene Implementierung sind nicht vorhanden. Es fehlt mir persönlich eine schnelle Möglichkeit empfehlenswerte Beiträge in einer Liste zu hinterlegen, die ich mir dann in aller Ruhe ansehen kann. Ich bin gezwungen Schritte unabhängig des Dienstes vorzunehmen um dieses Ziel zu erreichen. Ein “Kontextbruch” der es mir erschwert, mein Ziel zu erreichen.

Lösungsvorschlag

Die vorgeschlagenen Alternativen bieten also viele Nachteile, die behoben werden können. Zwar bedeutet dies nicht per se, dass die Dienste damit obsolet sind oder nicht genutzt werden sollten. Es geht aber besser - mit weit höherem Mehrwert. Genau die Schaffung dieses Mehrwertes ist das Ziel.

Wie also kann eine mögliche Lösung aussehen? Nachfolgend möchte ich die aufgekommenen Erkenntnisse zusammen fassen und zur Diskussion in den Raum stellen. Es ist jeder herzlich willkommen seine Meinung kund zu tun. Gerne auch konstruktive Kritik, da diese bekanntlich den größten Mehrwert bietet.

Content-Sharing. Entgegen meines ersten Vorschlages soll kein neuer Content generiert, sondern auf vorhandenen verlinkt werden. Es gibt ausreichend qualitativ hochwertige Beiträge.
Accountability. Beiträge können nur von Benutzern eingestellt werden, die mit vollem Namen registriert sind und mit solchem für ihre Quellen einstehen. Anonyme Beiträge sind nicht erlaubt, auch Phantasienamen werden nicht akzeptiert.
Rating. Eine Bewertung ist immer mit einem Grund zu versehen. Warum wird dieser Inhalt als empfehlenswert eingestuft? Was ist der tatsächliche Mehrwert? Wie hat mir der Beitrag weiter geholfen? Ein einfaches “Kick it” ist nicht ausreichend einen Beitrag zu empfehlen. Jeder angemeldete Benutzer kann ein Rating abgeben. Dieses ist wiederum mit einem ausreichenden Kommentar zu versehen.
Tagging. Es gibt kein Einstellen ohne Tagging. Beiträge sind mit passenden Tags zu versehen. Darauf aufbauend kann ein entsprechendes Einfächern in Kategorien stattfinden. Auch eine Suche kann darauf (unter anderem) abgestimmt werden.
Redaktionelle Betreuung. Eingestellte Beiträge werden von “Fachbereichs-Verantwortlichen” freigegeben. Dies bedeutet natürlich einen entsprechenden Aufwand, stellt jedoch sicher, dass passende Begründungen und Tags gesetzt wurden. Ebenfalls kann darüber die Relevanz und der Anspruch an die Qualität der Artikel gewährleistet werden. Hier stelle ich mir ein Team von Themen-Verantwortlichen vor, die sich eben diesem annehmen.
Gamification. Ein öffentliches Ranking-System für Beitragende soll spielerisch sicherstellen, dass die Motivation zum Einstellen neuer Beiträge gegeben ist. Dieses soll nicht auf Masse, sondern auf Qualität basieren. Bewertungen von einem höheren Ranking zählen hierbei mehr als dies bei einem unteren Rang der Fall ist.

Zu diesen Anforderungen bestehen natürlich weitere. Diese sind aber hauptsächlich in der Usability durch den Besucher zu finden, aber auch der Einsteller soll davon profitieren. So sollten beim Einstellen von Beiträgen die relevanten Informationen automatisch bezogen werden (wie man das auch von Facebook, Google+ und Konsorten bereits gewöhnt ist). Stattdessen sollte der Fokus auf die Bewertung des Inhaltes gelenkt werden.

Dem Besucher muss es ermöglicht werden, schnell an für ihn relevante Informationen zu gelangen. Registrierte Benutzer sollten zudem in den Vorteil von “Read Later”-Listen, persönlichen Filtern und Benachrichtigungen kommen.

Hinter den einzelnen Punkten liegen (teilweise) bereits konkrete Ideen zur Umsetzung. Bevor ich diese jedoch groß kund mache, möchte ich diese Zusammenfassung nochmals zur Abstimmung in die Runde werfen. Mir ist eure Meinung sehr wichtig und möchte einen tatsächlichen Mehrwert mit einer neuen Plattform liefern, die natürlich - wie jede andere Plattform - auch mit Anfangsproblemen zu kämpfen haben würde. Nur wenn ein Erfolg absehbar ist, wäre eine Umsetzung sinnvoll. Ich würde mich daher über viele Meinungen freuen. Ist der eingeschlagene Weg richtig, fehlt noch etwas, oder befinden wir uns hier generell auf einem Holzweg?

Yet Another Podcast #94–Phil Haack: Git

Jesse Liberty [MS] — 2013-04-02T19:24:21

Over 9,000 apps aimed for fame, 16 remain - You decide Windows Phone Next App Star

Windows Phone Dev Blog — 2013-03-29T22:13:00

As we head into the final stretch of consumer voting in the Windows Phone Next App Star contest, I wanted reach out to the developer community with an update.

We created the contest to shine the spotlight on your creations, and to help get these apps exposed to more customers. We started with 64 finalists (32 paid and 32 free apps), out of 9,000 entrants from 79 markets, and you’ve narrowed the field to 16 apps with head-to-head, bracket-style voting. To date, over half a million total votes have been cast and we expect the excitement to rise as we enter the final ten days.

Each of the apps in the contest is unique, and offers features specific to its target audience—this really highlights the diversity of the Windows Phone Store app catalog. I wanted to take a minute to look at one match-up in particular that caught my attention, because it showcases the creativity of our developer community: the match-up between the addicting game Brain Cube Reloaded from XIMAD in San Francisco, CA, and the popular VoiceTranslator from SeNSSoft in Waltham, MA.

Up first is Brain Cube Reloaded, a follow-up on the original Brain Cube, a multi-level puzzle game. Users are challenged to manipulate tumbling blocks into place. With its increasing levels of difficulty, one user called the game "intense and challenging," and another said it’s "crazy addicting." The graphics on this game are very engaging, which, combined with a well thought-out plot across the levels and increasing difficulty as you progress, is sure to be a must-have for Windows Phone users.

Next up is VoiceTranslator. This unique app provides a cloud-based, voice-activated language translator that supports numerous languages. As global connectivity becomes a greater part of our everyday lives, this type of app has a bright future, and the very high ratings from thousands of reviews indicate that VoiceTranslator really hits the mark with Windows Phone users.

As the brackets narrow in on the Windows Phone Next App Star champion, you’ll see more match-ups like this one: very different apps going head-to-head to win fan votes and move to the next round. It has been fun getting to this point, and I am excited to see how users continue to support their favorite apps. And, we’ll continue promoting the contest and the finalist apps as they continue to gain broad exposure for the great work of the community. With four more rounds to go, this is still a wide-open contest to see who will be named the grand prize winner.

If you haven’t had the opportunity to vote yet, I think you’ll want to check out the work of your colleagues. There are less than 12 hours left in this round. As an added incentive, we’re giving away a Nokia Lumia 920 every day as part of our voter sweepstakes through the last day of the contest, April 8, 2013, so keep coming back and vote in every round*.

* No purchase necessary. Open to registered Facebook account holders 18+. Ends 4/8/2013. See Official Rules for details.

31 días de Windows 8 | Día 14: Geo localización

La Liga Silverlight — 2013-03-29T16:00:26

Este artículo es una traducción de “Día 14: Geo localización” de Jeff Blakenburg. Puedes encontrar aquí la versión original en inglés. Hoy vamos a hablar acerca de uno de mis elementos favoritos e cualquier plataforma de desarrollo. Tener el conocimiento de la ubicación del usuario (o más específicamente, del dispositivo) hace mejor a cualqueir aplicación. Aquí están algunos ejemplos de como: Aplicaciones de línea de negocios Conoce que planta estará visitando tu gerente hoy de modo que el tenga toda la documentación apropiada para la maquinaria en esa instalación. Además tu aplicación podrá navegar e fotos y nombres de los empleados en ese lugar así ellos estarán más preparados cuando el llegue. Juegos Identifica otros jugadores cercanos y ten la oportunidad de retarlos a un juego. No solo mejorará potencialmente la latencia de red para ellos sino que también podrás formar un gremio de nada. Crea un juego global de parejas, basado únicamente en la proximidad, no en contacto. Mapas Duh. Haremos esto como una parte del código de ejemplo de hoy. Viajes Reconoce la distancia del usuario y tiempo de viaje potencial desde el aeropuerto y alértalos de caer en la urgencia de perder su vuelo. Además, una vez [...]

31 días de Windows 8 | Día 15: El teclado en pantalla

La Liga Silverlight — 2013-03-29T17:28:00

Este artículo es una traducción del día #15 en la serie 31 días de Windows 8 de Jeff Blakenburg. Hoy vamos a dar un vistazo al teclado en pantalla de Windows 8. Microsoft no parece hacer una distinción de nombres entre el teclado que aparece cuando haces tap con tu dedo en un control TextBox y el que encuentras en el Centro de Accesibilidad. Vamos a enfocarnos hoy en el teclado que se ve como esto: Por otro lado, el teclado de Accesibilidad, es una herramienta diseñada para hacer más fácil el uso de la computadora a quienes no pudieran usar el teclado de ninguna forma. Lo puedes encontrar abriendo el centro de Accesibilidad en tu maquina… Y haciendo click en la opción de “Iniciar Teclado en Pantalla” vas a descubrir un teclado que se ve como este: El enfoque principal de este teclado es permitir al usuario usar Windows completamente sin tener un teclado conectado a su computadora. No es personalizable, y no responde a ningún código que escribamos en este artículo. El teclado es también una de las pocas ventana que pueden ser puestas sobre la pantalla de Inicio. Míralo aquí: OK, así hemos usado los primeros párrafos [...]

Visual Studio 2010 Tooltip Assassin

Karl Shifflett [MS] — 2013-03-29T17:22:26

I don’t know about you, but the Visual Studio 2010 XAML and C# editor tooltips don’t provide much value. When presenting they are a distraction. When I collapse a region of XAML and the mouse wonders over the collapsed region I get this enormous tooltip painted over the XAML I’m looking at. I finally decided [...]

Windows 8 Store Applications Vs. WPF Applications

Jesse Liberty [MS] — 2013-03-29T16:47:35

Arbeiten wir an der Kommunikation!

Norbert Eder [MVP] — 2013-03-29T08:37:00

Vor einigen Monaten habe ich darüber geschrieben, was denn ein Team-Leader für sein Team tun kann bzw. überhaupt sollte. Nun ist doch ein wenig Zeit vergangen und ich habe unterschiedlichste Experimente vorgenommen - hauptsächlich um die Kommunikation und das Teamgefüge zu verbessern. Meine Erfahrung dabei: die kleinsten Umstellungen wirken am besten! In diesem Beitrag möchte ich aus den Erfahrungen der vergangenen Monate berichten.

Ausgangslage

Mein Team hat harte Zeiten hinter sich. Auch wurde es immer wieder durcheinander gewürfelt. Neue Kollegen, Splittung in mehrere Teams, erneute Zusammenführungen und vieles mehr ist in den letzten Jahren passiert. Gepaart mit zu viel Arbeit und zu wenig Ressourcen ist das für die Teamkultur nicht gerade förderlich. Im Gegenteil. Langsam aber sicher entwickelt sich jeder zum Einzelkämpfer und verhält sich dementsprechend abgeschottet. Eine Entwicklung die bei uns quasi über Jahre ging.

Kleine Änderungen führen zum Ziel

Oder zumindest in die richtige Richtung. Nachfolgend möchte ich einige der vorgenommenen Veränderungen aufführen. Ich gebe jedoch zu bedenken, dass jedes Team anders ist. Einige der besprochenen Probleme werden in anderen Teams nicht auftreten, dafür möglicherweise andere Schwachstellen.

Umbau Büro

Ganz wichtig ist das Klima im Büro. Wir hatten über Jahre hinweg ein sehr steriles Büro. Kaum Pflanzen, wenig Drumherum. Durch einen neuen Büro-Plan haben wir ein wesentlich größeres Büro für unser Team bekommen und haben dieses gemeinsam geplant. Die Tische wurden so aufgestellt, dass eine direkte Kommunikation vereinfacht wird, Beamer für Präsentationen, Code Reviews (oder aber auch manchmal Skifahren), Konferenzen. Ein eigener Besprechungstisch, zur Unterhaltung ohne PC. Auch ist es mittlerweile sehr grün. So mancher mag nun lächeln (was auch gesund ist), aber selbst Duftkerzen haben ihren Weg ins Büro gefunden. Auch sonstiger Dekor darf nicht fehlen, obwohl wir ein reines Männerbüro sind.

Dies wirkt sich nur in kleinen Teilen auf die tatsächliche Kommunikation aus, jedoch ungemein auf das gesamte “Raumklima”.

Kopfhörer

Musik ist heute immer und überall. Gerade am Arbeitsplatz ist man schnell dazu geneigt, einen Kopfhörer aufzusetzen. Für komplexe Problemstellungen ist es ein einfaches Mittel zur Abschottung und Fokussierung. Nachteilig daran ist jedoch, dass dies schnell zur Gewohnheit wird und das Team die Arbeitszeit mit aufgesetzten Kopfhörern verbringt. Wie also bereits angesprochen: Alles Einzelkämpfer. Keine gute Ausgangslage für eine funktionierende Kommunikation.

Als Lösung haben wir uns darauf geeinigt, einen Medienserver inkl. Boxen aufzustellen. Musik aus unterschiedlichen Genres wird darüber gespielt (damit für jeden etwas dabei ist, wobei sich glücklicherweise unser Musikgeschmack deckt). Kopfhörer sind - laut Team-Bescheid - nur mehr für Spezialfälle vorgesehen.

Team-Chat

Neben der täglichen Arbeit läuft ein Team-Chat über den in den letzten Jahren sämtliche Fragestellungen/Probleme/etc. abgehandelt wurden. Hierbei spielt auch mit, dass mein Team über zwei Standorte verteilt ist und so eine einfache Kommunikationsmöglichkeit geboten wird. Das bietet zwar den Vorteil, dass innerhalb der Nachrichten gesucht werden kann, aber dies bringt auch einen gewaltigen Nachteil mit sich: Vielfach werden wichtige Fragen einfach nicht beantwortet. Dafür gibt es viele Gründe:

Man will aktuell nicht gestört werden
Es ist einem schlicht zu blöd jetzt eine Antwort schreiben zu müssen
Die Benachrichtigungen wurden deaktiviert
Etc.

Mittlerweile haben wir den Team-Chat noch für wichtige Ankündigungen, mehr aber in Wirklichkeit auch nicht mehr. Vielmehr ist es nun so, dass jemand mit Frage aufsteht, seine Frage an das Team formuliert und sich einige Minuten später wieder mit einer Lösung hinsetzt. Die anfängliche Befürchtung ständig aus der Arbeit gerissen zu werden hat sich nicht bewahrheitet. Es kristallisiert sich heraus, dass die Fragen immer weniger, dafür jedoch schwergewichtiger werden. Durch die Diskussionen um die beste Lösung wird sehr viel Wissen transferiert, das dem gesamten Team zu Gute kommt. Entsprechend verlagern sich auch die Themengebiete der Fragen.

Da war doch noch etwas: zwei Standorte. Im ersten Schritt versucht der Standort selbst seine Frage zu klären (die Ergebnisse werden in diesem Fall jedoch schon über den Team-Chat mitgeteilt), ist dies nicht möglich gibt es ein “Online-Meeting”.

Online-Meetings

Wie bereits angesprochen: Mein Team ist über zwei Standorte verteilt. Dies macht Meetings nicht gerade einfacher. Ein klassisches Online-Meeting-System haben wir nicht im Einsatz. Bis dato wurden alle über den gewählten Kommunikationskanal angerufen, saßen vor ihren Rechnern mit Kopfhörer und haben mehr oder weniger am Meeting teilgenommen. Eher weniger.

Auch dies läuft nun anders: Bei Meetings setzen wir uns nun alle gemeinsam an unseren Besprechungstisch, oder stellen uns einfach zusammen (wie wir das in unseren Standup-Meetings machen - was Ralf im Übrigen nicht gut findet). Laptops sind nur für den “Schriftführer” zugelassen, es soll keine Ablenkung geben. Damit die Übertragung des Gesprochenen gut funktioniert, haben wir uns ein 3-teiliges Flächenmikrofon gekauft und ausgelegt (anfänglich haben wir günstigere Lösungen probiert, die alle nicht zufriedenstellend funktioniert hatten).

Im nächsten Schritt werden wir wohl auch ein wenig in Richtung Videoübertragung gehen um die entfernten Teammitglieder noch besser eingebunden zu haben.

Gemeinsame Aktivitäten

Als nächsten Schritt unternehmen wir nun monatlich etwas gemeinsam. Nur das Team. Nicht weiter aufregend: Wir gehen Steak essen. Wie Männer das gerne tun. Die ungezwungene Atmosphäre, das lockere Beisammensitzen, das Besprechen von Anliegen auf neutralem Boden ist ein gewaltiger Nährboden für das Zusammenwachsen des Teams.

Unser Unternehmen veranstaltet zwar in mehr oder weniger regelmäßigen Abständen größere Zusammenkünfte mit gemeinschaftlichem Essen, Wettkämpfen und mehr. Es ist jedoch extrem wichtig, dass jedes Team für sich selbst auch einen Weg und ein paar Stunden Freizeit findet, in kleiner Runde etwas zu unternehmen. Auf Dauer gesehen bringt dieser Aspekt aus meiner Sicht am meisten. Es verändert sich der tägliche Umgang miteinander merkbar. Dabei geht es weniger darum Freunde für’s Leben zu finden, sondern sich vielmehr auf eine gemeinsame Basis der Kommunikation zu “einigen” - was im übrigen automatisch passiert.

Fazit

Natürlich hat es noch weitere kleinere Änderungen gegeben, die angesprochenen waren mitunter wohl die größten bis dato. Jedes Team hat andere Baustellen die man erkennen und aktiv (vor allem gemeinsam) angehen und lösen muss. Da mag man durchaus zeitweise ratlos durch die Gegend laufen, aber es gibt Möglichkeiten und die einfachsten ist dann doch meist die besten. Weniger Egoismus und mehr Gemeinschaft im Team birgt für jeden Vorteile, vor allem aber enden Anschwärzungen, das Herumreiten auf Bugs anderer und gar schlimmere Vorkommnisse. Es tritt ein “Gemeinsam machen wir etwas wirklich tolles” in den Vordergrund. Der Grundstein für eine positive Weiterentwicklung.

Hast auch du zu diesem Thema etwas aus deiner Erfahrung zu berichten? Arbeitest du auch in einem Team mit “offenen Wunden”? Oder habt ihr diese bereits gelöst? Ich würde gerne davon erfahren!

31 días de Windows 8 | Día 13: Navegación

La Liga Silverlight — 2013-03-28T20:15:04

Este artículo es una traducción de “Día 13: Navegación” de Jeff Blakenburg. Puedes encontrar aquí la versión original en inglés. Hemos pasado los últimos días enfocándonos mucho en actualizar el sistema con información para permitirle saber al usuario que es lo que sucede. De hecho, en los primeros 12 días esta serie hemos pasado muy poco tiempo hablando de una de las actividades más comunes que vamos a encontrar en el desarrollo de Windows 8: La navegación entre páginas con XAML. Hoy corregiremos lo que estaba incorrecto metiéndonos en este tema. Hay tres escenarios específicos que quiero asegurarme de cubrir en este artículo: * El simple acto de navegación de la página A a la página B. ¿Qué sucede entonces y qué información está disponible para nosotros? * Pasar información de una página a otra. Esto no solo incluye cadenas y enteros, podemos pasar también objetos enteros entre páginas. * Guardar el caché de las páginas. Cuando un usuario presiona el botón de retroceso, ellos no quieren descubrir que toda la información que ingresaron ha desaparecido. Discutiremos esto más adelante. Navegar entre páginas en Windows 8 XAML Parece que cada vez que encontramos una nueva plataforma hay también una nueva [...]