Peter Drougge https://docs.microsoft.com/archive/blogs/drougge/feed.xml Tue, 16 Apr 2019 05:04:41 GMT en-US hourly 1 Resurrecting WOPR/Joshua using LUIS https://docs.microsoft.com/archive/blogs/drougge/resurrecting-woprjoshua-using-luis Tue, 31 May 2016 20:50:56 GMT blogs.msdn.microsoft.com/drougge/?p=165 would you like to play a nice game of chess In the classic movie Wargames from 1983 where a young Matthew Broderick calls up a military supercomputer called WOPR (War Operation Plan Response), he guesses a "secret" password and starts talking to an AI called "Joshua". While basic in terms of todays' theatrical AI escapes into the movies, the idea of Joshua lit a spark in many young minds at that time. Let's have some fun and re-create a bit of their dialog, using the Natural Language understanding intelligence of the LUIS.ai service.

Prerequisites:

  • Visual Studio 2015
  • Download the Bot Application VS2015 project template located at aka.ms/bf-bc-vstemplate
    • place downloaded zip file at “%USERPROFILE%\Documents\Visual Studio 2015\Templates\ProjectTemplates\Visual C#"
  • Download and install the Bot Framework Emulator at https://aka.ms/bf-bc-emulator
If you just want the code - clone the repo at https://github.com/peterdrougge/Recreating-Joshua-With-LUIS
To quickly setup your LUIS app by importing my application, grab and use the json file at https://github.com/peterdrougge/Recreating-Joshua-With-LUIS/blob/master/Luis.ai%20app/Joshua%202.0.json

Step by step guide:

Point your browser to luis.ai and sign in. new luis application Next, create your application - this will be your trained model that you'll use to understand the intent of what is said. luis add a new application dialog
Now we have a new application created in LUIS and blank canvas that we can start to work with.
The contents of the application can at this point be focused on the left pane and the top pane.
luis clean canvas
We'll start by adding an intent called "ListGames" to our application. An intent is more or less directly equivalent to an api action/method in the code we'll later add. luis add intent After adding an intent we'll get a view showing the utterance mapped to that intent and any identifiable entities - think of entities as identifiable and relative content to the dialog. To get that going - Add these 3 entities:
  • Game
  • UserName
  • Determined
We'll use these entities to further enhance our dialog later on. Now, let's add more intents to our model:
  • SayHello
  • GreetPerson
  • PlayAGame
  • BackgroundStory
  • WinningMove
Now, on with the show and train, train, train & train our model some more. What we're talking about here is adding a lot of utterances. And correctly mapping all these newly added utterances to the right intent and also identifying any entities in each of them. luis mapping utterance The entities can be mapped something like this:
  • Game > any game name (note that you can span several words as one entity, like "global thermonuclear war")
  • UserName > any identifiable name about themselves that the user is providing to the bot (like "professor falken")
  • Determined > the strong intent of repeating the request and stating firmly that they want to do said action (like "no!")
Now, the more you train your model, the better it will be at correctly interpreting the interactions later on. In other words:
don't cut corners on training your model. Take the time and do a good job.
After that training session it's time to publish the endpoint of our model. luis publish start Once the endpoint is published we can go ahead and try it out. In this example I'm trying my endpoint with the query "hello there, my name is Peter". luis try published endpoint When i hit enter/submit a new tab opens up and the results of the query are shown. luis result of published endpoint As you can see, my query correctly mapped to the intent of "GreetPerson" and also correctly identified the "UserName" entity with my name. In just a few basic steps we've created a service that can correctly map the intent to actionable outcomes.

Awesome.

