Forem: Laurent Bugnion

Humans of Microsoft S02E01: Abel Wang

Laurent Bugnion — Mon, 02 Aug 2021 14:24:22 +0000

A few weeks before Abel Wang's passing, he accepted my invitation to talk about his relocation from the Midwest to Redmond, his favorite software project ever, and his attitude towards life and his health issues.

Because of the circumstances, and after talking to Abel's family, we decided to publish this video now to remind everyone of Abel's amazing energy and positivity. We miss you Abel.

This is part of a series titled Humans of Microsoft, which is part of the Hello World show on LearnTV and on Channel9.
More details here
https://dev.to/t/humansofmicrosoft
and here
https://channel9.msdn.com/Shows/Hello-World

Transcript

Laurent: Welcome back to Humans of Microsoft. This is a segment where we talk to people just like you and me, but they all happen to work for Microsoft and today I have a guest who is not really just like you and me because it's a, it's an actual rock star and I'm so happy to welcome my good friend Abel Wang to the show. Hello Abel, how are you?

Abel: I'm doing really good. Thank you so much for having me.

Laurent: Oh absolutely, such a pleasure to have you. And as a first guest of Season 2, Abel, you are a Principal Program Manager and you work for Azure Incubations, right?

Abel: Yes, that is correct. I'm officially the technical advisor to the CTO of Azure, so to Mark Russinovich.

Laurent: So Abel I know that a few years ago you were living in Houston and you moved to the Pacific Northwest So in the region of Seattle, which is, you know, the headquarters of Microsoft. Why did you decide to move and how do you feel that it impacted your career?

Abel: That's a great question. I actually, I've always wanted to make it to the West Coast. Well I grew up in the Midwest in the United States, but I wanted to be in California, 'cause clearly that's where I belong. Or somewhere on the West Coast. I definitely didn't belong in the Midwest, but when I graduated from college, I already had my son then. So money was really tight. And you know, I got, I got a CS degree, And I got job offers on the East Coast, West Coast, everywhere, but they all paid the same amount of money. But living in Houston, TX, that was, the cost of living is so cheap, it was kind of a no brainer. So my plan was, move to Houston and then in a couple years I'll find a job somehow and get to the West Coast. But what I didn't realize is once you have children, you're kind of stuck in a place, right? So as soon as my son graduated from high school, I looked at my wife. She looked at me and we said, now is the time right? And I knew I wanted to spend a little bit of time in Redmond, at least just because that's the corporate headquarters for Microsoft and I wanted to be where the action was. I wanted to see what it was like. You know, I knew that I could compete in Microsoft everywhere else, right around the world, doing services, doing sales. But I was like, can I compete with those Redmond people, but then, can I join, like, a product group? Can I? Am I at that level? Can I do this? It was like a challenge. And it was a strategic move on my part in terms of what I wanted for my career. So I actually got a job in product marketing. And I moved over to Seattle and it was amazing coming into work, going into campus every single day, it was, it was freaking amazing. The amount of connections that I built was invaluable, right, the face-to-face time. I think it was a huge positive influence on my career and I'm not saying that it's the only way to do things, but for me, I'm I'm glad I made the move.

Laurent: What production software that you wrote are you the proudest of?

Abel: That's another great question. I think I need to go all the way back in time to, this was my third year out of college. I somehow fooled Chase Bank into thinking that I was actually like a software architect of some sort, and at that time, this was during the dotcom boom. So everybody was getting jobs, but I was, we were trying to get bank information except they stored all their bank information on mainframes, right? So in order to have web servers that could serve a webpage that would pull that live information from the mainframe. Well, that was really tough. They didn't have a way to do that, so if you remember back, I guess this would be the early 90s, or mid 90s there, there really was very few ways that you could remote and do things right, so I ended up having to write a bridge using CORBA. That would talk to both the mainframe and to, like, the web servers to pull data from the main frames. And it's still being used by Chase today. So it was one of my first big projects and one of the funnest things I've done.

Laurent: Wow, CORBA, it's like a horror show for me.

Abel: Oh it was horrible. But I didn't know better back then.

Laurent: Well yeah, I mean back then it was the way, right? So quickly to finish and we could talk, you know, for many more hours probably, but how do you stay positive throughout everything that you're going through?

Abel: Very good question. So for those that don't know, I was diagnosed with cancer about three years ago and then I beat it. And then in March I was diagnosed with stage four cancer and it spread everywhere, right? So people often ask me, how do you stay positive? But the truth is, life is hard for all of us. All of us, it's hard, right? in in in some certain ways, and you can't wait until life isn't hard enough to decide to be happy. So I decide to be happy every day that I can.

Laurent: Wow. This is fantastic. Positivity as a decision, as a conscious decision. I love that. Well, this was fantastic. Thank you so much for coming on the show today, Abel, it was amazing. Thank you so much to all the viewers for watching and we'll see you next time on Humans of Microsoft.

Humans of Microsoft S01E02: Tasha Scott

Laurent Bugnion — Fri, 02 Jul 2021 10:35:33 +0000

Humans of Microsoft is not about tech, it's about humans just like you and me, but they all work for Microsoft. Discover a new guest every week in this series, either live on Learn TV or on the Hello World show page.

This week we meet Tasha Scott, a Business Program Manager based in Seattle WA.

