Command line and vso-agent

Written to the tune of:

A while ago Microsoft released this wonderful thing called the VSO agent – a cross-platform build agent that you can set up on MacOS X and/or Linux and hook it directly to a VSO or TFS instance to handle automated builds with a lot of customization options. You can get it here.

So here comes the challenge – more often than not, the build agent should be automatically set up, but the documentation mentions that the instance details, such as the service URL, username and password are manually entered. Not exactly what you want to do in an automated scenario. The good news is that there is a (not so) secret option to use command line parameters for the vso-agent:


Voila! All of a sudden, you can include this in your deployment scripts.

Read More

Release of Hummingbird – distribution list converter

With the release of Outlook Groups, I got a lot of questions regarding the possibility of conversion of existing distribution groups to the new model. Instead of having users manually go through the process, I wrote a sample that demonstrates how it’s done with the help of EWS and Active Directory APIs. So how do you set it up?

Clone the repository here: You will get the project file with the associate source files. Open the project file (Hummingbird.csproj) and save the Visual Studio solution. Next, click on Manage NuGet Packages…

Visual Studio Screenshot - Manage NuGet Packagesimage

In the package manager, notice that there is an alert notifying you about the fact that you need to restore missing packages. Click on Restore.

Visual Studio 2015 - Restore NuGet Packagesimage

Once you have the packages restored, you can build the project and run the application:

Hummingbird - Main Screenimage

From here on, you will be able to use the application directly with O365. Click on Settings to configure all application parameters:

Hummingbird - Settings Screenimage

For the username, use the standard O365 email address. The server URL for the main EWS endpoint is – make sure that you also select O365 as the target. Once you enter both the credentials and the server information, click on the respective Save buttons.

Moving forward, you will have everything required for migration. On the main page, you can enter the alias of the DL (skip the domain) and click on Create Backup. The output (as long as the alias is resolved) will be an .xmldl file that contains the original alias, DL owner and list of members. Hummingbird will not automatically delete the distribution list for you, so nothing to worry about. You can use this .xmldl file in the next step when you will create the group. If you want to preserve the alias, you will need to manually delete the DL first. Otherwise, the new group will be created with the new alias and a list of members from the original DL. Every member of the new group will receive a welcome email upon completion.

If you run into any issues, open a new bug on GitHub.

Read More

In between usage and engagement

In a world where everyone is trying to collect and analyze data about their product, it is easy to get excited about numbers. After all, getting hard numbers about what you shipped is, in a way, validating or invalidating the provided value. The problem comes down to those numbers being presented in an exciting, or worse – misleading, way (refer to a16z’s 16 more startup metrics).

The two terms that I often hear being thrown around are usage and engagement. Now, there is, of course, nothing wrong with leveraging both to make decisions, but it is important to keep one thing in mind – they are not the same. So whenever these two terms are used interchangeably, intentionally or not, a mistake is made that loses the key differentiator between them and can potentially create a false sense of security when the product is failing to hit its actual performance indicators.

Usage is a value that describes a number of certain actions taken against a feature, or the product as a whole, that do not represent the actual usefulness of either. For example, number of clicks on a specific button as a standalone metric is pure usage. How many times a user clicks on a profile picture? Usage. Number of downloads? Also usage. None of this maps 1:1 to engagement. Because you have sixteen thousand clicks on a button means nothing for how much value it provided to the user – for all we know, the user might’ve been frustrated enough where he or she clicked a couple of times and quit the app. Great, so now you have clicks, but an unhappy user. See where the issue is?

On the other hand, engagement measures user interaction with the product in a much more holistic way, where it ties in a lot of what we discussed earlier. As an example, think of it as a way to correlate time spent in the product, feature usage, number of returns to the product in a day and conversion rate (read: user achieving a goal established in the product). Now, looking at the high-level picture, you can see just how much your product is achieving in terms of business goals.

So we end up with this:

Usage and Engagement
Fig. 1: Usage is nested within engagement.

Usage is a component of engagement. Not a synonym of it.

Read More

DubHacks 2015 (or why you should attend DubHacks 2016)

It’s Sunday night and I just came back from University of Washington, where we just closed the Fall 2015 edition of DubHacks. And all I can say is that it was, hands down, the most fun and rewarding hackathon experience that I managed to be a part of.

First, and the most important lesson – always let James Whittaker deliver a keynote. If there is one person who can energize a crowd of 600+ people in an auditorium, there really is no better choice than him (also, read this). Second lesson – caffeine is your best friend through 48 hours of hacking, but in reality it’s the people that are there. I came in as a mentor with Microsoft, but I ended up having an amazing time with students and many other professionals, all with different backgrounds and experiences, as cliché as it sounds. But really – every single person that I met there were amazingly passionate, smart and full of boundless energy.