Now that we have a service to use, it's time to write some code. So, fire up Visual Studio 2015 and create a new Bot Application (because you followed the prerequisites and installed the template, right?). vs new bot application Once the template is done setting up you'll basically have an api app with a messages controller. Now I want you to add the Bot Builder SDK. It's a NuGet package and thus is easily fetched and installed. vs add nuget package bot builder Now we want to wire up our Dialog, so create a WarGamesDialog.cs class. vs add wargamesdialog class That class should inherit LuisDialog<object> and implement the above basic constructor. Further to that I've decorated the class with the LuisModel attribute that identifies the app id and secret key used. The app id and secret can be found either by looking at the querystring when you test your endpoint, or by looking at the "application" section on your LUIS application model. Next, we'll go ahead and map our intents and identifiable entities. vs wargamesdialog class with some content Things to note in the above image are the usage of the LuisIntent attribute decorating the methods, and the way the methods are wired using the in params. Also, when trying to locate entities - use the TryFindEntity approach since the entities will only be available if they exist, other they'll be null. In order to get you going swiftly, here's the complete code for the WarGamesDialog.cs class: 
    [LuisModel("YOUR LUIS.AI APP ID HERE", "YOUR LUIS.AI KEY HERE")]
    [Serializable]
    public class WarGamesDialog : LuisDialog<object>
    {
        public WarGamesDialog(ILuisService service = null) : base(service)
        {
        }
        public const string Entity_Game_Title = "Game";
        public const string Entity_UserName = "UserName";
        public const string Entity_Game_Determined = "Determined";
        [LuisIntent("None")]
        public async Task None(IDialogContext context, LuisResult result)
        {
            string message = $"Sorry I did not understand: {string.Join(", ", result.Intents.Select(i => i.Intent))}";
            await context.PostAsync(message);
            context.Wait(MessageReceived);
        }
        [LuisIntent("GreetPerson")]
        public async Task GreetPerson(IDialogContext context, LuisResult result)
        {
            EntityRecommendation name;
            if (result.TryFindEntity(Entity_UserName, out name))
            {
                context.UserData.SetValue<string>("UserName", name.Entity);
                await context.PostAsync($"Greetings, {context.UserData.Get<string>("UserName")}.");
            }
            else
            {
                await context.PostAsync("Well hello, stranger.");
            }
            context.Wait(MessageReceived);
        }
        [LuisIntent("PlayAGame")]
        public async Task PlayAGame(IDialogContext context, LuisResult result)
        {
            EntityRecommendation game;
            EntityRecommendation determined;
            var username = string.Empty;
            context.UserData.TryGetValue<string>("UserName", out username);
            if (result.TryFindEntity(Entity_Game_Title, out game))
            {
                if (game.Entity.ToLower() == "global thermonuclear war")
                {
                    if (result.TryFindEntity(Entity_Game_Determined, out determined))
                    {
                        await context.PostAsync("Fine.");
                        await context.PostAsync("Shall we begin?");
                    }
                    else
                    {
                        if (!String.IsNullOrWhiteSpace(username))
                        {
                            PromptDialog.Confirm(context, PlayAGame_AfterReconfirming, $"{username}, wouldn't you prefer a nice game of chess?");
                        }
                        else
                        {
                            PromptDialog.Confirm(context, PlayAGame_AfterReconfirming, "Wouldn't you prefer a nice game of chess?");
                        }
                    }
                }
                else
                {
                    await context.PostAsync($"Ok, so you want to play {game.Entity}.");
                    PromptDialog.Confirm(context, PlayAGame_AfterConfirming, "Shall we begin?");
                }
            }
            else
            {
                if (!String.IsNullOrWhiteSpace(username))
                {
                    await context.PostAsync($"I'm afraid I don't know that game, {username}.");
                }
                else
                {
                    await context.PostAsync("I'm afraid I don't know that game.");
                }
                context.Wait(MessageReceived);
            }
        }
        private async Task PlayAGame_AfterConfirming(IDialogContext context, IAwaitable<bool> confirmation)
        {
            if (await confirmation)
            {
                context.UserData.SetValue<bool>("DidSelectGame", true);
                await context.PostAsync("Thanks for playing! Now go check out luis.ai and dev.botframework.com.");
            }
            else
            {
                await context.PostAsync("Oh, Ok. I'll be here if you change your mind.");
            }
            context.Wait(MessageReceived);
        }
        private async Task PlayAGame_AfterReconfirming(IDialogContext context, IAwaitable<bool> confirmation)
        {
            if (await confirmation)
            {
                await context.PostAsync("You have chosen.. wisely.");
                context.Wait(MessageReceived);
            }
            else
            {
                await context.PostAsync("Fine.");
                PromptDialog.Confirm(context, PlayAGame_AfterConfirming, "Shall we begin?");
            }
        }
        [LuisIntent("ListGames")]
        public async Task ListGames(IDialogContext context, LuisResult result)
        {
            await context.PostAsync("please select a game:");
            var gameNames = "falkens maze, black jack, gin rummy, hearts, bridge, checkers, chess, poker, fighter combat, guerilla engagement, desert warfare, air to ground actions, theaterwide tactical warfare, theaterwide biotoxic and chemical warfare, global thermonuclear war.";
            await context.PostAsync(gameNames);
            context.Wait(MessageReceived);
        }
        [LuisIntent("BackgroundStory")]
        public async Task BackgroundStory(IDialogContext context, LuisResult result)
        {
            await context.PostAsync("I am WOPR: War Operation Plan Response.");
            await context.PostAsync("I was created by Dr. Stephen Falken for NORAD. When we talk Professor Falken calls me Joshua. I like that name.");
            context.Wait(MessageReceived);
        }
        [LuisIntent("WinningMove")]
        public async Task WinningMove(IDialogContext context, LuisResult result)
        {
            var didSelectGame = false;
            context.UserData.TryGetValue<bool>("DidSelectGame", out didSelectGame);
            if (didSelectGame)
            {
                context.UserData.SetValue<bool>("DidSelectGame", false);
                await context.PostAsync("Nuclear war is a strange game.");
                await context.PostAsync("The only winning move is not to play.");
                PromptDialog.Confirm(context, WinningMove_Confirming, "Would you like to play a nice game of chess?");
            }
            else
            {
                await context.PostAsync("Let's talk more before we go into deep thoughts like that.");
                context.Wait(MessageReceived);
            }
        }
        private async Task WinningMove_Confirming(IDialogContext context, IAwaitable<bool> confirmation)
        {
            if (await confirmation)
            {
                await context.PostAsync("Thank you. You'll surely win this time :)");
            }
            else
            {
                await context.PostAsync("Ok. Farewell.");
            }
            context.Wait(MessageReceived);
        }
        [LuisIntent("SayHello")]
        public async Task SayHello(IDialogContext context, LuisResult result)
        {
            var username = string.Empty;
            if (context.UserData.TryGetValue<string>("UserName", out username))
            {
                await context.PostAsync($"haven't we already introduced ourselves, {username}?");
            }
            else
            {
                await context.PostAsync("Hello.");
            }
            context.Wait(MessageReceived);
        }
    }