Laurent: Welcome to humans of Microsoft. This is a segment where we meet people just like you and me, but they have one thing in common. They all work for Microsoft and today I'm joined by Tasha Scott. Hello Tasha, how are you?

Tasha: Hi, I'm doing great. How are you Laurent?

Laurent: I'm very good. Thank you. And Tasha, you are a business program manager and you are based in Seattle, very close to Microsoft Headquarters, right?

Tasha: Yes, Yep, beautiful lovely, great day here in Seattle as one would expect. It's not really cold

Laurent: Cool, so let's go into the questions. So the first question is what was a key moment, a pivotal moment in your career.

Tasha: So a pivotal moment in my career was when I actually got my first mentor and that's what really started my career in tech. I joined a user group. My first user group and the the woman who ran the user group became my mentor and if it wasn't for her, I wouldn't be here today. She was an incredible mentor for me and made sure that I was set up for success.

Laurent: Oh, that's fantastic and really mentors and mentoring people and getting a mentor is very important for careers in tech, right?

Tasha: Absolutely 100%.

Laurent: Yeah, I completely agree. So then if you could go back in time and find yourself like years before now. What would you tell yourself to help you getting started?

Tasha: Uh, so I started out, uhm, I don't, I'm not a typical tech career path person and so the thing that I would tell myself is I would, I would say like hey, a career in tech is possible for you and just so I could get started earlier. I never pictured myself having a career in tech and so I I just never, like, it wasn't something that I considered and so I didn't really pursue it. And I really wish that I could go back in time and just tell myself, hey this is a thing that's possible for you and you know, here's how you can, here's how you can do that. And I I would, you know, get started earlier if I could.

Laurent: Yeah, that's really interesting. And and that kind of brings me to the next question, which is do you even need a computer science degree to work at Microsoft?

Tasha: Absolutely not, and I am proof positive of that, so I don't have a computer science degree. My degree is actually in English, and before my tech career, I worked at a newspaper for a bunch of years.

Laurent: Yes, and we in fact have a lot of roles at Microsoft, so it's not just developers and programmers and we have a lot of developers who aren't computer science, you know?

Tasha: Yeah and I'm still in a technical role. I'm a citizen developer inside Microsoft, building programs for our sales operations worldwide.

Laurent: Fantastic, what would you say has been the key to the success in your career in tech?

Tasha: Uh, absolutely community. 100% tech communities are really the way to learn anything that you want to learn in tech. Whatever your chosen stack is, go find the community that that you know that stack belongs to and join that community. Participate in that community and you'll get so much support and you will learn so much through your community. It's really 100% the best way to get started and find success in your tech career.

Laurent: I cannot agree more. This is also how I got started and what brought me eventually to Microsoft. The last question I have. What is one more thing you want to tell to all our viewers to inspire them?

Tasha: I just I really like for all the people out there that think to themselves that maybe a tech career is out of reach or you just don't think you belong there or you think that you you couldn't make it. You really do have something to offer and it is something that you you can have if that's what you choose to do, there's there's nothing keeping you from having a tech career you absolutely can. You can come, you can work at Microsoft, which if you had told me, you know however many years ago, that one day you'd be working at Microsoft, I would have told you that was bananas, but it's not bananas. You should absolutely try if it's something that you want to do and find that tech community, find a mentor and you will make it. I believe in you

Laurent: Fantastic message. Well, thank you so much Tasha. It's been awesome talking to you and thank you to all our viewers for watching and we'll see you next time on another Humans of Microsoft. Thanks Tasha.

Tasha: Thank you. Have a great day.

Humans of Microsoft S01E01: LaBrina Loving

Laurent Bugnion — Thu, 24 Jun 2021 14:40:48 +0000

This week we meet LaBrina Loving, a Principal Program Manager based in Washington DC.

Transcript

Laurent: Welcome to Humans of Microsoft. This is a segment where we talk to people just like you and me, but they have one thing in common: They all work for Microsoft. Today I'm joined by LaBrina Loving. Hello LaBrina, how are you doing?

LaBrina: Hi, how are you?

Laurent: I'm very good, thank you. LaBrina, You are a senior custom engineer and you are based in Washington DC right?

LaBrina: That is correct, yes.

Laurent: Awesome. So let's go straight into the questions. What would you say was a key moment in your career, like a pivotal moment? If you think back.

LaBrina: Yes, I would say my very first job in tech was critical. I started in an organization, I didn't know anything that was going on. They had this architecture diagram with all these technologies that I wasn't familiar with and it was really intimidating. But what I did was, I spent several, several weeks really learning, really researching. And I think it sort of changed my career and showed me that I could really do this thin in tech.

Laurent: Oh, that's amazing. And definitely you never stop learning in this profession, right?

LaBrina: For sure.

Laurent: Yeah, that's really cool. If you could go back in time like anytime you want and see yourself as a younger person, you are obviously still young and all but younger, what would you tell yourself to help you getting started?

LaBrina: Yeah, I would say don't be intimidated. Don't be afraid to go and go after what you want, even if it means that there's no one that looks like you at the beginning. If it's something that you want totally go after it.

Laurent: Wow, yeah, that's a that's great advice, most probably right? You are very passionate about science, technology, engineering and math, which we commonly abbreviated as STEM, right? And so can you share some of the work that you're doing in this area?