So why was DubHacks so great?



Do you know what is the best college campus in the country? Spoiler alert, it is UW. According to, it’s #20 in the list of the most beautiful campuses. Trust me, it’s not. It’s #1. What stood out is that even though it was during a football game when we started (go Dawgs!), there was plenty of parking available both in the Red Square and the adjacent lots. Despite being a huge campus, it is really easy to navigate – there are maps placed around that can always tell you where to go, which ended up being extremely helpful for attendees. Did I mention the fact that the entire event was spread across three buildings?



DubHacks successfully managed to get the best and the brightest from UW, a couple of other colleges in neighboring states – we even had an entire bus with students coming from University of British Columbia (Vancouver, BC)! In addition to that, we worked together with an extremely talented group of mentors – experts in Azure, web backend, web frontend, Windows Apps, IoT, Machine Learning and many others. And throughout the night and the following day we handled a huge influx of question on how the above technologies fit into a wide variety of projects (my phone died by 3AM from all the questions coming in). To be honest, it was also a tremendous learning experience for myself – I don’t think I’ve coded as much for Android as I did in these two days to learn about ways to integrate Mobile Services into photo-identifying applications.

Icing on the cake was the honor to look at the projects students presented as an expo judge – every single table that I stopped by to grade the project was not giving the slightest vibe of a two-day project. Which brings me to my next point.



The participating students really showed what they are up to in college – doing some serious hacking in and out of class. I’ve seen an electronic frisbee trajectory tracker, an app that automatically calculates and learns about the types of pizza your coworkers might want on a certain day, an entire system that uses Kinect to analyze how distracted a driver is when on the road, a game that is asking its players to find certain objects and up their score by scanning those directly with their webcam (all in the browser, by the way), tools that can generate videos from text (which, by the way, won first place), a project that will reward users with BitCoin for biking (while it’s mined on an Azure VM – the more you bike, the more cores the VM spins up and the more BitCoin you make) and many many more. It’s absolutely mindblowing just what skills all people here posses, and I am excited to see where they are going to take those (*cough*Microsoft is hiring*cough*).

Everything else




Food trucks (thanks Microsoft!), lip sync battle, piroshki, cup stacking, good music, stickers, more good food (read: Chipotle catering), frisbees, raffles and everything there is great about hackathons – all exceeded expectations at DubHacks. Above all, mad kudos go to the organizers – @MahirK95, @nitrogen, @skylerkidd and @MaliaImayama.

If there is one hackathon that you want to pick to attend in a year, look no further than this.

Read More

Non-Store Windows Phone Apps: Integrate With the Settings Hub

Let’s say you are developing an application that needs to integrate in the Settings Hub. For most applications, this is not at all necessary – if you are not altering the behavior of the device (e.g. through global settings that go beyond the application), you do not need to do this. However, for experimentation purposes, it is, in fact, possible to integrate your app in there.

NOTE: I’ve already talked about this in my StackOverflow answer, but putting together this blog post for documentation purposes.

First step, create a new Windows Phone application. There is no difference in the type of the application that you are creating, but since this is a simple demo, I am going to go ahead and create a blank app:


Without making any changes to the app, run it on a device or the emulator. Notice that by default, the application is listed along with all other applications, so nothing out of the ordinary at this point.


If you are already working with Windows Phone, you should know that the application placement in terms of launch location is determined in the application manifest file (WMAppManifest.xml). By default, and if you are using the latest Visual Studio + Windows Phone SDK couple, you will get the ‘visual designer’ for the manifest.


Not exactly what’s needed for the purpose of this post, because we don’t have a way to modify the target launch ‘hub’. Instead, right-click on the manifest file in Solution Explorer and select View Code:


What I need here is a HubType attribute, that is not listed by default:


So just adding it in there, with the target value of 268435456 will do the trick. However, be aware that since you already deployed the application as a ‘normal app’ (belonging to the standard launch hub), you need to make sure that you uninstall the app first, and then re-deploy it, for it to appear in the Settings hub. Notice the change:


There is no simple way to uninstall the app from the Settings Hub, however, because there is no ‘tap-and-hold’ way to pick the ‘Uninstall’ option. The way to do it would be to re-deploy another app, with the same ProductID (from WMAppManifest.xml). Even if you use the same application with HubType removed, you will need to create a different one to replace it.

Read More

To the Incoming (and Maybe Current) Computer Science Majors

