Diary of a code trotter

Laurent Bugnion

I am really happy to welcome you here. This page displays the 10 most recent entries of my blog.

For older posts, please go to this page where you can browse the whole content.

For other content, please visit my main page at https://galasoft.ch

Thank you for your visit!!
Laurent

Best practice when naming Durable Functions in C#

.NET, .NET Core, Azure Functions, Technical stuff
See comments

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

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

    // Replace "hello" with the name of your Durable Activity Function.
    outputs.Add(await context.CallActivityAsync("Function1_Hello", "Tokyo"));
    outputs.Add(await context.CallActivityAsync("Function1_Hello", "Seattle"));
    outputs.Add(await context.CallActivityAsync("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> RunOrchestrator(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var outputs = new List();

    // Replace "hello" with the name of your Durable Activity Function.
    outputs.Add(await context.CallActivityAsync(nameof(SayHello), "Tokyo"));
    outputs.Add(await context.CallActivityAsync(nameof(SayHello), "Seattle"));
    outputs.Add(await context.CallActivityAsync(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

.NET, ASP.NET, Azure Fundamentals, Azure SQL, Cloud Developer Advocate, Conferences, Cosmos DB, Data, Microsoft Ignite
See comments

Microsoft Ignite 2020

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

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

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

.NET, Azure, Azure Functions, Technical stuff, Work, Xamarin
See comments

Xamarin, Notification Hub, Functions, Cosmos DB

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:

  1. Click on Create a project.

Creating a new Firebase project

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

Setting up the new Firebase project

  1. 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...

Setting up the project's analytics

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

Provisioning...

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.

  1. 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.

Starting the Android configuration

  1. 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.

Setting up the application's details

  1. 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.

Downloading the configuration file

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

Skipping to the next step

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.

  1. In the Firebase Console, select your application.

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

Navigating to your application

  1. Click on the Settings icon

Navigating to the settings

  1. Click on Cloud Messaging.

Navigating to Cloud Messaging

  1. Copy the Server Key and save it somewhere for later.

Copying the Server Key

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

.NET, Azure, Azure Functions, Technical stuff, Work, Xamarin
See comments

Xamarin, Notification Hub, Functions, Cosmos DB

Intro

Find the GitHub repository for this series here

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.

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

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

Channel page with the corresponding notifications

Detail of a notification template

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

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

Notification system architecture

  1. 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.

  1. The Azure Function passes the notification request to an Azure Notification Hub.

  2. 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!!

  1. 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.

  2. 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.

    1. 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).

    2. 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

Happy coding

Laurent

Building a notifications client with Xamarin and Azure

.NET, Azure, Azure Functions, Technical stuff, Work, Xamarin
See comments

Xamarin, Notification Hub, Functions, Cosmos DB

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 :)

Go to step 0: Specification

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.

Go to step 1.0: Creating the Firebase Cloud Messaging project

Step 2: Sending a notification from Azure Notification Hub

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

Join me online May 15, 2020: Free session

AI, Cloud developer advocate, Deep Learning, Microsoft, Technical stuff, Work
See comments

On Friday, May the 15th, 2020, I will live stream my session titled "A Gentle Introduction to Deep Learning".

A Gentle Introduction to Deep Learning

I presented this session a few times at various events and it was always quite successful. Since obviously in-person events are rather quiet these days, I want to try to live stream it and see how successful it gets. If that works well, I'll probably stream this session and others again, at different times, so more people can join.

Technically speaking, I will be using a Microsoft Teams Live event. This kind of meeting allows anyone to join, either anonymously in a web browser, or logged in on the web or in the Teams client. It also allows Q&A and the amazing Amy Boyd agreed to help moderating and answering questions. Amy is a data scientist on the Cloud advocates team and an AI specialist so you'll be in good hands.

I am very excited about this event and curious to see how it turns out. Hopefully you can also join us!

The event is free but I ask you to register here so you can receive the attendee link per email.

If you want to know when the event will be in your timezone, you can go here. If the event is too late or too early for you, I will record the event and I will also probably repeat the live stream at other times so people in the US or Asia can join too.

Can't wait to see you all on Friday!

Happy coding

Laurent

Happy 2020

Cloud Developer Advocate, Conferences, Microsoft, Microsoft Ignite the Tour, Personal
See comments

My spirit animal

This beautiful sea turtle tolerated me for a beautiful moment, and started my year 2020 in a wonderful fashion

As always at this time of the year, it's a good moment to stop and reflect on the events of the year, and get ready for the new year (or decade?)

Technically speaking, the decade will only start in 2021, since the first year of the calendar was year 1. But I think we can all agree that by popular request, the decade goes from 2020 to 2029 :) Welcome to the roaring 20s!!

First party events

For me, 2019 was mostly focused on our first party string of events called Microsoft Ignite the Tour. In 2018 - 2019, I prepared one session (about database migration) and then spoke at 9 "Ignite the Tour" events across the globe, and really enjoyed the experience. This is why around June, after the Tour 2018-2019 ended, I decided to change team and be even more committed to the Tour 2019-2020. I joined my good friend Scott Cate's newly created Scalable content team, and took over (together with my esteemed colleague Brian Benz) two of the learning paths, "Developing Cloud Native Applications" and "Modernizing Web Applications and Data for the Cloud".

Preparing the sessions took us from July until Novemeber, when we presented the premiere of all our sessions at our "big Ignite" event. And then, we went on the road... starting in Paris, which was our first "Tour" event.

All our sessions were recorded at Ignite, and so if you want to re-watch them, or catch a preview, you can head to the site and look for the videos!

I listed all the events below, and highlighted the ones where I will personally take part. Hopefully it will be an occasion to see some of you there. If you come to one of our events, make sure to reach out to me on Twitter and we'll meet up :)

Third party events

Next to these events that kept me super busy, I also had time to go to a few more events. In general, whenever we go to a location for a first party event, we always try to meet community groups in meetups or other events. So make sure to keep an eye on my Twitter feed to keep up with planned events.

As always, you can find past events on my site, where I list the slides, source code repos and all other resources related to the event.

Other content

Of course next to events, we also create other content. My blog and my YouTube channel haven't be extremely busy recently because of all the work on the Tour, but still, make sure to visit and subscribe :)

Happy new year to all!

I want to take a moment to thank everyone who came to see me talk at various events, or who watched and read my content. It's a privilege to be able to share the knowledge that I am acquiring every day in my job as a Cloud Advocate. I really hope that this content is useful to you, and that it helps you progress in your role, everyday and always.

Please take a moment to rest, relax, and recharge before more exciting technological advances in 2020!!

Happy coding!!

Laurent

List of Microsoft Ignite the Tour events for 2019-2020

Here is the list of all the Microsoft Ignite the Tour events for 2019-2020. I made the ones where I will be personally bold.

More information about Microsoft Ignite the Tour

  • Paris (13-14 Nov 2019)
  • Tokyo (5-6 Dec 2019)
  • Beijing (10-11 Dec 2019)
  • Sao Paulo (10-11 Dec 2019)
  • Toronto (8-9 Jan 2020)
  • Shenzhen (13-14 Jan 2020)
  • London (16-17 Jan 2020)
  • Seoul (21-22 Jan 2020)
  • Osaka (23-24 Jan 2020)
  • Milan (27-28 Jan 2020)
  • Johannesburg (30-31 Jan 2020)
  • Washington DC (6-7 Feb 2020)
  • Dubai (10-11 Feb 2020)
  • Sydney (13-14 Feb 2020)
  • Taipei (17-18 Feb 2020)
  • Singapore (20-21 Feb 2020)
  • Prag (24-25 Feb 2020)
  • Copenhagen (27-28 Feb 2020)
  • Zurich (4-5 Mar 2020)
  • Amsterdam (11-12 Mar 2020)
  • Shanghai (18-19 Mar 2020)
  • Hong Kong (25-26 Mar 2020)
  • Madrid (25-26 Mar 2020)
  • Mexico City (30-31 Mar 2020)
  • Mumbai (2-3 Apr 2020)
  • Bangalore (8-9 Apr 2020)
  • Chicago (15-16 Apr 2020)
  • Tel Aviv (22-23 Apr 2020)
  • Berlin (29-30 Apr 2020)
  • Stockholm (5-6 May 2020)

Microsoft Ignite the Tour 2019 - 2020

Azure, Cloud Developer Advocate, Microsoft Ignite, Microsoft Ignite the Tour
See comments

In July 2019, I decided that this year again I wanted to spend most of my time in our fiscal year 2020 (July 2019 - July 2020) on our series of conferences titles Microsoft Ignite the Tour. I am very thankful to my back-then managers Bruno Borges and Tim Heuer for making this possible, and to my now-manager Scott Cate for welcoming me on the team. Scott and I have a long history and he is in fact the one who called me back then in 2017 and asked me if I wanted to interview for this brand new team called the Cloud Developer Advocates. (Since then we dropped the developer qualifier because the team has epanded to include DevOps, SRE and more.)

In July 2019 we started creating the content that we will present on the Tour. We premiered this content last week at Microsoft Ignite in Orlando, and while some adjustments are going to be applied, it's fair to say that our content was well received.

Going on the road

Starting on the 13th and 14th of November, we're taking the show on the road. We'll be there in a total of 30 locations (the bold ones are the ones where I will present):

  • Paris (13-14 Nov 2019)
  • Tokyo (5-6 Dec 2019)
  • Beijing (10-11 Dec 2019)
  • Sao Paulo (10-11 Dec 2019) TODO Check
  • Toronto (8-9 Jan 2020)
  • Shenzhen (13-14 Jan 2020)
  • London (16-17 Jan 2020)
  • Seoul (21-22 Jan 2020)
  • Osaka (23-24 Jan 2020)
  • Milan (27-28 Jan 2020)
  • Johannesburg (30-31 Jan 2020)
  • Washington DC (6-7 Feb 2020)
  • Dubai (10-11 Feb 2020)
  • Sydney (13-14 Feb 2020)
  • Taipei (17-18 Feb 2020)
  • Singapore (20-21 Feb 2020)
  • Prag (24-25 Feb 2020)
  • Copenhagen (27-28 Feb 2020)
  • Zurich (4-5 Mar 2020)
  • Amsterdam (11-12 Mar 2020)
  • Shanghai (18-19 Mar 2020)
  • Hong Kong (25-26 Mar 2020)
  • Madrid (25-26 Mar 2020)
  • Mexico City (30-31 Mar 2020)
  • Mumbai (2-3 Apr 2020)
  • Bangalore (8-9 Apr 2020)
  • Chicago (15-16 Apr 2020)
  • Tel Aviv (22-23 Apr 2020)
  • Berlin (29-30 Apr 2020)
  • Stockholm (5-6 May 2020)

I want to stress out that this is a free event and that you can take advantage of two full days of sessions, as well as meeting with hundreds of presenters from Microsoft and partners.

My sessions in Paris

Microsoft Ignite the Tour Paris

In Paris I will present three breakout sessions (45 minutes) and one theater session (20 minutes). You can find some details about these sessions and activities at the links below.

Other activities in Paris

In addition to the Tour, you will also be able to see me at two occasions in Paris.

These two events will be conducted in French.

Ecole EPITA

EPITA

I will have the immense pleasure to introduce Microsoft Azure to students of the "Ecole pour l'Informatique et les Techniques Avancées" in Le Kremlin-Bicêtre near Paris. There, I will present my Azure 101 session which gives an overview of some services of Azure, as well as demos on how to make these work. I am very happy to have this opportunity to speak to future software developers who will shape the future of our industry. Students will see me there on Tuesday, the 12th of November between 12PM and 1PM. This event is not public.

.NET Meetup DevTalks

DevTalks

Community is and will always be one on the major reasons for my team to exist. We try to connect to local user groups as often as we can when we travel. On the 12th of November, I will also be honored to speak at a local user group about .NET, and I will speak about Cognitive Services on Azure. We will also have the pleasure to hear my esteemed colleague Frank Boucher who will speak about Docker on Azure.

You can register for this free event here.

I am very much looking forward to see everyone in France!!

Happy coding

Laurent

Meet me at Microsoft Ignite 2019

Cloud Developer Advocate, Microsoft Ignite, Microsoft Ignite the Tour, Work
See comments

Can you feel the excitement growing? Yes it's right, Microsoft Ignite and Microsoft Ignite the Tour are going to start soon.

Microsoft Ignite logo

Microsoft Ignite

Ignite is going to take place at the Orange County Convention Center in Orlando FL from November 4th to 8th. It is the largest Microsoft conference. It will also be the first time that I attend this show. It's also sold out, which means multiple tens of thousands of attendees will converge to Orlando soon...

To be honest I am a little worried to be overwhelmed by the sheer size of the event. But on the other hand it will be a great occasion to see all my friends and to make new ones :)