LaBrina: Yeah, so one of the cool things I'm working on right now is with our employee resource group Blacks @ Microsoft. We're working in conjunction with a college here in the Washington DC area. And a group of middle school students where we're actually teaching them STEM. Right now, we're teaching them how to code in Python. And the Microsoft employees are putting together their curriculum. Our college students are delivering the curriculum and middle school students are learning, so we've got learning going at three levels, and it's amazing.

Laurent: Oh yes, that sounds amazing, because learning to teach is also very important, right?

LaBrina: Right, correct.

Laurent: Oh, that sounds really great. And so in your free time, and when it's allowed, I hear you're really the world traveler, just like me, right? So what would you say was your most exciting adventure?

LaBrina: Yeah, so I love to travel. I've been to 39 countries so far, but one of the things that I like to do is something where I go very last minute. So actually I was working with a customer here at Microsoft. I had a weekend to myself. I just went to the airport, looked for flights that were departing in the next two hours, and I hopped on a plane. At that point it actually ended up being, I flew to Barcelona for the weekend right. But yeah, I like the idea of just being very spontaneous and traveling somewhere I've never been to, very last minute.

Laurent: Yeah, this is very exciting indeed. did something similar at some point within the US, but it was really cool. So one more question. What is one more thing that you would tell our viewers, to try to inspire them and motivate them?

LaBrina: Yeah, I would say just don't, don't be afraid. I think fear really creeps into everything that we do. I would say don't be afraid to jump in tech and don't be afraid to learn out loud and ask questions. And and you know, ask for help like I, I think I cannot say that enough, that it's really, really important to get comfortable with asking for help and learning out loud.

Laurent: Yeah, I see I think it's true, and in fact mentoring and being mentored is very important in someone's carrier, right?

LaBrina: Yes, absolutely.

Laurent: Perfect. Well, this has been fantastic talking to you. So thank you so much for being with us today, LaBrina, and to all of our viewers, come next time and join us for another Humans of Microsoft. Thank you.

LaBrina: Thank you.

Best practice when naming Durable Functions in C#

Laurent Bugnion — Wed, 04 Nov 2020 19:37:03 +0000

When you create a new Durable Function in C#, you get some code which looks like this:

[FunctionName("Function1")]
public static async Task<List<string>> RunOrchestrator(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var outputs = new List<string>();

    // Replace "hello" with the name of your Durable Activity Function.
    outputs.Add(await context.CallActivityAsync<string>("Function1_Hello", "Tokyo"));
    outputs.Add(await context.CallActivityAsync<string>("Function1_Hello", "Seattle"));
    outputs.Add(await context.CallActivityAsync<string>("Function1_Hello", "London"));

    // returns ["Hello Tokyo!", "Hello Seattle!", "Hello London!"]
    return outputs;
}

[FunctionName("Function1_Hello")]
public static string SayHello([ActivityTrigger] string name, ILogger log)
{
    log.LogInformation($"Saying hello to {name}.");
    return $"Hello {name}!";
}

For brevity, I didn't include the HttpStart method here, it's not relevant to this discussion.

As you can see here, the execution of the program relies on some strings.

The FunctionName attribute which decorates the function SayHello uses a string as the function's identifier.
When the function is called by the context.CallActivityAsync method, the first argument of the method is the magic string identifying the function.

About Magic strings

The term "Magic string" in programming refers to identifiers which are stored in a string format. They are deemed "magic" because they have a specific meaning critical to the execution of the program.

One thing I learned when I was learning programming is that in general, it's not a great idea to rely on "magic strings". They are dangerous, because a typo will not be detected by the compiler (compilers don't normally check the format of string variables). So the risk of getting problems at some point is higher.

Using the `nameof` operator

In order to minimize the need of magic string, C# introduced the nameof operator.

This can be used on a number of identifiers in the code. For example you can consider this code:

public class MyClass
{
    public int MyProperty
    {
        get;
        set;
    }

    public void MyMethod()
    {
    }

    public void ShowNames()
    {
        Console.WriteLine(nameof(MyClass)); // prints "MyClass"
        Console.WriteLine(nameof(MyProperty)); // prints "MyProperty"
        Console.WriteLine(nameof(MyMethod)); // prints "MyMethod"
    }
}

So what's the point?

The point of the nameof operator is that it makes it easier to detect typos or changes in the code. For example, if you change the name of MyClass to MyNewClass, then the code won't compile unless you also change it inside the nameof operator.

If you use refactoring tools, for example inside of Visual Studio, you can easily rename all the instances of the MyClass identifier without having to search-and-replace.

Finally, it also makes it easier to navigate the code. If you are inside the nameof operator, place your cursor on MyClass and press F12 (in Visual Studio), this will take you directly inside the MyClass class, even if it is located in another file.

Next steps for Durable Functions

For Durable Functions, my first step was always to modify the code like this:

[FunctionName(nameof(Function1))]
public static async Task<List<string>> RunOrchestrator(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var outputs = new List<string>();

    // Replace "hello" with the name of your Durable Activity Function.
    outputs.Add(await context.CallActivityAsync<string>(nameof(SayHello), "Tokyo"));
    outputs.Add(await context.CallActivityAsync<string>(nameof(SayHello), "Seattle"));
    outputs.Add(await context.CallActivityAsync<string>(nameof(SayHello), "London"));

    // returns ["Hello Tokyo!", "Hello Seattle!", "Hello London!"]
    return outputs;
}