As someone who is almost (and by almost, I mean months away) from finishing my undergraduate program and starting as a full-time Program Manager at Microsoft, I feel like the past 4 years have really been life-changing for me, both from personal and professional standpoints. It’s been a rollercoaster, and I happened to be lucky every second that I’ve been on it. This is a story, that can be considered both a “thank you” letter to the university that welcomed me (I can easily thank Anthony Wu for giving me that idea through his post), and as a list of items you, the reader, might want to tackle before you graduate. If you already graduated, you can take a couple of minutes to go over the experiences I’ve had for purely entertainment purposes. It’s obviously reflected through my own prism of understanding and years of cultural and educational baggage, so I can’t guarantee that everything I put here will apply to you. As a matter of fact, maybe nothing will apply to you at all, so consider this as merely a reflection on how thankful I am for making sure that I got the outlined bases somewhat covered.


Let’s begin with some background information. I was born in Eastern Europe, in an academic family, where both parents insisted I knew how to use computers from a very early age. At age 7 I got my hands on my first PC, and so it happened that there was a Visual Basic 6 book laying around. That’s when I realized that making machines do big things should be my life goal. Fast forward to 2008, I got the fantastic opportunity through a program sponsored by the US Department of State called FLEX (Future Leaders Exchange Program), which gave me the possibility to spend an academic year in a high school in the United States. Moving across the globe was an adventure in itself, but what surprised me the most is how much opportunity there is in my field here, in the US. Nobody cared that I was a student, I could participate in a multitude of IT and CS competitions, build websites, get professional hands-on training right in the classroom. I was shocked. I had none of these opportunities back where I came from. I knew I could do more, so once I got back in Europe, I decided for myself that I want to go back to the States and pursue a degree in Computer Science.

Skipping the logistics, I ended up at Wichita State University. After tens of credit hours, two internships and with a full-time offer in hand, I though I’d put my experiences on digital paper, and it could be that the next Bill Gates will be reading these right now. So here goes.

1. Computer Science programs can be wildly different from university to university.

Maybe you already chose your university, maybe not. Regardless, the quality and focus of CS programs differs. Professors differ, the approaches differ, the way material is presented is different, and more than that – your ramp-up in the professional world might somewhat differ if you plan to mostly rely on the career resources offered by your university. More than that, your level of internal (academic) involvement in the field of Computer Science will depend on a lot of opportunities, such as undergraduate research, so make sure that you look at those when learning more about the program.

WP_000049 (1)

In my own opinion, the ranking of a specific program on a national level doesn’t really matter, as long as you know that you can be successful with the opportunities extended through your engineering department. I’ve been lucky enough to be a part of the Software Engineering Research Lab, here at Wichita State University, from which I benefited immensely. It gave me the possibility to play more in the field of NUI (Natural User Interfaces) and it introduced me to a software development field that I barely knew just a couple of years ago. Every university has a list of faculty, so reach out and find out how the CS program can be beneficial to you.

2. It’s totally okay if some classes seem “too easy”, but that doesn’t mean you should be easy on yourself.

I have to admit, a lot of classes seemed to easy when I started, some still are even though I am a senior. “Introduction to C programming”, where we learned to build “Hello World” programs, or “Introduction to Database Systems” that is technically classified as a grad/undergrad course, covering basic database structure and SQL syntax – all this does not seem extremely challenging. And that is okay. I’ve been lucky to have the resources to be self-taught, but not everyone is in the same boat. These courses are obviously a graduation requirement, there is no way around it. But it’s up to you what you’re going to make of it. Remember one thing – don’t waste your time. Playing Angry Birds in class might be fun, but while you do that, someone else will be building the next big thing. Instead, submit your assignments early and work on your own projects. There are millions of dollars waiting to be made through apps and other products, so might as well start early.

3. Learn on your own.

Stemming from the previous point, you should not limit yourself to just the material offered in class. I have to admit, what I know now didn’t come from class. Programming C#, C++, the fundamentals of DirectX and shaders – none of that was in my CS curriculum. Learn more programming languages, try different operating systems, create apps, contribute to an open-source project, read tech books, spend sleepless nights trying to debug that web service that fails every single time when someone tries to upload a video larger than 200MB. Learn. There are plenty of opportunities out there – Khan Academy, Coursera,, Stanford Engineering, MIT OpenCourseWare, Channel9 (shameless plug, I know). Everything is a click away. Learning the basics about binary trees and graph theory is important, but it’s even more important to be able to apply it in a real project. Consider classes as your basic “here is what you can do” guide, and it’s up to you to actually do something with it. During your interview, rarely will you be asked what is insertion sort – instead, you’ll probably have to talk about your extracurricular projects.

4. Projects > GPA. Build something.

As a follow-up to #3, when you’re going to interview for internships (or maybe full-time positions), you rarely will be asked about your GPA. Mine never made it on my resume. Grades are important, don’t get me wrong. I am not trying to suggest to ditch classes and instead sit in your room and code all day, not at all. If anything, your grades are a direct reflection of your efforts, and often times – knowledge (with rare exceptions). With that in mind, balance your academic effort with your passion for the field – really, just 30 minutes of brainstorming will give you a 2 page paper of what you can build. Don’t be scared by the fact that something is unknown to you – do your research.