I will be quite active at Ignite and I am really excited about showing the sessions that we have been working on since, in some cases, August. It took a long time to prepare those sessions and polish them, and to prepare train-the-trainer packages (more about that later).

At Ignite, you will see me on stage at 3 occasions, and a whole lot of other occasions to connect with me:

MOD20 - Moving Your Database to Azure

CosmosDB, Azure SQL, Database Migration Service logos

In this session, I will show you how to migrate on-premises databses (MongoDB and SQL Server) to Azure (CosmosDB and Azure SQL Database). We will talk about our data offering, see how the Database Migratin Service assists you in the migration.

  • Agenda link
  • Date and time: Nov 6th, 11:45AM - 12:30PM

Here is the abstract:

Northwind kept the bulk of its data in an on-premises data center, which hosted servers running both SQL Server and MongoDB. After the acquisition, Tailwind Traders worked with the Northwind team to move their data center to Azure. In this session, you’ll see how to migrate an on-premises MongoDB database to Azure Cosmos DB and SQL Server database to an Azure SQL Server. From there, you’ll walk through performing the migration and ensuring minimal downtime while you switch over to the cloud-hosted providers.

MOD40 - Debugging and interacting with production applications

Azure Monitor logo

Here we will see multiple tools to monitor, debug and update web applications in production. This includes powerful tools like Azure Monitor, Application Insights, Log Analytics. We will also see how the Snapshot debugger can provide even more information about an issue. Finally we'll talk about one of my favorite features of App Services: Deployment slots. We'll see how these can be used to deploy new features safely, as well as perform A/B testing.