[FunctionName(nameof(SayHello))]
public static string SayHello([ActivityTrigger] string name, ILogger log)
{
    log.LogInformation($"Saying hello to {name}.");
    return $"Hello {name}!";
}

These few changes (using nameof) minimize the usage of magic strings and make it easier for me to navigate the code.

Changing the templates

In order to make this easier for everyone, I proposed a change to the C# templates for Durable Functions which, if accepted, should promote the usage of nameof in the generated code.

Happy coding!

Laurent

Microsoft Ignite 2020

Laurent Bugnion — Tue, 22 Sep 2020 12:04:52 +0000

This week (in fact, today) we are starting Microsoft Ignite, our biggest conference of the year. It is the first time that we have to run the event online, which of course is a bit sad (last year's event in Orlando was amazing, so many people...) but in the other hand it's also the chance for everyone to see the event LIVE and to ask questions from the experts in real time. We'll have 3 days of content non stop (yes literally 24/7) around the globe. Exciting!

I'll be doing a lot of moderation and Q&A behind the scenes so if you see me in the chat, be sure to say hi. But even better I'll also have two "on-stage" appearances, so mark your calendars and add me to your schedule or your backpack.

Migrating an ASP.NET web application to Azure App Service

Date / Time: September 23, 2020 at 2PM CEST

Azure App Services offer a wide range of platforms, functionalities, and utilities around your web application. In this session, we will see how an ASP.NET web application can be migrated from a local environment to Azure with the help of our tools and processes. We will also talk about the configuration of the App Service, such as improving security, automatically scaling and more.

During this 15 minutes interstitial program, I will join Seth Juarez and Christina Warren to talk about ways to migrate ASP.NET applications to Azure App Service, advantages, tools etc. We will also see a demo migrating an old ASP.NET WebForms app (.NET 3.5) to Azure App Service with almost no changes, and how to improve the configuration by using Azure Key Vault for the secrets (such as a configuration string).

Note that there is no repeat for this short session, but it will be recorded.

Exploring core concepts in Azure Data

Date / Time: September 24, 2020 at 2PM CEST

Microsoft Learn Workshops are designed to be interactive and hands on. For the most immersive experience we recommend the prerequisites suggested in the module link provided below but are not required to join. To ensure everyone attending has the best involvement, these sessions have limited capacity. But don't worry, they are being recorded and will be available on demand.

Join us for this guided online Microsoft Learn workshop: https://aka.ms/Learn/AzureDataConcepts.

This 75 minutes workshop will take place 3 times, and this is the 3rd repeat. Join me to go through a series of Microsoft Learn Module and slides teaching you the fundamentals of data on Azure. This is great for beginners!! We will talk about relational databases (such as Azure SQL Database, Azure SQL Database Managed Instance), semi-structured databases such as CosmosDB, big data and more.

Note that you need to register for this event! Places are limited.

I am really looking forward to this event, and hopefully I will reach out to a lot of you.

Stay safe!

Laurent

Notifications Client Step 1.0: Creating the FCM project

Laurent Bugnion — Thu, 09 Jul 2020 13:21:30 +0000

Intro

Find the GitHub repository for this series here.

Previous article: Notifications Client Step 0: Specification

Main article: Building a notifications client with Xamarin and Azure

I have decided to build a cross-platform Notifications Client used to receive push notifications when a long-running system needs it. This Notifications Client is generic, and not tied to a specific system or application, but serves as a receiver and repository for all kinds of notifications.

This article is part of a series. In here, we will set the Firebase Cloud Messaging (FCM) service and prepare it to be an intermediate between Azure Notification Hub and our mobile app on Android.

Creating a new FCM project

Android notifications are sent through a service called Firebase Cloud Messaging (this is a Google service). When you use an "aggregation service" like Azure Notification Hub, this service will communicate with FCM to send the notification to all the Android devices who registered for it. Similarly, Notification Hub will also communicate with corresponding services for Windows (we will set this later) and for iOS.

Note: For this to work, the Android device needs to support Google Play Services. The Azure Notification Hub also supports Baidu as a target, but this won't be treated in this article.

To start, we need to navigate to the Firebase console. Then follow the steps:

Click on Create a project.

In the first step, enter a name for your new project. You can choose any name, this is just for management purposes.

You can choose to enable analytics or not. In my case, I decided to turn this off, because I will be using Application Insights on Azure to monitor the system, and I don't really need a separate analytics solution just for the Android devices. But your mileage may vary...

The new project will be provisioned, so just wait for a moment until it is ready.

Firebase can be used for quite a lot of things next to push notifications, but we are not going to use these features here. The main point of this project is to be a gateway between Azure Notification Hub and the Android devices.

Now we will configure the Android application. This is quite easy. First, in the "Get started by adding Firebase to your app" section, click on the Android icon.

Next, we will link the Firebase project to the Android application that we will create later. You need to enter an Android package name. You can also enter a nickname for this app, this is just for management purpose.

The Android package name is of the form com.[yourcompanyname].[yourapplicationname]. Make sure to write it down for later.

On the next step, download the google-service.json file and save it in a safe location. This file contains all the information needed by the Android devices to register with the Firebase system to get the notifications.

On the next screen, you can just press Next and then Continue to console.

Writing down the keys

Now we will write down the secret keys that we'll need to use in the Android application. Later we'll use these keys in the Xamarin code, and even later we'll save these keys to Azure Key Vault for safe keeping.

In the Firebase Console, select your application.
In the application dashboard, click on the button with the small Android icon, and the name of your app.

Click on the Settings icon

Click on Cloud Messaging.

Copy the Server Key and save it somewhere for later.

Well done!!

That's it, you have created and configured a new Google Firebase Cloud Messaging project, and downloaded the file you need.

If you lose the google-services.json file, you can always retrieve it from the Firebase console.

You have also retrieved the Server key which we will use to configure the Azure Notification Hub. Make sure to save it!

In the next article...

In the next article (coming soon), we will see how to build an "empty" Xamarin Forms application and configure it to receive the notification from FCM.

Find the GitHub repository for this series here.

Main article: Building a notifications client with Xamarin and Azure

Happy coding!

Laurent

Notifications Client Step 0: Specification

Laurent Bugnion — Mon, 22 Jun 2020 16:32:22 +0000

Intro

Find the GitHub repository for this series here.

Main article: Building a notifications client with Xamarin and Azure

I have the following specifications in mind:

The client will have different pages. The notifications can have a "channel", which will sort them to a specific page.

Note: The "channel" here is a custom property I am adding to the notification for my own purpose. It's not the same at the Push Notification Topic in Firebase, which allows to push notifications only to selected devices, or the customer segments in Windows, which have the same goal. Here we just use the channel as a way to sort notifications in pages.

App main page with all the channels

There should be one page showing all the notifications, and one page per channel with only the corresponding notifications.

Channel page with the corresponding notifications

Detail of a notification template

The client should save the notifications locally.
The client should allow the notifications to be searched on the current page (or the "all notifications" page).
Notifications can be received when the application is off, or when it is running.
Eventually, the notifications should also be saved in the app for offline mode.
Notifications can be deleted from the app.

Detail page for a notification

The client should be implemented in Xamarin.Forms to be cross-platform, even though initially I only need Android and possibly Windows (UWP).

Architecture

The architecture is composed of a few Azure services, as well as a Google service for Android notifications, a Windows service for Windows notifications, and later of an Apple service for iOS notifications.

Notification system architecture

Any system can send a simple POST request over HTTP to an Azure Functions endpoint. The payload is a simple JSON file containing a title, a message and an optional channel.

If you are watching systems on Azure, a great way to connect a system to the Azure Functions endpoint is to use EventGrid.

The Azure Function passes the notification request to an Azure Notification Hub.
The Notification Hub communicates with Firebase Cloud Messaging (FCM) (Android), the corresponding services for Windows (Windows Push Notification Service WNS) and iOS (Apple Push Notification Service APNS). The notification is enqueued on these systems and sent to registered devices.

Azure Notification Hub also supports other systems such as Amazon (ADM), Baidu, and even good old Windows Phone!!

FCM sends the notification to registered Android devices. Similarly, APNS sends the notification to iOS devices, and WNS sends the notification to Windows devices. What happens on the device is described below in When a device receives a notification.
After the push notification has been successfully enqueued, it is saved to a cloud database. We will use the new CosmosDB free tier for this, as this allows for a powerful yet simple NoQSL database to be used.

When a device receives a notification

There are three scenarios.

The application is running in the foreground: The new notification is shown on a page, the user's attention is attracted for example by a sound or a flashing.
The application is in the background, or not running: The new notification is displayed as a push notification. The user taps the notification, which starts the app. The new notification is shown on a page.
Same scenario but the user dismisses the notification: Nothing happens until the next time that the app starts.

When the running app receives a new notification, or when the app is started from a new notification, the notification is saved in a local database on the device (SQLite).
A synchronization can occur between the cloud database and the device database. The synchronization is started by the user, it also occurs when a notification is deleted on a device, or every time that the application starts.

In the next article...

Hopefully these specs make sense for everyone!

In the next article, we will get started with the implementation of the notification system!

Find the GitHub repository for this series here.

Main article: Building a notifications client with Xamarin and Azure

Next article: Notifications Client Step 1.0: Creating the FCM project

Happy coding

Laurent

Building a notifications client with Xamarin and Azure

Laurent Bugnion — Wed, 17 Jun 2020 12:10:31 +0000

Intro

Find the GitHub repository for this series here.

I often find myself needing to send a notification to my mobile device, for example when a job finishes on Azure, when one of my computers at home is done doing something, or when I just want to send an alert when something changes in a system I am observing.

Normally I would go ahead and create a companion app for the system I am building, and then send notifications to this app, but sometimes it's really overkill to build a full-blown app for this. This is why I decided to build a generic notifications client that I can install on my phone.

What's really cool is that a lot of the development (with dotnet and Xamarin) can be done locally on my Surface Pro, which makes testing and debugging very much easier, before the services and applications are deployed to Azure and to my devices.

Why Push Notifications? (aka why not SignalR?)

Why did I choose to use push notifications and not another messaging service like SignalR for example?

SignalR is an amazing feature that you can easily add to a Xamarin application as shown in this sample. It is very well suited for high traffic, real-time communication. In our scenario, it doesn't quite fit, because we want the notifications to reach the device also when the application is not running, which is exactly what push notifications are made for. Also, even when the application is running, adding SignalR would be overkill because we don't really need real time, high traffic here. What we get from our watched systems is a notification from time to time, and even if this notification is delayed by a few seconds, it's not mission critical.

Finally the push notification system also includes retries, in case one device is offline for a period of time. This is very useful for our scenario too.

Steps

I am planning to build this system in the following order:

Step 0: Specification

In this step we will specify what we want the system to achieve, create a few sketches of the application and get ready :)