5. Challenge yourself outside the field of Computer Science.

You’re passionate about software, building software, testing software and improving it. That’s great, but that’s rarely the only skill you will need in life. College is a great opportunity to get out of your comfort zone and build a set of skills that will prove invaluable in more than one area. Public speaking competition? Do it. Debate? Do it. Chance to MC an event? Do it. Every university will offer you a diverse set of opportunities that you can take advantage of, so make sure you glance at announcement boards outside your engineering department. More than that, join a student organization that isn’t necessarily related to engineering or computer science – there really isn’t a better way to make friends of all majors and backgrounds and be a much bigger part of campus life than you would be otherwise.

6. Participate in hackathons.

To give you a couple of big examples:

There are obviously more, and you can find a detailed (although, not necessarily complete) list here. Hackathons are a great way to build prototypes in conditions where you have limited resources in terms of time, and unlimited resources in terms of technologies. Look at those as both a social and learning experience, where you have the opportunity to improve your knowledge of a variety of hardware and software platforms, showcase your abilities to potential employers, start your own venture and maybe win some prizes and cash. For major hackathons, you can get partially reimbursed travel as well.

7. Find an internship as early as possible.

An internship has several benefits for you. First of all, you get to know what working in your field of choice is like. You might think that Computer Science implies one thing – you will have to be a software engineer (programmer), but there are more ramifications in the field than you might think. For example, Microsoft offers you three core paths – Software Development Engineer (SDE), Software Development Engineer in Test (SDET) and Program Manager (PM). You can learn more about them here. Each one has different sets of responsibilities and tasks, and an internship is a great way to experience each of these to see where you fit best. Even better, since we’re already following the Microsoft example, there exists the Explore Microsoft Program (limited to freshmen and sophomores), which essentially is a way to rotate you through all three roles in the course of a single internship period (12 weeks is standard).

Meeting Kurt DelBene, at the time president of the Microsoft Office Division.

I rotated through two roles – I started as a software engineer, working as vendor for DPE. The next summer, I switched to the Program Manager role in the Office division. Getting the experience from both sides of the spectrum made me realize that I can better combine my programming and communication skills in the PM role, so make sure you get an early start to have a better understanding of what you want to do post-graduation.

8. Write. Publish. Write some more.

I owe this blog more than one can imagine. To some extent, you can say that my professional career started from “den by default”, when I first got noticed by Clint Rutkas of Channel9 Coding4Fun for publishing a blog post, documenting the Zune Web API (now available here). Also, with a lot of Windows Phone content published here, I managed to become a Windows Phone Development MVP, which resulted in even more exposure and professional opportunities. It’s a relatively inexpensive investment in your future, with potentially large benefits.

9. Don’t be afraid to reach out and network.

Meeting Dennis Crowley, founder of Foursquare, at the ImagineCup finals in New York City