And for the abstract:

Now that Tailwind Traders is running fully on Azure, the developers must find ways to debug and interact with the production applications with minimal impact and maximal efficiency. Azure comes with a full set of tools and utilities that can be used to manage and monitor your applications. In this session, we will see how Streaming logs work to monitor the production application in live time. We will also talk about Deployment slots that enable easy A/B testing of new features and show how Snapshot Debugging can be used to live debug applications. We'll also see how other tools can be used to manage your websites and containers live.

MOD41 - Deploying and A/B testing without risks with Deployment Slots

Azure App Service logo

This session is a short 20 minutes theater session allowing us to deep dive into my favorite feature of the App Services on Azure, the Deployment slots. It's a deeper dive into one of the demos of MOD40 above. It will allow us to be more complete about safe feature deployment, where we use a staging slot as the target. Seeing how easily we can swap production and staging slots gives us great confidence, because in the worst case scenario, if an untested bug surfaces after the swap, we can easily swap back to the previous state, and take our time to fix the issue. We will also see how we can randomly redirect some of the traffic to a new slot for A/B testing. It means that some of the users will randomly see the new features, while others will still see the previous version of the site.

Here is the abstract for this theater session:

Who hasn’t been very scared when deploying a new feature to a website? Sometimes we feel that we will break everything, and the stress level is just not something we want to experience ever again. That's why the Deployment Slots feature of Azure App Services is such a nice experience. With Deployment Slots, you can deploy to a safe slot in the same conditions than your production environment. You can test in isolation, without risking breaking something. Then you can gradually route some of the traffic to the new features, for example to perform A/B testing. When you are satisfied with the results, you can simply switch the whole traffic to the new site. But don't fret, if something goes wrong, the old, safe site is just one mouse click away.