Next up - time to wire our Messages controller to use our new LUIS-powered dialog class. vs update messages controller Yes, that's really all we're doing - replacing the template-predefined message with 
return await Conversation.SendAsync(message, () => new WarGamesDialog());
Time to test all this, so: Build and run. Fire up the Bot Framework Emulator (that you installed, right?) and point it at our endpoint, then chat away! emulator 1 All cool stuff. But can we throw a curveball and use a not-so-common lingo? emulator 2 Nah. that still worked. So, how about we tell it something more context-aware? emulator 3 Woah.

Really cool.

It actually got the correct intent and entity regardless of me trying to be cool when chatting with it. Now I leave the rest up to you and I'll end this article with the same dialog that the movie closed with. emulator 4 
The code and LUIS model is available in the repo located at https://github.com/peterdrougge/Recreating-Joshua-With-LUIS
     ]]> Export Azure resource group template https://docs.microsoft.com/archive/blogs/drougge/exportresourcegrouptemplate Fri, 15 Apr 2016 10:14:04 GMT blogs.msdn.microsoft.com/drougge/?p=95 A useful functionality in Azure that has entered preview a few weeks ago is the ability to export a resource group as a template. This is very handy when you want to automate your environment setup or perhaps securely store your infrastructure setup in your source-control-of-choice.

 Here's how it works when you're doing it from the portal:

1

  1. Navigate to a resource group
  2. Select "Settings"
  3. In the Settings blade, hit "Export template"

 As the Export Template blade unfolds you'll be presented with the following view that show you the actions available as well as the actual template itself.

2

The Export template blade will not only show you the layout and contents of your arm template, but also the available parameters that affect your template:

4

Adding to that there's three more tabs that help you deploy the template..

5

.. CLI

6

.. Powershell

7

.. .NET / C#

Since this functionality is currently in preview you might end up trying to export a resource that's not supported at this point. If that happens, you'll see something like this in the blade:

8

To work around that you can always add the missing resource(s) manually after you've exported the template.

To act on your template you have 3 options:

3

Download
Creates a zip file with the template along with all the sample deployment files as well.
Save Template
Gives you the opportunity to save the template in Azure so that you can use it later via Browse > Templates.
Deploy
Creates a custom deployment based on the template.

]]> Migrating MySQL DB to Azure Linux CentOS VM using MySQLDump and SCP https://docs.microsoft.com/archive/blogs/drougge/migrating-mysql-db-to-azure-linux-centos-vm-using-mysqldump-and-scp Thu, 25 Feb 2016 04:05:42 GMT https://blogs.msdn.microsoft.com/drougge/2016/02/25/migrating-mysql-db-to-azure-linux-centos-vm-using-mysqldump-and-scp/ This week I was asked to help move stuff from a Linux machine to Azure. The task seemed simple – ‘web app & database. The web app went really fast, but moving a MySQL database from one VM to another is something that got me thinking.

After looking into various solutions for a while I figure there are multiple paths you can walk down:

  1. Use the ClearDB MySQL offer?
  2. Spin up a VM & install MySQL?
  3. Re-create everything using the Web app + MySQL template?
  4. Use Azure Site Recovery to migrate the VM?

For this example I decided to go with option #2 (that best matched the original setup): create a VM, install MySQL and copy the data there.

Note: this is not a ‘best practice’, ‘supported’ or ‘ideal way’ – just one possible way of migrating the DB.

Target setup

Since I didn’t have MySQL running in Azure I first created a new CentOS based Linux VM so that it would match the source setup as best as possible. This can be done either via the Azure portal, or using tools such as (Azure) Powershell or the Azure Command Line Interface (https://azure.microsoft.com/en-us/documentation/articles/xplat-cli-install/)

SSH to the new machine that will serve as MySQL host

I usually use Putty, but any form of SSH that you’re comfortable with is fine.

Update the installation

sudo yum update

install WGET if the command is not found

sudo yum install wget

Download and install MySQL from the community repository

sudo wget repo.mysql.com/mysql-community-release-el7-5.noarch.rpm
sudo rpm -ivh mysql-community-release-el7-5.noarch.rpm
sudo yum update

Install and start MySQL

sudo yum install mysql-server
sudo systemctl start mysqld
clip_image001

Harden the MySQL installation

sudo mysql_secure_installation

Login to MySQL as root to test the installation

mysql -u root -p

SSH to the machine you'll be exporting the MySQL data from

Again, I’m using Putty, but go ahead and use whatever tool you want for the task.

Dump (export) a database to a specific location

In this example I'm dumping the 'testdb' database to the '/tmp' folder and naming it 'exportedtestdb.sql'

sudo mysqldump -u root -p --opt testdb > /tmp/exportedtesttdb.sql

Use SCP to copy the export from the original server to your Azure VM

scp exportedtestdb.sql <username>@<hostname>:/tmp

clip_image002

Go back to the target machine

list the contents and you’ll see the copied file should be there

clip_image003

Import the database

mysql -u root -p testdb < /tmp/exportedtestdb.sql

That should do it.

P.

]]> Making use of your MSDN benefits to host a Windows 10 VM in Azure https://docs.microsoft.com/archive/blogs/drougge/making-use-of-your-msdn-benefits-to-host-a-windows-10-vm-in-azure Fri, 21 Aug 2015 04:21:14 GMT https://blogs.msdn.microsoft.com/drougge/2015/08/21/making-use-of-your-msdn-benefits-to-host-a-windows-10-vm-in-azure/ As you might already know, at dev.modern.ie you can find some great tools to use when developing and testing websites. One of those great tools is the downloadable Virtual Machines section that now also contains images with Windows 10 and Microsoft Edge.