Step 1: Sending a notification from the Firebase Cloud Messaging

The first step will include:

Creating a new project in Google Firebase and setting up Firebase Cloud Messaging (FCM).
Building a client app just here to receive the Push Notification and test that it works.
Test the notification with with Postman.

Step 2: Sending a notification from Azure Notification Hub](./building-notifications-client-2.md)

So far I hadn't worked directly with Azure Notification Hub (I was using App Center, but this is being retired), so I need to figure out how the Notification Hub works. Thankfully there is good documentation available. Here is what we'll do in this step:

Create a new Azure Notification Hub and connect it to FCM.
Test the setup by sending a push notification with Postman.

Step 3: Build the endpoint and connect to Notification Hub.

Once we have the FCM project and the Notification Hub set up, we can build an Azure Function to serve as the main endpoint for the notification system. The Azure Function will communicate with the Azure Notification Hub by means of an SDK for .NET. This includes:

Build the Azure Functions application locally.
Build a test request in Postman to try things out.
Create the Azure Functions application on Azure.
Publish the function to the Azure Functions application.

Not started yet

Step: Sending a notification from the Windows Push Notification Services

Not started yet.

Step: Show the new notification in a page on the device.

Not started yet.

Step: Save the notifications in Cosmos DB.

Not started yet.