Debug bar

In addition to these sessions, I will often be available at the Debug bar. This is a place in the Development and Architecture Center where you can connect to Microsoft employees, MVPs and other partners, and talk about the topics that you love. I hope to be able to help for some issues but also to hear what you use our services for, and what you think can be improved (features, documentations, etc). Here is my schedule. I will make sure to update it if something changes, so make sure to bookmark this page!

  • Monday Nov 4th, 7:30AM - 11:00AM
  • Tuesday Nov 5th, 11AM - 1PM
  • Thursday Nov 7th, 3PM - 5:15PM

I am really looking forward to attend Ignite and to see you all there. Since I missed Build this year in Seattle, I didn't have my "fix" of first party conferences since Microsoft Ignite the Tour 2018 - 2019 ended in May. Ignite should be awesome :)

(and Ignite the Tour 2019 - 2020 starts soon, more in a future blog post soon :) )

Happy coding

Laurent

My new role for fiscal year 2020

Microsoft, Microsoft Ignite the Tour, Work
See comments

At Microsoft, we are using a weird way to count the years: Our fiscal year goes from July to July for some historical reason, and so every mid-calendar year, we are faced with what other firms often do in December: Reorganizing the teams, doing accounting, finishing up the budgets...

The end of the fiscal year 2019 also marked the end of our Microsoft Ignite the Tour 2019, in which we tried quite a few new concepts. We took this tour on the road in 17 different locations, including more remote locations where Microsoft rarely has first party conferences. I've personally spoken at 9 of these locations, many of these for my first time, including Mexico City, Sao Paulo, Johannesburg, Hong Kong and more.