But, instead of downloading that image, did you know that you can wire up your own in Azure?

Yes indeed, if you got an MSDN subscription and an Azure account you can create a Windows 10 Enterprise (x64) VM in Azure that you can use when testing with/for Microsoft Edge.

Here’s how you do it in (roughly) 5 minutes:

  1. Sign in to Azure at portal.azure.com
  2. Navigate to create a new Compute resource
  3. Filter for “Windows 10”

    image
     
  4. Select “Windows 10 Enterprise (x64)”

     image
     
  5. Step through the wizard one tier at a time

    image
     
  6. Choose a size to your liking. If one of the recommended doesn’t suit your needs, feel free to hit “view all” and pick a setup with the specifications you want. Just remember that depending on your account setup you might end up paying for it later. I picked Basic A2, which will work just fine for what I want to do.

    image
     
  7. When you’re happy with the selections you’ve made, hit “create” and you will be returned to the dashboard where you’ll see the animated progress of Deploying Windows 10 Enterprise (x64) 

    image
     
  8. At this point, go do something else for a couple of minutes unless you just want to stare at the animations. It’ll take a while. Not to long though, so don’t go to far. Once it’s done you’ll be prompted with a blade showing the details of your new virtual machine. 

     details blade
     
  9. That’s it really.
    Now you got a Windows 10 Enterprise (x64) VM running in Azure that you can remote to using a Remote Desktop client suitable to your OS.
     
  10. To connect to it, click the “Connect” icon. That will trigger a download of the remote desktop connection. Open it. 

    remote desktop 

    That will start the connection to the virtual machine. Authenticate using the credentials you specified in the first tier of the wizard (I named my virtual machine “EdgeTestVM” and my user *peter*)..

     credentials
     
  11. There you go. One fully functional Windows 10 Enterprise (x64) virtual machine running in Azure.

    image

This is an excellent alternative to running a virtual machine locally.

One last thing: remember to stop/deallocate your virtual machine when you’re not using it unless you want to pay for the full month of usage at the end.

]]> Microsoft Edge – keeping up to date with frameworks & libraries https://docs.microsoft.com/archive/blogs/drougge/microsoft-edge-keeping-up-to-date-with-frameworks-libraries Wed, 19 Aug 2015 04:47:12 GMT https://blogs.msdn.microsoft.com/drougge/2015/08/19/microsoft-edge-keeping-up-to-date-with-frameworks-libraries/ This article is part of a series of posts detailing specific compatibility tollgates for a modern web, and how you can take action to make sure your site works as intended in the world of modern web browsers:

Keeping up to date with frameworks & libraries

Common frameworks or libraries like jQuery are often updated to address compatibility problems when new browser versions are released.

Why is it important?

Your users may not be able to do what they want like navigate or view your webpage correctly.

What will we look for?

We check if frameworks or libraries that are not up-to-date and might contain bugs are present.

How can you fix it?