Step: Get the notifications from Cosmos DB into the app.

Not started yet.

Step: Save all the secrets to Azure KeyVault.

Not started yet

Step: Organize the notifications in the app in pages.

Not started yet.

Step: Save the notifications locally (synchronize).

Not started yet.

Step: Customize the application with icons, design etc...

Not started yet.

Building an ARM deployment template

In order to allow people to use this on their own, I am also planning to prepare an ARM deployment template for the Azure components.

Azure Function connected to the Azure Functions application GitHub repo.
CosmosDB.
Notification Hub.
KeyVault for the connection strings and other secrets.

In addition I will write detailed description on how to create the Firebase Cloud Messaging project, and how to configure all the Azure pieces.

Find the GitHub repository for this series here.

Next article: Notifications Client Step 0: Specification

Happy coding!

Laurent

Ethics in Artificial intelligence, a talk recorded in video

Laurent Bugnion — Mon, 08 Jul 2019 15:15:39 +0000

Over the past few weeks, I was really happy to give a talk about a topic that has been preoccupying me for a long time, ever since I started reading science fiction and being confronted with the moral conflicts that advanced technology always brings to the front of the stage.

In order to get notified when more parts of this talk, as well as other talks that I am preparing, are published, please subscribe to my YouTube channel.

In the talk, I mention a simple example: Imagine a self driving car who has to decide if it should go left and kill one human, or go right and kill 10 of us. Now imagine that the one person on the left is a child. How is a machine supposed to make this kind of decisions? Earlier this kind of moral question was only a theoretical one (see for instance Isaac Asimov's laws of robotic). But now we need to think about these issues in a much more practical manner. We now have the data and the power to run artificial intelligence models, and we must deal with all kinds of ethical questions.

The main issue we are dealing with these days is the bias in data. The talk explains in detail what bias is, and how it creeps into the AI models. We also talk about a few other ethical issues linked to AI, and explore some ways to improve the situation. Finally we end with a few positive examples where AI promotes inclusion and diversity, and shows that we should not abandon artificial intelligence, but that we should do our best to use it for the greater good.

For the viewer's convenience, I split the 45 minutes talk in 7 parts which are between 3 and 7 minutes. I published parts 1 to 5 already and the rest will follow in the next few days. Hopefully this talk is useful for you! And if you like it, please subscribe to my YouTube channel.

Happy viewing!
Laurent

DateTime.Now: No, no...

Laurent Bugnion — Tue, 28 May 2019 11:47:03 +0000

Recently my colleague and friend Donovan Brown was in Switzerland for customer visits and for the DotNet Day conference in Zurich. I took the occasion to spend some time with him and we got to talk (as you would expect) about geeky and "cloudy" stuff.

One topic of discussion (and that was also mentioned by one of the clients) is: What do you need to get ready for the cloud... and one topic was: Timezones!!

What time is it, really?

Because of all the regions we have, it means that your code suddenly has the potential to easily go global :) So here's a fun experiment you can do:

Create a new web application. Here I use Visual Studio to create an ASP.NET Core web application with Razor pages.
In the HTML code, display the local time and the UTC time. In ASP.NET, I can use the following code in the index.cshtml:

<h1>Local time: @DateTime.Now</h1>

<h1>UTC: @DateTime.UtcNow</h1>

In Razor pages, you can call C# code directly from the CSHTML markup, which is very convenient.

Run the application locally. If like me you are based in Western Europe, you should see something like the below (notice the 2 hours difference between local time and UTC). If you are based somewhere else, it will vary, but there are very good chances that the Local time and the UTC time are going to be different (except of course if you happen to be in a timezone where the local time is the same as UTC).

Now deploy your application to Azure, into the West US region. You can do that from Visual Studio directly, or create an App Service in the Azure Portal and deploy there.
Run the West US application. Now you should see the same time displayed for Local and for UTC.