You can see the videos of Microsoft Ignite the Tour 2019 here.

And in 2020?

With 2020 coming up, we are already hard at work on the next edition of Microsoft Ignite the Tour. And for this edition, we go bigger and further: We will have 30 locations on 5 continents (still no edition in Antartica I am afraid :)

For me personally, this is also time for a change. I asked for and obtained a change in my activities: Starting in August (which coincidentally also marks my second anniversary at Microsoft), I will move in my good friend Scott Cate's team, and my main activity for fiscal year 2020 will be dedicated to the Tour.

Learning paths: A success that we will repeat

More specifically, I will lead one of the learning paths consisting of five breakout sessions and one theater session. It's still a bit early to reveal what this learning path will be about, but let's just say that we are building on last year's feedback, keeping what worked great and improving the few areas where we can be better. The teams are now assembled and hard at work to create the sessions.

Polymath: A polyvalent presenter

One of the things we had to deal with last year was emergency situations. One of my colleagues ended up in the hospital just a couple of days before he was supposed to be presenting (he is good now, no worries :). We managed to solve this issue thanks to a very professional team and extra work, but it was stressy.

This year we want to be better prepared. This is why in addition to leading one of the learning paths, I will also take the role of polymath. In Wikipedia, the article about polymath is illustrated by a picture of Leonardo da Vinci.

Leonardo da Vinci

Source: Wikipedia

This is of course very ambitious and none of us is seriously comparing ourselves to that great man. By extrapolation, our definition of a polymath on Microsoft Ignite the Tour is someone who learns 10 different sessions, and is able to deliver those, in case of emergency such as above, with minimal preparation and time. This is a really interesting challenge for us, which will lead us to learn even more about Azure than we would normally do.

A Cloud Advocate is (amongst other things) a professional presenter, and so it's not new for us to learn and give new sessions in a relatively short time. But a big part of the job is also to be a learner. We keep learning new technologies, new services, every day. More than ever, at 48 years old I am still learning ever day, and I just love it. The polymath role pushes me further in that activity and I just love it. Without revealing too much, I can say that the areas where I will be learning and presenting are artificial intelligence, web apps, databases, containers and more.

In the next few weeks, we will start being more precise about the content of Microsoft Ignite the Tour, and I will also detail the locations where you will be able to meet me in person. For now, you can already get ready for Microsoft Ignite the Tour and check all the locations. I am looking forward very much to meeting more people in person, and to deliver these new and updated sessions.

Happy coding! Laurent