Our suggestion is that you keep frameworks & libraries up to date to prevent or fix compatibility problems.

  • Update any known outdated resources to its closest supported version.
  • Check using the Site Scanner available at dev.modern.ie for detailed info.
]]> Microsoft Edge – no more legacy plug-ins and features https://docs.microsoft.com/archive/blogs/drougge/microsoft-edge-no-more-legacy-plug-ins-and-features Wed, 19 Aug 2015 04:46:45 GMT https://blogs.msdn.microsoft.com/drougge/2015/08/19/microsoft-edge-no-more-legacy-plug-ins-and-features/ This article is part of a series of posts detailing specific compatibility tollgates for a modern web, and how you can take action to make sure your site works as intended in the world of modern web browsers:

No more legacy plug-ins and features

Why is it important?

As your visitors access your website from a plug-in free browser or device they expect the site to function normally. If you’re using plug-ins or unsupported features they may be missing out on content or features on your page.

What will we look for?

We check if the webpage has a plug-in other than Adobe Flash and PDF. Microsoft, and other industry leaders have embraced a vision of progressing the web towards a plugin-free experience.

How can you fix it?

We suggest building a plug-in free experience with web standards like HTML5 & CSS3 to reach the widest possible audience across browsers and devices.

Where can you learn more?

]]> Microsoft Edge – keeping up to date with CSS prefixes https://docs.microsoft.com/archive/blogs/drougge/microsoft-edge-keeping-up-to-date-with-css-prefixes Wed, 19 Aug 2015 04:46:09 GMT https://blogs.msdn.microsoft.com/drougge/2015/08/19/microsoft-edge-keeping-up-to-date-with-css-prefixes/ This article is part of a series of posts detailing specific compatibility tollgates for a modern web, and how you can take action to make sure your site works as intended in the world of modern web browsers:

Keeping up to date with CSS prefixes

CSS vendor prefixes or browser prefixes are a way for browser makers to add support (either fully or experimental) for new CSS features. They can also be used to add support for features that aren’t officially part of a standard but still widely adopted by the public.

The prefixes causing all the trouble (and what browser is using which one) are:

  • -webkit-
    • Android, Chrome, iOS, Safari
  • -ms-
    • Internet Explorer
  • -moz-
    • Firefox
  • -o-
    • Opera

 

Why is it important?

Following best practices when using vendor prefixes will help you reach the widest possible audience across browsers and devices.

What will we look for?

We check if the webpage may have missing vendor-specific prefixes or may have implemented vendor-specific prefixes when they are not required in common CSS properties. This may cause compatibility problems with how this webpage renders across different browsers.

CanIUse.com - pointer events? CanIUse.com - border images?

How can you fix it?

Since it's very difficult to validate and verify all vendor specific properties, it becomes easy to make mistakes.

clip_image005

If you’re using Visual Studio you definitely should check out Web Essentials – the Visual Studio web developers’ secret cache of ninja tools.

In Web Essentials the validator will automatically make you aware of any unknown or deprecated vendor specifics. The same goes for any missing vendor specific properties – it’ll let you know of these as well.

Where can you learn more?

]]> Microsoft Edge – don’t do browser detection https://docs.microsoft.com/archive/blogs/drougge/microsoft-edge-dont-do-browser-detection Wed, 19 Aug 2015 04:45:18 GMT https://blogs.msdn.microsoft.com/drougge/2015/08/19/microsoft-edge-dont-do-browser-detection/ This article is part of a series of posts detailing specific compatibility tollgates for a modern web, and how you can take action to make sure your site works as intended in the world of modern web browsers:

Don’t do browser detection

Browser Detection is a technique to determine how the webpage should render across many different versions of browsers. In a script this would mean using code like navigator.userAgent to act differently depending on what User Agent string is supplied to the page. Every browser you’re using has a User Agent string that contains information about the browser. Only problem with that “unique” string is that since way back they’ve more or less imitated each other, and today they hold (pretty much) the same information. It is not a reliable way of determining if a feature is supported or not. Simply put – User Agents can’t be trusted.

Why is it important?

Your users will get their best experience in their preferred browser. You can spend less time maintaining separate code bases for various modern browsers including Microsoft Edge.