What?

So that might be a surprise, and in fact I wasn't expecting that when I first did this experiment a few months ago.

What's going on here is that the Azure architects decided to make it easy for people to migrate web applications (App Services) from region to region without changes in code used to calculate time and time differences. So they run all the Azure servers on UTC. On the other hand, this has the disadvantage that you might have to modify your code to take this in account when you migrate from on-premises to the cloud

For example, if I am based in Switzerland and deploy my application to Western Europe (which is based in the Netherlands), I would expect my application to have the exact same DateTime.Now in Azure than locally. And yet...

The morale of the story...

The big learning here is that if you are looking to migrate to the cloud, suddenly timezones become very relevant, but not necessarily in the way that you would imagine. It's not that you need to know where your code will be running. It is that you need to know that these regional questions will be abstracted.

It would be a great idea to prepare yourself to the migration by doing the right thing already now on premises: Do not use DateTime.Now in your code but use DateTime.UtcNow instead and do the conversions where needed. This way you are already abstracting the location of your code, and when you migrate to the cloud and the location becomes irrelevant or unpredictable, your code will continue to work without being affected.

Happy coding

Laurent

Creating the simplest possible ASP.NET Core form with a POST method

Laurent Bugnion — Mon, 04 Mar 2019 21:49:10 +0000

Recently I needed to create a simple page for someone to submit an HTML form. The rest of the Azure aplication is running on Azure serverless functions, Logic apps and Cognitive services, but for that last part I wanted something where the user can click on a link, open the page in a web browser (probably on a mobile device), enter a passphrase in a form and the submit through a POST to an SSL encrypted page. I thought of writing a small Xamarin app and submitting through POST to an Azure Function. Another option would be to use a static HTML page and to use Javascript to submit the Form through a POST to that Azure Function. I don't exclude these two options for the future.

But in the meantime I wanted to experiment with a simple Razor page (CSHTML) that would present an HTML Form to the user, and submit this Form to itself with a POST over HTTPS.

The source code for this example is here.

Razor pages with models are really cool

I love super simple ASP.NET Core sites without MVC. Don't get me wrong, MVC is awesome for enterprise web applications, where testability and maintainability are primordial. But they also come with a lot of overhead. If you go ahead and create an "empty" ASP.NET Core MVC website with the red-circled template below, you will end up with a lot of files (CSHTML pages, controllers, setup classes, Javascript, CSS etc). Even an empty ASP.NET Core MVC website contains 38 files (!).

ASP.NET Core Razor and ASP.NET Core MVC templates in Visual Studio

Another option is to create an ASP.NET Core web application with Razor pages only. In such an app, you eliminate the controllers, and you handle the code in a PageModel instance which is attached to the CSHTML Razor page. This is definitely less complex and in fact my private website is implemented in this manner. However even if you create an "empty" web application in this manner using the orange-circled template shown above, you still end up with a lot of files and need to delete most of them. That's annoying and I prefer to start from a "truly empty" template like the one selected in blue in the image above.

Even though I use Visual Studio in this example, you can create the ASP.NET Core apps using a command line with the dotnet new syntax shown here.

Starting from scratch

Let's start from scratch using the Empty web app template shown above. To do this, in Visual Studio 2017, start by selecting File, New, Project.

Before you start, you must make sure to have installed the .NET Core workload in the Visual Studio installer. You can always run the Visual Studio Installer from your Start menu, and check that the following workload is checked.

.NET Core workload

In the next step, you will have to select the Empty web application as shown below. You can enable HTTPS by default, which is usually a good idea. In our example we won't use authentication so you can leave this option to No Authentication. Then click OK.

Configuring Razor pages

As the next steps, we will configure the application to serve Razor pages. To do this, and even though we are not going to use the full MVC capabilities here, we still need to ask the application to use MVC services.

Open Startup.cs in Visual Studio.
Modify the ConfigureServices method as follows:



public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc();
}

Modify the Configure method as shown below:



public void Configure(
    IApplicationBuilder app, 
    IHostingEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    app.UseMvc();
}

Creating the Razor page

With this configuration, the application will look for Razor (CSHTML) pages in a folder named Pages and will direct the request to the page corresponding to the route (URL). In this example, since we want to keep it as simple as possible, we will use the default route and create a page named Index.cshtml.

Right click on the project and select Add and then New Folder from the context menu.
Name this new folder Pages.
Right click on the Pages folder and select Add and then Razor Page from the context menu.
in the Add scaffold dialog, press on Add.
In the Add Razor Page dialog, enter the name Index and make sure that Generate PageModel class is selected.
Uncheck Use a layout page and then press Add.

This step can take a moment because a few Nuget packages need to be installed in order for the ASP.NET Core application, the routing and the Razor pages to work.

Testing the GET method

By default, the page is configured to receive GET requests. We will test this now.

Open the Index.cshtml page (in the Pages folder).
Note the presence of the @model directive. This is instructing ASP.NET to use the IndexModel class (in Index.cshtml.cs) to handle the calls.

You can also add code directly inside the Index.cshtml page, inline with the HTML markup. This is super convenient but it can also lead to some "spaghetti" code which is very hard to test. It is not recommended to do so, except for layout code (for example for loops to create lists, etc...).

