Right before the end of the year, I wrote about my updated approach to recording Nest video streams without having to worry about the Nest Aware subscription by reading from the video stream directly with the help of a .NET-based application I wrote, called FoggyCam.
It's the perfect time to drink coffee, sit inside, and code. There was just one problem with that for me - I actually need to step away from my machine from time to time to brew some coffee, and while I was gone, the computer would go to sleep, and I needed to wake it up, enter my credentials.
It finally happened - after almost five years of sticking with macOS and a MacBook, I gave up and built my own desktop computer.
I recently moved all my development boxes to Windows. That’s right, all those Mac machines, with the exception of one that I need for testing, have been Boot Camp-ed to use the latest and greatest of the Windows 10 ecosystem. As part of this process, I started building some automation scripts - I’ve had that for macOS in the form of shell scripts that I could run whenever I re-installed the system, but nothing like that for Windows.
In the past couple of months, folks asked me how I got into product management. While everyone probably wants to hear an overly romanticized story about how this was my passion from an early age, the reality is much funnier - it was an accident. I never had any plan to be in product management, and yet, this is how I built my career. This essay is a story of how I got to be in the role I am today.
Sometimes, you code for the sake of coding, and build something that is just fun. Back in June, my good friend Dan Fernandez came up with the idea of a website that can create Zoom meeting screenshots that place people in the company of celebrities, animals, or the Brady Bunch. That is, we’re not cool enough to actually hang out with said celebrities, but we can at least pretend that we chat with them over Zoom, to the surprise of our friends and family.
I am using a Raspberry Pi device for experimentation purposes, and I had to temporarily enable SSH on it via the public Internet, which can be a monumentally bad idea if the machine where the service is enabled is not properly secured. The problem is less related to SSH itself, and more to the default configuration which is used by some folks. That is - they use passwords to authenticate.
Last week I mentioned that after six year at Microsoft I was leaving the company to pursue a new adventure that would push my growth and skills to new levels. To me, learning can only be done if I constantly push myself outside my comfort zone - I think today’s decision does this. I am happy to announce that starting today I will be joining Amazon Web Services as a Senior Product Manager, Technical on the Amazon EventBridge team, making serverless and event-driven infrastructure more accessible and developer-friendly.
Jeff Sandquist, CVP of Developer Relations at Microsoft, once said that “change invigorates the soul”. Working with Jeff’s organization was one of the highlights of my career - collaborating with some of the smartest folks in the industry, shipping things that have an impact (also known as docs.microsoft.com) and being very closely aligned with developer needs. I’ve been at Microsoft for close to six years, and I always felt like I am never the smartest person in the room - the sheer caliber of individuals that I had the honor of working with speaks volumes for the kinds of organizations that exist within the company.
TL;DR: Check the source code out on GitHub for the project. It’s a demonstration of how you can use simple components to build awesome tools. That’s right, you don’t need Kubernetes for this! Table of contents Introduction The basics Ingress Data store Rendering layer Building the tools SQLite database Ingress script Analysis notebook Conclusion Introduction I’m one of those people that needs data around the things that I do - there is just something fun about being able to quantify and analyze things.
Back in 2012, I had experienced a situation where one of my Git repositories (I will not mention any specific providers here) suddenly disappeared overnight, with no recovery options. And while I was able to restore some of the code from local backups, it was an all-around bad position to be in. You know how you’re always told to not put all the eggs in one basket? Who knew that it applies to code as well!
I was working on some data analysis recently, that involved me dealing with data snapshots. These are effectively point-in-time representations of specific data. For example, if you’d be dealing with the amount of items at a warehouse, you could imagine that you’d be taking a snapshot through the day of how many items you have available during each hour. That will give you a pretty good idea of the in-flow and out-flow of materials.
When building tools that authenticate against other APIs, more often than not I need to manage private keys and secrets. The challenge is that sometimes it’s very easy to forget the fact that the key is sitting somewhere in a configuration file, and it will be accidentally checked in to the repository. With the proliferation of tools like trufflehog, that’s generally not a position you want to be in. A lot of services are being proactive about it, and when a leaked key is detected, it will be automatically revoked (notice how it someone attempted to use it within minutes of the leak).
I recently discussed a topic that came up through a conversation with an intern I was helping - they were not familiar with the floppy disk icon as the metaphor for “Save”, and thought that it was a box of some sorts. As in - a box in which you put in stuff to “save it”. The next logical thing was for me to sit down and put together a list of things that I will fondly remember in the world of tech, that are likely to not be missed by the next generation as technology becomes much more convenient and frictionless.
This is somewhat of an open letter that I don’t usually write, but we really need to sit down and talk with Apple about account management UX. I am generally a pretty happy Apple user - the iPhone and the Watch are great. However, there is one lingering problem that seems to elude the user experience teams, related to subscription management. In 2020, when more and more services are moving towards a subscription model (Apple Arcade included - that is now a separate tab in the App Store), managing those in one place seems like a key part of customer experience, and Apple is uniquely positioned to address this problem.
One of the things that I am really curious about is analysis of publicly-available data. There is a lot of useful context that can shed a lot of light on some important happenings and trends. I’ve started with one of the resources that has a lot of rich, user-created content: Reddit. I also wanted to focus on a local implementation, that does not require me to sign up for a big data service, such as BigQuery.
Whenever we talk about documentation infrastructure, one of the most common pieces of feedback I hear from developers is that it’s too complicated to set up. There is just too much configuration, fiddling around and trying to make sure that the output is produced in way that is expected. That’s why back in June I set out to build a documentation CLI that allows one to produce docs with one liners.
You probably heard (or read) a post I wrote back in July about how we built docs.microsoft.com/samples - I talked about some of the foundational elements and the process which we followed to build the site. Now that we’re a couple of months in, I thought I would take a step back and write about some of the lessons learned about shipping the new site, in the hopes that this will be helpful to others who will work on projects of similar scale!
I’ve been a big fan of GitHub Actions since last year’s Universe (read the post on building docs with them). As a matter of fact, I was such a fan that I moved my blog publishing process entirely to GitHub Actions and GitHub Pages. Recently, GitHub announced that the Actions engine is changing, which makes workflow management much easier - still in private beta, though. Recently I got an invite to try out the new functionality, though, so I thought I’d write up how I updated the blog publishing workflow to the new experience!
I am all about numbers when it comes to driving decisions. That’s the most accurate and tested way in ensuring that you are pursuing the right thing. Not to say that we should not focus on things like customer development, but numbers certainly can shed a lot of light on whether the product is on the right track. There are certain approaches to analyzing product data that universally apply to all projects, and can yield some interesting insights given that you put some time in it.
One of the biggest projects I’ve had the honor of being a part of has shipped a couple of days ago - docs.microsoft.com/samples. If you haven’t read the announcement blog post, I recommend you start there. Table of contents Inception Looking back First steps Improving the experience Published pages Automating releases Stack Conclusion Inception When we started working more in-depth on developer experiences, we realized that there are too many disjoint pages out there that provide an aggregation of code samples (and we ship thousands of samples that span hundreds of teams).
The other day I had a conversation with my skip-level manager about what it means to be a leader in an independent contributor role, that prompted me to sit down and write this out. I’ve always been fascinated about ways in which I can multiply my impact, so this seemed like an important conversation to have. A lot of times product managers assume that just because they are in an Individual Contributor (IC) role, that means they need to focus only on their immediate areas - things that yield positive outcomes in projects and initiatives that are directly related to one’s line of work.
I am big on figuring out ways in which I can spend time more meaningfully. Part of this is a strategy to automate as many of the routine tasks as possible, to make sure that I can focus on the big picture - building products that deliver value to customers. I should also preface this post with some context - I am a remote employee. Sometimes it’s hard to communicate what you’re doing and how you’re approaching the stack of tasks while hundreds of miles away from your team.
When building documentation for your product, you will often encounter situations where you need to mix and match a bunch of content that comes from different sources. It becomes a bit more complex when you need to start dealing with different platforms, e.g. documenting APIs for Python, .NET and Java all in one place. We do all that and more on docs.microsoft.com, where we host documentation that is both hand-written and generated automatically from code - DocFX is a very powerful and versatile system that allows you to do that with the help of pre-defined contracts for structured and unstructured content.
Last year, I decided to be more proactive about working on becoming a better product manager - I acutally carved out some time to learn about the skills that would allow me to have a bigger positive impact on the customers of projects that I am building. I’ve spent a significant amount of time reading through various books that tackled topics from customer empathy, innovation to practices on improving collaboration with my team and partners.
I’ve always loved technology - since the first 486 computer my parents got me, to the days when I discovered Visual Basic 6 with its revolutionary ability to build graphical user interfaces by just dragging the mouse around. I was fortunate enough that my parents were able to afford the tools that planted the seed of “Maybe I can be an engineer?” in my mind. Once I moved to the United States, I was, once again, fortunate enough that I got connected early with people that helped propel my career where it is today - from online community leaders to industry professionals.
There comes a time when one needs to re-assess how and what they are using for their blog software. For years, I have been an avid WordPress user, jumping from shared hosting to shared hosting in search for a good deal, but always encountered issues - there was either little room to customize things, or I had to deal with the ever-growing bloat of a large code base for a little site.
I was just chatting with my good friend Anthony Chu about containers and an idea struck me - I love GitHub Actions, I love PowerShell. I wonder if the two would work together?
At GitHub Universe 2018, the team announced a new an exciting capability of the platform - GitHub Actions. At its core, this allows you to run "micro-CI" (or not so micro) within the repository itself. The benefit is two-fold: you can still plug in to other CI services, and you can also segment the workflow directly from the repository (there are some pretty interesting workflows out there already).
Yet another one of those times where people kept asking about something on Twitter, and I thought that it would be easier to write a blog post explaining the inner workings of things instead of responding in 280 characters. This time, this relates to "How can I build my own little docs.microsoft.com", so let's tackle the problem head-on.
Thought I’d start a series of videos talking about documentation and anything related to it.
API documentation - something that often remains an after-thought for developers purely because writing it can be cumbersome, it requires working with a bunch of different tools (often very old), and maintaining it makes developers cringe just because that means they have to come up with good examples and descriptions, and let's face it - most developers would rather focus on writing code.
Summer is here, the city finally feels like you can take pictures of it from above without being “head in the clouds”, and that also means that it’s time to document how we generate .NET documentation on docs.microsoft.com. A while ago I wrote a post about documenting NuGet packages, and while it was a generally good description of high-level tools, it also missed the key detail - how to use DocFX to render the docs.
In our team (docs.microsoft.com - we are hiring), we extensively use both GitHub and VSTS, for a variety of reasons. The problem of connecting the two came along as we were thinking about our public feedback channel. We ultimately want to have all user suggestions directed to the PM and engineering teams; however, internally all processes revolve around VSTS and engineering work is tracked there. The idea was to build a bot that can create VSTS work items from suggestions in GitHub.
This weekend I’ve spent some time to rework foggycam, the open-source tool to record Nest camera footage locally and to the cloud.
Recently I’ve been reading a tech site on my iOS device when a new tab opened and went into the background - something I’ve seen before caused by rogue ads that are fetched via normal means (e.g. embedded in a legit page), so my next steps were not unusual - go to the tab and close it. Here is what I faced: Once the tab opened, I instantly recognized it as one of those tech support scams.
Last weekend I hacked together a solution that allows Nest stream capture locally. This weekend I got a chance to improve it a bit and make the entire solution cloud-ready.
I previously talked about connecting to Instagram without the browser as part of a little hobby project I am working on. Another component of this project involves tracking the popularity of individual hashtags on Instagram, and how those grow over time. There are two approaches that I will describe here, each with its own merits, that can solve the problem. NOTE: This is a just-for-fun project - no private information is collected, or shared through it.
For one of the hobby projects, that I am working on, I thought I would leverage the Instagram API. It deals with an automation scenario, so the choice was obvious - I can put together a Python script that runs at scheduled intervals. Lucky for me, I’ve also learned that there is already a Python library that can help me access the API - it is archived and no longer maintained, but should at least give me some leverage over what I wanted to do.
I love looking at my Ubnt graphs - how much traffic goes where, to what clients, and many other interesting indicators. But I am also the kind of person that loves having raw access to the data, so I started digging - how can I pull those statistics locally? The setup I run is described here - I have a cloud key that manages the network, composed of a router acting as a switch, access point and the security gateway.
As a Program Manager, part of my job is to write technical specification documents. Our team recently switched to using our very own system (yes, we use the docs.microsoft.com infrastructure internally too) to write technical specs – content is on GitHub and Markdown-based. As part of that came the question – how do we aggregate comments when people review them?
If you are following the news around our new technical documentation experience, you probably know that last week we revamped our managed reference experience and launched the .NET API Browser. In today’s post, I thought I would go into the nitty-gritty of the process and talk about how exactly we generate reference documentation for .NET Framework and related managed SDKs.
I recently overhauled my network setup to get better WiFi coverage as well as get more data as to what traffic actually happens through my local network. After some relatively short conversations with my colleagues, I landed on Ubnt gear.
One of the features that I love the most about Visual Studio Team Services is the ability to build my code in the cloud. In my project I have a requirement for dynamic build provisioning, which works well. However, I recently tried to figure out how can I get the list of steps from a build definition, and was hitting a roadblock up until I got some help from Chris Patterson.
If you already checked out the Intro to Azure Notification Hubs post, there is some new material ready for you, that describes how to build a push notification service for Chrome, Xamarin.Android and native Android.
This October marks a year since my switch from working on client software to working on the unified Microsoft documentation experience. Throughout the past year I had to learn a tremendous amount of absolutely new (to me, at least) things that totally changed my perception of what the importance of documentation is.
If you’ve used Instagram before, you’ve surely noticed how it handles DMs when shared from the home feed. Looks like Twitter took a hint from Instagram on how to easily share tweets between users in private.
One of the key parts of my job as a Program Manager on the docs.microsoft.com team is to assess community contributions across different documentation repositories and areas. That might appear to be a very complicated task, and as we go, I will document more on the process. This post, however, is dedicated to setting up the core environment to make the task somewhat easy.
Depending on your project, you might need to run the latest version of the .NET Core SDK on your hosted build agent. Hosted agents are pulled from the VSTS hosted pool. With great flexibility comes great responsibility, so the build agent has some limitations when it comes to picking the software that needs to be deployed.
As we released the Visual F# documentation as open-source, one thing stood out as a challenge that needed to be tackled – content validation. There could be several things we could do, such as integrating extra validation rules in the build system or building a GitHub bot. I thought that as a learning experience, I will go the bot route. This post explains how I worked this problem.
A bit ago, Scott Hanselman and myself recorded a nice intro to sending push notifications with Azure Notification Hubs. Check out our session to learn more.
There might be several scenarios under which you need to make sure that certain published posts are hidden on your Ghost Blog landing page. Out-of-the-box this is not yet supported, but luckily there is an easy way to implement this restriction.
Gone are the days when you no longer have to worry whether you want to fetch a website through HTTPS. No matter whether you are handling private information or not, there is no excuse to have a site residing in plain HTTP land. That said, this tutorial assumes that you, the reader, already have some knowledge as to why HTTPS is necessary.
Prompted by a Reddit thread, the question in the title seems to be a fairly common one among Computer Science undergrads as well as those that are just now starting up in the field - What programming language should I choose? Is there a possibility that I will choose the wrong one? Should I learn one or many?
Before going any further into this post, I should preface this by saying that anything and everything below is purely my subjective view on what makes a Program Manager a great Program Manager. I consider myself lucky enough to have experienced what it's like to be a PM on a product team, and currently - on a content team, and this blog post is a reflection of my experiences across the two completely different organizations.
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.
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?
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.
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.
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.
I’ve added several changes to the FileExplorer control, that will be included in the Coding4Fun Toolkit.
I am proud to announce today, that one of my largest Windows Phone projects – Beem, is now open-source, in an effort to improve the product and to facilitate community contributions (there were many requests to add features – now devs can easily chime in).
To continue the tradition of a weekly FileExplorer build, here is the next update, bringing you a new set of capabilities and fixes.
You can download the Coding4Fun Toolkit source code. Once downloaded, go to Experimental > FileExplorer. The sample project carries an alpha implementation of the control, and I would love to get your feedback on it - let me know what you want to see become a part of it.
As per the request of many Beem users, I am implementing Last.fm track scrobbling. The first part of this task is to implement an API client for the Last.fm web service, and step one is user authentication. Last.fm is not using OAuth, but rather its own implementation of an authentication engine that relies on a composite MD5 secret.
With the full tutorial series and the PDF eBook, it would only be logical that the next step in the FallFury story would be releasing the game in the Windows Store. Today, I am happy to announce that my first big game development project successfully passed certification and is now available in most of the locations worldwide in the Windows Store.
Almost a week ago, my FallFury series (building a hybrid Windows Store XAML/DirectX/C++ game) was released on Channel9. 12 articles and associated videos is a lot to go through, and you might not always have an active internet connection.
If you follow this blog, you probably know that I spent part of Summer of 2012 in Redmond, WA, working on the Channel9 Coding4Fun team. My project for that period was FallFury – a 2D game that was designed to demonstrate the capabilities of the Windows 8 (specifically, Windows Store) development platform when it comes to creating hybrid applications (C++/XAML/DirectX).
As I discussed the basic of authentication in my previous post, the most important Last.fm feature that is added to Beem in itself is track scrobbling, which will allow you to keep records of what you listened to from your favorite music aggregation service.
While working on Beem, I always relied on a static XML file to fetch me the list of available online radio streams. It’s a good way to keep the content dynamic, and when new stations are added, I do not have to re-submit the application for certification but rather just update the XML file.
Serialization is a process that is prone to errors, especially with a poorly structured data layer. However, that is not always the case and a seemingly normal serialization/deserialization scenario might turn out to produce unexepected results.
As Windows 8 adoption is growing (as a matter of fact, in the first month there were more than 40 million licenses sold), so is the number of Windows Store applications. I use some of the Windows Store delivered applications, such as Music, Netflix, Bing Weather and Bing Search quite often, but I also spend a lot of time in Visual Studio, which means that I am not in the Windows 8 shell, but I have access to the taskbar.
Multiple applications that are already in the Windows Phone Marketplace operate with a variety of content, such as pictures, text files and music. More often than not, that content is stored locally, in the application isolated storage, and although it is a good way to preserve that content, this method is bound to create some inconveniences in case the user decides to switch phones or do a complete device reset.
With the release of the new Windows Phone 8 SDK, the developers are now able to create URI associations, where their application can be launched from the context of another application.
This summer I got an awesome opportunity, thanks to Dan Fernandez, Jeff Sandquist, and Clint Rutkas – I worked as a vendor/intern on the Channel9 Coding4Fun team. Now, if you are not aware of what Channel9 is about, then you are totally missing out on a portal dedicated to everything Microsoft (with a focus on dev tech), so check it out.
If you are using So.Cl, you have a great opportunity to help three students: me, Wilson To, and Alex Poms, in the monumental task of writing a research paper on the social network.
The Windows Phone team recently announced that it will remove the Windows Phone apps section from the Zune Desktop client due to the fact that users mostly access those through the web interface or the mobile client directly on the device.
If you own a Samsung Windows Phone device, you probably noticed that there is an update available for the stock Diagnostics application. The default build is 1004 and the new one is 0210.
It’s almost 4 in the morning, and as with all great ideas, this one came to me while I was working on a completely different project. I was thinking that it is a shame that I cannot attach files to an email via EmailComposeTask – and indeed, I am not the only one thinking about this.
For a college project I had to set up an Ubuntu box and work on a network analysis assignment. I worked with this kind of tasks on Windows, and got some pretty interesting results by sniffing Windows Phone, Xbox and Windows 8 traffic with Wireshark. Ubuntu is a new environment for me, and I figured that the actual capture process is set a bit differently.
With the new update, Dell also updated their EM application. Which is still pretty horrible, surprisingly. It didn’t change much – some functionality is gone while other parts were unnecessarily hidden.
As you probably know, the Windows Phone SDK comes with an emulator that is locked down to the maximum – the developer only has access to Internet Explorer and to a limited number of settings. However, today I found out an indirect (and maybe not that optimal) way to access various applications that are blocklisted, but are still available on the device.
Dropped phones are not that uncommon of a phenomenon. My idea was to find a way when this happens while a third-party application is running on Windows Phone. No phones were destroyed or damaged during the experiment.
The Isolated Storage Explorer Tool is new with the Mango SDK (7.1). In this video I am talking about general capabilities of the application and why you should use it if Isolated Storage is a component part of your application.
The new Windows Phone Mango SDK introduced a testing tool, that is tied to the device emulator, allowing developers to simulate location data and readings from the accelerometer sensor (now it also allows taking screenshots).
Windows Phone tiles are cool – everyone knows that. So far, developers can create shell tiles outside the application itself, pinning them to the user’s home screen. Today, Clint Rutkas updated his Coding4Fun Toolkit with a component called Tile, that allows the usage of tiles directly in a third-party application.
Today I got the chance to attend a couple of team project presentations and one of those was a project called MIRA – Medical Interactive Recovery Assistant, developed by team SIMPLEX from Cluj-Napoca, Romania. The purpose of the project is to facilitate a more effective recovery for people with physical injuries. I already wrote about their idea a while ago, but today I got to see the real project and it’s actions.
Each Windows Phone OS – powered device has its own way of communicating with its hardware. In a non-public environment, this is done through a COM (Component Object Model) layer. A DLL providing this layer is usually shipped as a part of the OS or an official OEM application. When it is distributed the second way, it is fairly easy to intercept the XAP and extract the DLL. And that’s when the experiments begin.
For those who were developing for Windows Phone for quite a while, you probably know that the emulator itself exposes quite a few gems. The one I found today is rather useless at this point, but it’s interesting nonetheless.
I use Zune a lot, having started with the 4GB player, and now it’s available on Windows Phone 7. Though the WP7 player is labeled as Music Hub, it appears under the Zune icon and incorporates Zune’s organization, providing many of the same capabilities as the desktop client.
There are cases, when the functionality provided with the application is just not enough. Or maybe it is enough, but some people want to use it a bit different – either adapt it to their own needs or implement something that would add value to existing features. I actually encountered the extensibility problem in one of my projects, WeatherBar. Initially, I built it around the Google Weather API. Fair enough, it worked well for a lot of locations and it was quite simple.
According to the leaderboards (I am the leader of Team Core, by the way), the ImagineCup judges liked my Internet Explorer 8 Award entry, so I am moving on to Round 2 of the competition.
Facebook has a very useful API, that can give the developer access to pretty much anything Facebook-related when it comes to user profiles. The documentation provided comes in handy and it shows how to use the API from a web developer’s perspective – mostly giving examples in PHP. What if the developer wants to work with managed code in a desktop application? Since I am working with C#, I tried to implement some of the API calls in this language.
Snippet Manager is an application built by Danny Battison. Its main purpose is to help developers organize their code snippets in the cloud (those aren’t stored locally). One of the interesting features of the application is that it offers an interface for plug-ins, although with a specific code structure.
Back in the day, December 8th, 2008 I decided to join Dream.In.Code. What was the reason? Just for fun, in the first place. I wanted to see how many people I can help with programming issues, how many articles I can write and how many pieces of reusable code I could submit.
Today, I am excited to show you my new blog. I finally got my hands on a custom WordPress setup (the free one was way too limited for me at this point), so I am happy I can add so many interesting features. What is this blog going to be about? Well, it will mostly be about software development (as well as software in general) and some of my interests (especially technology).