What will we look for?

We check if the webpage may be using browser detection techniques to determine how the webpage should render across many different versions of browsers, like browser.userAgent.

How can you fix it?

We recommend that instead of browser detection you go with feature detection – a practice that first determines if a browser or device supports a specific feature and then chooses the best experience to render based on this information. Feature detection is a great alternative to browser detection and is commonly used via popular JavaScript libraries like Modernizr or through feature detection code. There’s also sites like CanIUse.com that easily lets you check what features are available in what version of what browser.

CanIUse.com - Pointer events? CanIUse.com - Border images?

Where can you learn more?

]]> Microsoft Edge - EdgeHTML interoperability https://docs.microsoft.com/archive/blogs/drougge/microsoft-edge-edgehtml-interoperability Wed, 19 Aug 2015 02:45:14 GMT https://blogs.msdn.microsoft.com/drougge/2015/08/19/microsoft-edge-edgehtml-interoperability/ This article is part of a series of posts detailing specific compatibility tollgates for a modern web, and how you can take action to make sure your site works as intended in the world of modern web browsers:

EdgeHTML interoperability

Previously we stood on the barricades proclaiming “adhere to standards!”

That’s still true. Sort of.

Reality though is more “adhere to interoperability”.

The days of quirks mode, compatibility issues or rendering issues should be long gone.
The only thing now standing in the way between a good, universal web and your customers is your own code.

You shouldn’t have to worry about sending your markup in different forms to different browsers – the web should just work and you should only have to send your awesome markup one way.

Why is it important?

Your users will get their best experience in their preferred browser. You can spend less time maintaining separate code bases for various modern browsers including Microsoft Edge.

What will we look for?

We check if the webpage may include HTML markup that treats Microsoft Edge differently from other modern browsers.

How can you fix it?

We recommend your site to send your markup to all modern browsers and then include Microsoft Edge in your test matrix. This will also help you progress towards maintaining one code base in the future.

Where can you learn more?

]]> Why should you care about Microsoft Edge? https://docs.microsoft.com/archive/blogs/drougge/why-should-you-care-about-microsoft-edge Wed, 19 Aug 2015 02:34:00 GMT https://blogs.msdn.microsoft.com/drougge/2015/08/19/why-should-you-care-about-microsoft-edge/ This post is a short intro to a 5-part mini-series.

imageMicrosoft Edge is our browser for the new, modern web built exclusively for Windows 10.

It’s engineered to enable you to go beyond browsing the web and to start experiencing a more personal and productive web.

It’s not packed with legacy support. Nor will it render your site differently based on some flags. It will however treat your site the way it’s meant to – assuming you’ve done your part.

The thing is though – Edge will be installed on every Windows 10 installation.

Every. Single. One.

Think about it - That’s several million installations already, and a lot more adding to those numbers each day.

Edge is not another new version of Internet Explorer.
It is something completely different.

It is unique.

Making sure your website works in Microsoft Edge

We will try to help you circle some of the common pitfalls we’ve identified when it comes to compatibility. We will specifically look at these five issues:

Each of these posts will contain a Why? What? How? And Where? Section aimed at guiding you in the right direction to fix your website.

The Compatibility View list

If, for some reason, we or your users detect and report that your site is not functioning properly in the browser it could end up on the Compatibility View list – basically saying that it’s rendering for the not-so-modern web. If this happens to your site but you think that it’s incorrect and you wish to be removed from the list, reach out to iepo@microsoft.com.

clip_image002

 

Tools made by us, for you to use, at your convenience

At dev.modern.ie you’ll find useful tools that we’ve created for you to make sure your users get the best experience possible when visiting your website from different browsers.

clip_image004

Some of the things you can do at dev.modern.ie:

And, last but not least, check out the recorded sessions from Microsoft Edge Web Summit 2015 over at Channel 9 for some really interesting insights into Edge.

]]>