Open the Index.cshtml.cs file. This file is nested within the Index.cshtml page in the Solution explorer.
Place a breakpoint within the OnGet method.
Run the application in debug mode. This will start IIS Express and open a localhost URL in your favorite web browser, for example https://localhost:44367/.
Notice that the breakpoint is hit.

Within the method, you have access to all the usual ASP.NET objects, such as the HttpRequest instance (in the Request property), etc.

Setting up the POST feature

Just like we can handle GET calls in the OnGet method, we will handle POST calls in the OnPost method. However this needs a little addition configuration as we will see. First let's prepare an HTML Form which will post a single text field to the IndexModel class.

In the IndexModel class, add a property of type string named Message.



public string Message
{
    get;
    set;
}

Modify the OnGet method as follows:



public void OnGet()
{
    Message = "Enter your message here";
}

Still in the IndexModel class, add a method named OnPost:



public void OnPost()
{
    Message = Request.Form[nameof(Message)];
}

Place a breakpoint inside the OnPost method.
Open Index.cshtml in the editor.
Edit the body as follows:



<body>
    <form method="post">
        <input asp-for="Message" />
        <br />
        <input type="submit" />
    </form>
</body>

Run the application again in Debug mode. The OnGet method will get called like before, and you should see the HTML Form with an empty input field.

At this point, you might be surprised if like me you had expected the input field to be initialized with the content of the Message property (because of the asp-for attribute). But let's test further to see another issue.

Enter any text in the field and press the Submit button.

At this point, you will get an HTTP error 400 in the browser (Bad request).

Fixing the Bad request error 400

A quick online search reveals that the issue has to do with missing antiforgery tokens, which are a security measure put in place by ASP.NET to avoid cross-site request forgery (CSRF) attacks. In essence, what the token does is prove that the request comes from the site which the form originated from.

So how do we get the token? This is where a useful namespace called Microsoft.AspNetCore.Mvc.TagHelpers comes to play. Adding this to the CSHTML page will automatically generate the antiforgery token in the HTML form, and will also create the HTML attributes corresponding to the asp-for attribute that we added into the form.

Open Index.cshtml.
On top of the file, but below the @page attribute, add the @addTagHelper attribute so that your file looks like the following code:



@page
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
@model TestPostWithRazor.Pages.IndexModel
@{
    Layout = null;
}

Run the application again in Debug mode.
In your web browser, once the page is loaded, you should now see the form initialized as expected:

Right click anywhere on the page and select View page source. You should see the following HTML code that was generated by the ASP.NET application:



<body>
    <form method="post">
        <input type="text" id="Message" name="Message" value="Enter your message here" />
        <br />
        <input type="submit" />
    <input name="__RequestVerificationToken" type="hidden" value="[Some token]" /></form>
</body>

Modify the content of the text field and click on the Submit button. At this point, the breakpoint in the OnPost method should get hit, and the content of the field will be assigned to the Message property.

Conclusion

The source code for this example is here.

Sometimes, simple is better. In this example, we saw how to create an empty ASP.NET Core application with a Razor page (and the corresponding PageModel), and how to configure this application to handle simple GET and POST methods. This is an alternative to other mechanisms such as a pure client-side JavaScript powered page talking to a serverless Azure function. While the solution presented here is not serverless, you can take advantage of it if you already have an App Service plan in Azure, with Windows or Linux thanks to the cross-platform abilities of ASP.NET Core.

Hopefully this code will be useful to some.

Happy coding!

Laurent

Forem: Laurent Bugnion

Humans of Microsoft S02E01: Abel Wang

Transcript

Humans of Microsoft S01E02: Tasha Scott

Humans of Microsoft S01E01: LaBrina Loving

Transcript

Best practice when naming Durable Functions in C#

About Magic strings

Using the nameof operator

So what's the point?

Next steps for Durable Functions

Changing the templates

Microsoft Ignite 2020

Migrating an ASP.NET web application to Azure App Service

Exploring core concepts in Azure Data

Notifications Client Step 1.0: Creating the FCM project

Intro

Creating a new FCM project

Writing down the keys

Well done!!

In the next article...

Notifications Client Step 0: Specification

Intro

Architecture

When a device receives a notification

In the next article...

Building a notifications client with Xamarin and Azure

Intro

Why Push Notifications? (aka why not SignalR?)

Steps

Step 0: Specification

Step 1: Sending a notification from the Firebase Cloud Messaging

Step 2: Sending a notification from Azure Notification Hub](./building-notifications-client-2.md)

Step 3: Build the endpoint and connect to Notification Hub.

Step: Sending a notification from the Windows Push Notification Services

Step: Show the new notification in a page on the device.

Step: Save the notifications in Cosmos DB.

Step: Get the notifications from Cosmos DB into the app.

Step: Save all the secrets to Azure KeyVault.

Step: Organize the notifications in the app in pages.

Step: Save the notifications locally (synchronize).

Step: Customize the application with icons, design etc...

Building an ARM deployment template

Ethics in Artificial intelligence, a talk recorded in video

DateTime.Now: No, no...

What time is it, really?

What?

The morale of the story...

Creating the simplest possible ASP.NET Core form with a POST method

Razor pages with models are really cool

Starting from scratch

Configuring Razor pages

Creating the Razor page

Testing the GET method

Setting up the POST feature

Fixing the Bad request error 400

Conclusion

Using the `nameof` operator