One of the most important assets that you can get out of your college post-graduation is your network. There are different ways to do it. You can join your local user group, attend hackathons (refer to #6), help run campus events, attend conferences (a lot of them have academic discounts), reach out to project leads – if every other of the above mentioned 8 points is something you’re following, you are already starting to build connections. You would be surprised how much that will help you in the long run, whether you decide to start working full time or continue your academic career.


All in all, a single blog post is obviously not enough to outline all my experiences. Enjoy your time in college and make sure you are making the best of it, because that’s about the only time in your life when you will have such a vast number of opportunities in all fields imaginable.

As I am moving forward on my professional path, I would like to recognize the fact that I couldn’t have done it without the help of many people. Members of the Channel9 team helped me set my foot in the door at Microsoft, and the fantastic team I worked with at Microsoft this summer, that helped me understand the importance of technical knowledge being combined with good communication and presentation skills. I am thankful to every single professor at Wichita State University, that took their time to share their bits of knowledge with me. I am thankful to my two families, the one over the ocean, as well as the American one, that helped me every step of the way. I am thankful to my friends in Wichita and all over the United States, that supported me despite my preferences for blasting EDM all day and watching SNL at the highest volume possible.

I am lucky, and I hope that my experiences will be an encouragement for someone else.

Read More

Building a Notification Hub for Windows Phone on top of Windows Azure Mobile Services

For most applications, notifications are not exactly critical. Granted, a scientific calculator will not benefit from having an in-app notification hub. On the other hand, there are cases when you want to let the user know about what’s new and what changes before an update or including information in the changelog. That’s where a custom notification hub control can come in really handy.

What goes into a notification?

Before jumping to actual coding, let’s think about what actually should go in a notification. We obviously want to display the information in the form of the simplest message possible. A title and a description should do it. But a notification also usually implies that there is some action tied to it, be it opening another application or a third-party location. So maybe including a URI would be another valid addition. All in all, we end up with this layout:


Fantastic. You can see that there are two extra properties that I haven’t mentioned – Id and TimeStamp. Since Azure Mobile Services are used, one of the core ways to determine the identity of an entity is by its unique integer identifier in the data table – Id takes care of holding the proper value. The TimeStamp property might not carry a unique value, but will tell the user when the notification was created. Ultimately, in the application itself it is possible to set filters to only show notifications from a given date range, but that’s a different topic.

In C# code, the class above will look like this:

using Microsoft.WindowsAzure.MobileServices;
using System;

namespace Hilltop.CoreTools.Models
  public class Notification
    public int? Id { get; set; }
    public DateTime TimeStamp { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    public string Url { get; set; }

Notice the reference to Microsoft.WindowsAzure.MobileServices – make sure you install the Azure Mobile Services Windows Phone SDK in order to be able to use it. I personally prefer using NuGet for this, so feel free to use this command to get the package:

PM> Install-Package WindowsAzure.MobileServices

The Core Control

Now that there is a defined notification model, I can start working on the core control itself. I’ll start by defining the skeleton via a INotificationCenter interface:

 using System.Threading.Tasks;

namespace Hilltop.CoreTools.Interfaces
  interface INotificationCenter
    void Initialize();
    void GetCurrent();
    void Clear();

    Task CreateNotification(string title, string content, string url);

GetCurrent will handle the acquisition of the current notification stack, Clear will erase all existing notifications and CreateNotifications will help the developer create notifications directly from the app.

SECURITY NOTE: It is important to remember, however, that notification creation should probably be secured – the way the notification hub control works, it provides a unified “connector” to the service and it is up to the developer to have the proper separation of roles and capabilities available to different app user categories.

Without going into the boring details of dependency property registration, here is what the ultimate class for the NotificationCenter control will look like:


Notice that I have MobileService declared in the Fields section. This is nothing else but the core managed Azure Mobile Services client. By default, it is null:

 public static MobileServiceClient MobileService = null;

We have an entire set of properties that determine the appearance of the notification entity in the global notification list. It is possible to set the icon associated with a given notification (usually taken from the context of the application itself but can be remote as well) as well as the colors for the content displayed.

Most important, however, is to have these two properties: ZumoKey and ZumoUrl. These will be used by the managed client to connect to the specific Azure Mobile Service instance and retrieve the data.

When the control is loaded in the visual tree, a call to Initialize (this is not the same as InitializeComponent) is made, that will try to connect to the service and retrieve any pending notifications:

 public void Initialize()
    if (!string.IsNullOrWhiteSpace(ZumoKey))
        if (!string.IsNullOrWhiteSpace(ZumoUrl))
            MobileService = new MobileServiceClient(ZumoUrl, ZumoKey);

            throw new InvalidOperationException("Missing ZUMO URL.");
        throw new InvalidOperationException("Missing ZUMO key.");

When it comes to GetCurrent, it will simply populate the Notifications collection with the data returned by AMS:

 public async void GetCurrent()
    if (MobileService != null)
            var data = await MobileService.GetTable().ToListAsync();
            Notifications = new ObservableCollection(data);
            // Failed to obtain the list of current notifications.

Post-initialization, we want to let the user know that the control is ready, so I’ve added the Ready event handler. Here is how it will be invoked once the control has finished the first iteration of the loading routine:

 void NotificationCenter_Loaded(object sender, RoutedEventArgs e)

    if (Ready != null)
        Ready(this, new EventArgs());
        this.Loaded -= NotificationCenter_Loaded;

Great. However chances are that at this point you don’t have any notifications available. CreateNotification would be exactly what you need:

/// Allows notification insertion directly from the client app.
///Notification title.
///Notification content.
/// TRUE if insertion is successful. FALSE if not.
public async Task CreateNotification(string title, string content, string url)
    Notification notification = new Notification();
    notification.Content = content;
    notification.Title = title;
    notification.TimeStamp = DateTime.Now;
    notification.Url = url;

    if (MobileService != null)
             await MobileService.GetTable().InsertAsync(notification);
             return true;
             return false;

     return false;

Thanks to the amazing work done by the Windows Azure Mobile Services team, all you really need to do is create a new instance of the Notification model and push it to the aforementioned MobileService client.

As I also mentioned earlier, we’d want the notification to be interactive and actually point to some sort of a resource, that is represented with the help of the Url property. To do this, we handle the notification item selection in the list:

 private void NotificationSelected(object sender, SelectionChangedEventArgs e)
    if (e.AddedItems.Count > 0)
        Notification notification = (Notification)e.AddedItems[0];

        WebBrowserTask task = new WebBrowserTask();
        task.Uri = new Uri(notification.Url);

The WebBrowserTask will use the built in browser (Internet Explorer) to open the associated page. Simple as that.

What do I need to set up in the AMS dashboard?

Not a whole lot. First of all, make sure that you create a new table that has the same identifier as the DataTable attribute in the Notification class. In the example above, I am using notifications as the name, and it is used like that in production with Beem and EnTrance:


During development, you might also want to enable Dynamic Schema:


SECURITY NOTE: It is important to disable dynamic schema before your app goes in production.

How do I use the control?

Use the standard XAML syntax in one of your pages:

 <ht:NotificationCenter NotificationIcon="/Images/notification.png" ZumoUrl="YOUR_URL" Ready="NotificationCenter_Ready" ZumoKey="YOUR_KEY" AbsentNotificationsColor="White"></ht:NotificationCenter>

And there you go:


You can download the source code for the control here (ZIP file).


Read More

DI.FM in a New Dimension – Beem Plus 2.0 is Out

At this point in time, Beem Plus has established itself as the de-facto DI.FM client for Windows Phone, although unofficial. With more than 45,000 downloads all over the world, I feel like this project is filling its niche pretty well. That being said, I don’t want to have the app “frozen”, so updates are a crucial part in delivering a better user experience and additional capabilities that would make the listening experience as streamlined as possible. So here it is – Beem 2.0.

I am proud to say that this release is by far the most stable and fast, but the focus was more on improving discoverability and ease-of-use. The motto for the 2.0 release was “Simplify, simplify” (quoting Thoreau on this one). Take a look at the 1.9 main page:


Although seemingly nice and well-organized, there is no structure to where a station should be. Let’s say you want to find Dubstep. Or Trance. Or maybe Progressive. What is the first idea that comes to mind when you need to look it up? Probably just scroll through the list and hope that you are lucky enough to stumble across what you were looking for. I wanted to eliminate this pain. With 2.0, no matter what – you will always get an alphabetized list of all stations:

2013-10-02 12.40.35

Neat. Notice that it’s clear and to the point – you know what to find and where to find. The same happened to the list of favorites. For comparison purposes, 1.9 content is on the left, and 2.0 is on the right:

2013-10-02 12.50.01 2013-10-02 12.40.41

First and foremost what comes into play is consistency. I noticed that the station description does not really add much value to the UI, specifically to the Favorites section because the users that have added a specific station to the list are already well-aware of what that stream will be about. There are a couple of extra changes here too. There is no longer the tap-and-hold option for either the main station list or the Favorites list. As analytics have shown, that is a capability that is barely used, mainly because of discoverability problems – people simply don’t know that you can tap-and-hold to get the ability to pin a station to the Windows Phone start screen or to add/remove it from favorites. So instead, this ability went away. But don’t be alarmed – it is still present in playback mode. Which brings us to the next set of changes – the “now playing” screen.

Let’s compare the amateur 1.9 build versus the pro 2.0 build:

d08e8af9-b444-4a19-83e3-769ff4962f67 2013-10-02 12.41.06

Whoa! On the left, there is an absolute information overload. What does the bag icon do? Is the pin going to add this station to favorites or actually get me out of Beem Plus and pin it to the home screen? Instead, I removed all that clutter to let the user focus on what’s important – the station that’s being played and the tracks in it. You can still record and add the station to favorites from the playback bar, but the rest is now hidden in the application bar, with a bit more context sprinkled on them:

2013-10-02 12.41.11

In addition to that, Beem Plus now supports an additional sharing option – via NFC, which stems from another added feature – bookmarked tracks. If you look at one of the 2.0 screenshots above, you will notice that the list of tracks is now easier to tap on, with clearly separated data related to the artist and track name. Once you tap on the track, the user will be able to select a couple of options:

2013-10-02 12.41.21

The track can be searched for on Xbox Music or Nokia Music (even on non-Nokia Windows Phone devices), giving the user the ability to purchase a song that he or she liked on that specific station. But there is also a star “Save” button, that gives the ability to simply bookmark the track and keep it in a personalized list:

2013-10-02 12.40.45

With NFC activated, you can share the currently playing track and send it to another Windows Phone device running Beem Plus 2.0 – once tapped, the track that was just shared will become a bookmark that can be later used to find it in any of the supported stores. I’d like to mention that Beem Plus does not offer track download capabilities – it merely keeps the track metadata that later will help you identify the channels where it can be obtained.

In addition to visual changes, Beem Plus 2.0 includes multiple bug fixes, reducing the possibility of the app crashing during a stream to a minimum. It still supports scrobbling and SkyDrive uploads of the recorded streams for backup purposes. You can get the app in the Windows Phone Store, free as always. Also keep in mind that Beem is an open-source project, available on GitHub. If you’d like to provide criticism, feedback or suggestions – feel free to stop by the Issues Hub.

Read More

A State of Trance Podcast Fans on Windows Phone – I Present You EnTrance

After a sleepless weekend, here is the final product – EnTrance. It’s not really a big secret that I am a fan of EDM and A State of Trance is, hands down, in my opinion one of the best trance shows there is. With this in mind, I realized that there is way for me to easily managed the ASOT podcast on the device. Need creates ideas, so I though about building my own client that would let me aggregate the latest and greatest podcast episodes, with information about the collected tracks as well as with the ability for me to find those on Xbox Music, Nokia Music and YouTube.

Hence, EnTrance came to life.


What can it do at the moment? Pretty much everything you would expect a podcast app to do – download and play ASOT episodes. What I have planned for it is another question. Here is a short breakdown:

  • Upload to SkyDrive – what if you like an episode so much that you want to have it stored on your machine as well? Simply push it to SkyDrive and the deed is done – once your PC(s) sync the changes, you will find the episode in your folder.
  • Push Notifications – get alerts when new ASOT episodes are released and when new track information is available.
  • ASOT Full Show Integration – other than the podcast, every Thursday Armin van Buuren runs his ASOT radio show. Despite the fact that the episode itself is often not available for download, it contains track metadata. I want to show you that track metadata – with the ability to find those later on Xbox Music, Nokia Music or YouTube.
  • Event Information – ASOT 650 is coming up and I need to get the app ready for it.

It would be very short-sighted to say that this list is complete. It’s not, and will never be – such is software. If you have more ideas, feel free to stop by at the Issues Hub on GitHub (did I mention EnTrance is open-source?).

For now, pick up your Windows Phone 8 and download the app!

Read More

My Summer as a Program Manager Intern at Microsoft

I’ve once again spent my summer in the Pacific Northwest, working as an intern for one of the top companies in the world – Microsoft. I embarked on a journey in a completely different role for me – despite the fact that I coded pretty much all my life (or, as much life as a 22-year old adult can have) and was a Software Design Engineer vendor all last year (feel free to read the post I wrote back then), I decided that I should become a Program Manager (or a PM). Not because I didn’t like coding or, but because I felt that over the years I developed not only a passion for writing software, but also for communication, planning and management. A PM role combines those perfectly, so once the time came for me to apply to for my next internship, I didn’t hesitate to check the PM role as the priority on the Microsoft Internship application form.

Interviews went well and I got the PM position in the Microsoft Office Division the same day, right after the interviews. I expected quite of a contrast compared to Developer Platform Evangelism, where I made my baby steps in the huge world that is known as the Redmond Campus. I had exactly zero connections in the Office division at the time, so I didn’t have anyone who could tell me from their experience – what is the culture like, what is the approach to tackling a variety of problems? Regardless, I was really excited and was ready to start working as soon as I landed in SeaTac.

I got to be a part of an amazing team that did remarkable work. All three months went by like a flash, but since I was dropped right into the epicenter of all the action, here are some of the highlights  (or, things that stuck with me) that might  be helpful to future interns from the perspective of a starting PM:

  1. Relationships matter. When it comes to getting things done, you need to know the right people that have the authority and ability to contribute to your work. Talk to your teammates – not just those in the same role, but everyone on the team. When I was just ramping up, I sent out 1:1 invites to pretty much everyone on the team to get to know them better, to see what they were working on and what are the most interesting parts of their job. I have not gotten a single rejection, and so through all my 3 months, I had the occasional 30 minute meeting with one of the developers, testers or program managers in their office, where I could ask almost any career-related question. That way, I found out more about my team than any PowerPoint slide deck could ever explain. That’s also a good way for people to remember who you are – not just some intern working in the office around the corner. More than that, one of the PM leads on my team is a motorcycle pro, and after a few conversations with him, I discovered that bikes is something I would like to know more about. So don’t be shy – get to know people you’re working with.
  2. Reach out. Microsoft is a very diverse company, with people coming from different backgrounds and different experiences. Don’t hesitate to reach out to them, even if they are way above you on the management chain. I remember that one of the opportunities I never got the chance to take was meeting Alex Kipman, the man who started ‘Project Natal’ (better known as Kinect nowadays). After talking to one of my coworkers at Microsoft about my thought of meeting the Director of Incubation at Xbox, I was advised to do the simplest thing one could possibly think of – just email him. That’s it. No formal introductions, just an email explaining why I want to meet him and what I want to get out of the meeting. A couple of days later, I was sitting in the lobby of one building talking to Alex – and once again, I learned a lot more than I would ever read in any interview or article. A lesson I learned from Charlie Kindel is that a good way to look at a problem is through the “What’s the worst that can happen and what do I have to lose?” lens. So let’s say you want to reach out to one of the top people. What’s the worst that can happen? Probably getting a rejection email. What do you have to lose? Nothing. That is, if you are smart about what you ask for and are not trying to waste people’s time. So go for it – meet people and learn, learn, learn. A lot of Microsoft employees are excited about talking to interns about their experiences.
  3. Effective communication is extremely important. Be clear, concise and to the point. Again, I’m back to the idea of not wasting people’s time. It’s shockingly easy to derail a conversation or an email thread if a person starts throwing too many issues in at once, so be aware of that and contact only the people that are either responsible for what you’re talking about, or can point you in the right direction. Stemming out of the ‘good communication’ stack is also the ability to present your ideas in an efficient manner. As a PM, I had the responsibility of writing several specifications, an area plan and on top of that – present all of those to the team. I loved doing it, but that is not enough – you need to not only know what to present, but also how. Learn from what your teammates are doing, pick up a couple of books and go through them on a weekend. It will pay-off in the long run.
  4. Don’t work in a silo. Or, as my manager called it, window shop before making any decisions. It is important to realize that what you’re working on is not impacting just you. Chances are, other features or parts of the project flow are in one or more ways affected by what you create. Pinpoint those possibilities early and talk to the people who are responsible for the respective areas. For example, if I am writing a specification for a car steering wheel, I would like to talk to the designer to make sure that it fits with the overall vision of the vehicle interior. I would also need to talk to the engineer that designs the steering wheel connectors that hook into the electronics (e.g. changing the radio volume or honk) to make sure that my design will allow for everything that’s needed. I could, of course, throw together a document that shows the fact that my steering wheel is the best possible idea since sliced bread, and leave it at that, but chances are this will not make a lot of people happy and all the design issues will be raised at some point. Plan accordingly and communicate with the individuals covering the adjacent or larger features.
  5. Attend intern events. There are plenty of those – some organized by University Recruiting, but even more are ran by interns themselves. Hiking? Why not. Have a few people chip in on gas and you will be going to explore Mount St. Helens, Goat Lake or the Olympic Peninsula. Do not, I repeat – DO NOT, waste time on weekends by playing Xbox (or PC, whatever your preference might be) inside all day. Get to know people, explore the neighborhood, get people together and try a new Korean restaurant, go see a movie or a live concert (for me there’s Paradiso. the Capitol Hill Block Party in Seattle and Paramount, that had some of the best shows). There’s always something to do and you should take advantage of that opportunity. And yes, the deadmau5 and Macklemore concert was amazing on every level. Thank you, Microsoft!
  7. Read. One of the fantastic things I love about Microsoft is its library. I managed to read a dozen of books this past summer, that completely changed my views (The Power of Habit was, hands down, the most interesting one), and you should do the same.
  8. Focus on the success of your product and take pride in what you do. When I asked Kurt DelBene, the president of the Microsoft Office Division, as to what would define an exceptional Program Manager, this was his response. And indeed, every morning I was coming excited to work because I knew that my work will contribute to the success of the larger product. I was following my passion – it is an outstanding feeling when you realize just how much impact you really have.
  9. Unexpected things happen. Usually at the least expected time too. Be ready to change your plan and have a fallback scenario. “What can go wrong?” is a good question to ask yourself when you’re designing a feature, and once you have a list of possible issues, list the causes and think about a way to tackle those, so that at the end your work will continue, even when one of the foundation pillars failed.
  10. Be open to feedback. Ask for feedback. You can sit in your office all day, writing specs and presenting them, then going back to the office and carrying on with the work you’ll be doing. But that’s not really what your internship is about. You want to become better at what you do, learn from people who’ve been in the field for quite a while and adopt the best practices, avoiding the mistakes that maybe have already been tackled before. One of the habits that I have developed is constantly asking for feedback from my manager, my mentor and fellow PMs. How should I improve my presentation? What could have I done better? What potential issues do you see with my approach that I might be missing? Trust me, you want to know answers to those questions. Also, never be offended by direct feedback – your goal is to be exceptional at what you do, and the only way to do it is by ensuring that you are getting the least sugarcoated feedback. Expect it, and develop an action plan for yourself on how to act based on what you’ve learned.


At the end of the day, the internship is what you make of it. There is no book or blueprint that will guide you through it for 100% of the way. Will you make mistakes? Probably. But what you learn from those mistakes is what will make you a valuable employee at the end. Be active, be eager to learn and realize that your impact matters.

This August, I have accepted a return offer and will be coming back to Microsoft in 2014 as a full-time Program Manager, which I am really excited about – these are great times and I am happy to apply my knowledge and skills towards changing the world. If there is one last thing that I’d say – apply for a Microsoft internship. It is truly a life-changing experience.

Read More