Tuesday, May 19, 2020

Highlights from BUILD 2020 (so far)

I'm missing being in Seattle for the BUILD conference this year. :(
It's normally one of my favorite events and a highlight of my year.

However, like most events this year, it's gone virtual. Anyone can watch online and there are likely to be many more things that are announced.
This is what's caught my attention initially.
  • Project Reunion - Unifying and evolving the Windows development platform.
  • WinUI 3 preview - The future approach to building native Windows apps.
  • WinGet - The new Windows Package Manager can change how we distribute and install apps.
  • MAUI - Xamarin.Forms is evolving and getting a new name.  github.com/dotnet/maui

more to come....

Wednesday, May 13, 2020

More fun with comments

This is probably the least interesting screenshot I've ever shared
and this one is only slightly more remarkable
Yes, it's the same method from the same file.
But, did you spot the difference?

It's only small.
Look at the left margin.
There are more of the little outlining boxes with minus signs in them in the second image.

The first image is the default behavior. It shows something I hadn't noticed before.
By default, in a method, only multi-line comments starting with a triple-slash can be collapsed.

And the second screenshot?
Well, it turns out that as I wrote a Visual Studio extension that works with comments, these are the kind of things I learn.
As such the second screenshot shows a minor feature of the latest version (1.8) of that extension. It now lets Visual Studio know how to collapse (and expand)  multi-line comments within method blocks. (That's not a piece of code I ever imagined writing!)

Additionally, it also:
- fixes a bug in how it identifies which block to expand and collapse.
- fixes a bug that affects anyone who uses tabs instead of spaces.

Now go: download, install and review the extension for yourself.

Sunday, May 10, 2020

Spaces beats tabs (by a factor of a thousand!)

Yes, there are reasonable arguments for each approach. I know that the accessibility argument for tabs is very strong. But I use spaces. It seems that so many people also do that I'm surprised that this is still an issue.

How many more? (Well, if the title wasn't a give-away) a thousand times more!!!

I have a Visual Studio extension for manipulating comments. It recently passed a thousand installs.
I also recently had a bug filed against it. The bug only affected code that used tabs instead of spaces.

Based on this single, unscientific data-point, it looks like there are at least one thousand people using spaces for each one using tabs.

- this isn't scientific.
- this is me twisting the statistics to make a point.
- others may have encountered this but not reported a problem.
- installs and actuals use aren't the same things.

Why is this worth blogging about?
- This number is MUCH bigger than I was expecting.
- This debate is usually based on arbitrary preference and not on data. (I have data because I'm doing something that involves code manipulation and parsing.)

I'm not bothered about which you use (as long as it's not a mixture of the two--now that's barbaric!)

Tuesday, April 28, 2020

Collapse Comments (v1.4) and expand them

Comments (in code) can be really helpful. But, at other times they can get in the way of the code you're working on.

It's for the times when I just want the comments to get out the way that I created the Collapse Comments extension for Visual Studio 2019. It adds a simple command to collapse all the comments in the open document that you can invoke by pressing Ctrl+M, Ctrl+C.

I've just released version 1.4 and this includes something new. It includes the ability to do exactly the opposite of what I specified above. It adds another command that will expand all comments and collapse everything else.
It's not a scenario I have to deal with a lot but came as a suggestion (thanks Morten) who frequently looks at the decompiled code (and comments) that Visual Studio can generate. The generated file lists method names with comments (which are automatically collapsed upon opening) and it's the comments that are most important here for understanding all the different overloads. For this reason, it makes sense to be able to quickly expand all the comments by pressing Ctrl+M, Ctrl+D.

There's an option to control whether to treat using (or imports) directives like comments, and it works with C#, VB.NET, and XML documents.

Get it now, for FREE, from the Visual Studio Marketplace.

Got thoughts about this? Why not leave a comment below? I promise not to hide it away ;)

Monday, April 20, 2020

How to use VSIXSignTool

Trying to be a good developer/publisher, I sign my Visual Studio extensions.

Signing VSIXs is optional but it sends a good signal. Plus I have a code-signing certificate because I had to get one to sign NuGet packages as they MUST be signed.

But knowing how to sign a VSIX isn't obvious.
When I first wanted to sign an extension I was using Visual Studio 2017 and found the Extensibility Tools for Visual Studio from Mads Kristensen. This includes a UI for signing the generated package.

This was all good until I moved to exclusively use Visual Studio 2019. Those extensibility tools aren't supported in VS2019 so I was stuck.

To unblock myself, I ported the signing functionality, from the above-referenced tools, into a separate package that works with VS2019. A few hundred other people have also used this so I guess they were in a similar situation to me.

Fast forward to a week or so ago and I came across the NuGet package Microsoft.VSSDK.Vsixsigntool

This looked very interesting but lacked instructions on how to use it.
There's a link to some release notes but they're for "Visual Studio 2015 Update 2".
The "Project Site" link goes to the general landing page for Visual Studio Extensibility. :(

After more searching than I thought should be necessary, I eventually found https://docs.microsoft.com/en-us/visualstudio/extensibility/signing-vsix-packages?view=vs-2019
This page should be helpful but only includes some vague descriptions of what to do. :(

To try and work out how to automatically sign my generated packages using this tool, I did what I often do to solve problems relating to extension development, I searched GitHub to work out how other people had done it. Eventually, I came to this solution.

I added the following to my project file.

    <VsixSignCommand>$(VsixSignTool) sign /f $(SIGN_CERTIFICATE) /p $(SIGN_PASSWORD) /sha1 $(SIGN_CERT_HASH) /fd sha256</VsixSignCommand>
  <Target Name="AfterBuild" DependsOnTargets="CoreCompile" Condition="Exists('$(SIGN_CERTIFICATE)')">
    <Message Text="Signing $(TargetVsixContainer)" Condition="'$(Configuration)' == 'Release'" />
    <Exec Command="$(VsixSignCommand) $(MSBuildProjectDirectory)\$(TargetVsixContainer)" Condition="'$(Configuration)' == 'Release'" />

This relies on two things:

  1. The NuGet package is referenced in the project.
  2. Add environment variables for the relevant parameters.

Points of note:
  • This allows for the certificate to be in different places on different machines.
  • This means there is no need to check the certificate into the code repository.
  • The password doesn't get checked in with the source.
  • If the environment variables aren't specified the process is skipped. This is how I avoid any issue with running this on a public CI server. It only needs to be defined on the machine that builds the release version for publishing.
  • The certificate hash was found with the following command.
>certutil -p ****** -dump ./filename.pfx

I also learned that it's possible to reference environment variables in MSBuild files. However, it's necessary to restart Visual Studio for it to pick up any changes (or additions) to these.

With this all set up, every time I build a release version of my extensions they are automatically signed without me having to do anything else. This simplifies the process and avoids me needing to enter the certificate file path and password. Yay!

There are probably other solutions with online key vaults and other such things but this works for me. Maybe this will help you too.

Saturday, April 18, 2020

ConstVisualizer v1.2 released and out of preview

My Const Visualizer extension is now at version 1.2 and out of preview.

Version 1.0 was only released this week but it has allowed me to identify some use cases that I hadn't previously accounted for. This is why I originally released it with a preview tag.

Having previously seen an increasingly broad range of code-bases, I had a very strong suspicion that there might have been things I originally missed. Thanks to people who tried out the first version and gave me feedback, the less obvious cases (to me) are now covered and it should work for all use cases where the definition of the constant is in the same solution.

For anyone who needs (or wants) to see constants defined in other code-bases (such as in referenced libraries) I'll wait for them to raise an issue to request this. ;)

Tuesday, April 14, 2020

Comment Links v1.2

I've just released an update to my Comment Links extension.

Version 1.2 adds the ability to create links through new context menu options on the editor.

No more manually composing links yourself. Now you can just put the cursor where you want the link to go to and create it that way.
The formatted link is copied to the clipboard for you to paste wherever you want it.
Copied links are also listed in the Output Pane so you can also access them from there (and even navigate from there too.)

Thanks to Michael for the suggestion.

View constants where you use them in your C# code

When debugging or just trying to understand code, it can be useful to see the value of constants. Yes, you can try and remember the values but seeing them is often easier.

The above is enabled by a new extension, I've just published, called Const Visualizer.

Yes, there's a lot of similarity between this and String Resource Visualizer.

Const Visualizer is something I've been meaning to create for a while but I've done it now as a pre-cursor to adding new functionality in the String Resource Visualizer. It's forced me to learn how to integrate Roslyn code analysis into an extension and look at other ways of analyzing the contents of a solution.

Why not put all the functionality related to const values and string resources in one extension?
Two reasons. 1. Because I prefer lots of simple tools that each focus on a single task. These can then be combined and used as preferred.  and 2. Because the existing "String Resource Visualizer" name doesn't expand well to cover other functionality too.

Please install it, give it a try, and see what you think. Does it make your coding-life easier too?

Saturday, April 11, 2020

Have you heard about text fragment anchors?

There are always lots of exciting and interesting things happening in the world of web development. One I just heard about is an experimental feature in Chrome that allows you to create links to any point on a page.

If you want the technical details, see this project from the Web Incubator Community Group.

It will work like this.

You include the text you wish to link to at the end of the URL with the special new `#:~:text=` anchor indicator.

Then the first occurrence of that text is highlighted on the page.

This is still an experimental feature and only works in some browsers. You must enable it like this:
In Chrome:

Or in the new Chromium-based version of Microsoft Edge.

Once you've enabled it and restarted your browser: give it a try

FYI. This was brought to my attention because of a project I'm doing relating to inter-document linking.

Friday, April 10, 2020

Comment Links - v1.1

Version 1 only shipped yesterday but there's a new version already.

Version 1.1 includes three changes:

  • The ability to support file and path names containing spaces. (including if they're URL encoded)
  • Support for search terms that include spaces
  • Indicating when a file can't be found (in the status bar). This also includes line numbers that don't exist or search text that can't be found.

These changes are the result of issues submitted on GitHub. Please raise any other feature requests there ;)

  • There was also a bugfix relating to navigating to the line containing the search text.

Download and enjoy.

Stay safe.

Thursday, April 09, 2020

Navigate between files of different languages in Visual Studio

Visual Studio has great tooling for navigating within code when it is in the same (programming) language.
However, if your solution contains code in more than one language and you want a quick way to navigate between files you're out of luck. Until now!

Presenting: Comment Links
Yes, it's (another) new Visual Studio 2019 extension. This one lets you put links between files anywhere in your code. In theory, this could be anywhere in your code, but in comments makes the most sense. Just include the text `link:` (case-insensitive) followed by the file name.

A green button with an arrow on it will, when clicked, open the named file.

You can also have the file open on a specific line by including the line number after `#L` at the end of the file name.

// link:mapManager.js#L25

 Or you can jump to the first occurrence of a specific piece of text

// link:mapManager.js:UpdateLocalData

For compatibility with text fragment anchors you can also use `#:~:text=` after the file name to specify the text.

// link:mapManager.js#:~:text=UpdateLocalData

Version 1.0 is in preview and available from the Visual Studio Marketplace now.
Please give it a try and tell me what you think or suggest new features on GitHub.

This project was the result of a comment from one of my GitHub sponsors. If you join them I'm likely to take any suggestions you make more seriously. ;)

Thursday, April 02, 2020

Automatically collapse code comments when opening a document

I've just released a new version (1.2) of my Collapse Comments extension for Visual Studio.

Amongst the changes are two new configurable options.

Whether using (or imports in VB) directives are collapsed as well as comments is now configurable. This is the old behavior and so is enabled by default.

The other new option is the ability to automatically close comments whenever a new document is opened. This is off by default as it's a change in behavior.

Please let me know what you think of these changes, or, even better, leave a review :)

Monday, March 23, 2020

Open URLs in the error/warning description

It can be more effort than it feels necessary to navigate to a URL in a message description.

To get to it you might type it into a browser, or more likely, copy the whole message and then copy the URL and then paste it into a browser.

But, you're a busy developer. You have better things to spend your time on than unnecessarily cutting and pasting URLs that you can't easily open.

What you need is a way to open that URL in a browser without all the faff.

Congratulations, you're in luck. I've just updated my Error Helper extension to enable just this scenario.

After you install the extension, you can simply right-click on the entry in the error list and select Open URL. I'm sure you can guess what will happen then ;)
What could be simpler?

And for the avoidance of any doubt, the other options highlighted above will copy the description of the selected entry into the clipboard or search for the description in your default browser.

If you haven't already go install it now.

Don't just take my word for it, here's what others have said.

Thursday, March 19, 2020

Controversial idea: Get rid of the XAML Image tag

Here's an idea I've had swimming around in the back of my brain for a while. I've not yet settled on it 100% yet, but when I do, I'll start some proposals, and discussions with the appropriate people/organizations/repositories.

This is me writing down my ideas to help better think them through and for those of you who come across this page to have a chance to share your thoughts.

Let's get rid of the <Image /> tag!

I acknowledge that this is a potentially controversial idea and it would be a BIG change to a lot of people but I think it has the possibility to advance XAML based development in two important areas: semantics and accessibility.

I'm increasingly persuading myself on the benefits of improving the intent of written XAML. Having a generic image tag only communicates that an image should be displayed but provides no information about how that image is used within the UI. This is far from optimal. Alternative/replacement controls could do a better job of communicating intent and aiding the readability of the code.

The vast majority of XAML based apps that I've seen make little or no regard for accessibility support and how screen-readers work with images in apps created with XAML. While HTML and the web are far from perfect, they do a much better job of encouraging people to use "alt" tags on their images. As accessibility and inclusive design continue to grow in importance and consideration for all users of all software, I expect an increased need for XAML based UIs to be asked to do a better job in the coming years.

How would we get rid of it?
In an ideal world, I'd mark it deprecated and then rename it (to BaseIamge) and make it abstract. I'd then add tooling to indicate it shouldn't be used and a suitable replacement is used instead.
The tooling part is easy (:wink:) but the other parts would cause A LOT of compatibility issues. I'd settle for introducing alternatives and recommending they are used instead. I don't really expect to be able to change the current Image tag.

What I propose we have instead

I propose adding two new controls to replace (or be used instead of) the current one: BackgroundImage and ContentImage.

This would support an image source and be almost identical to the current Image control. The difference would be that this would never show up in accessibility tools. It's just a background, so it doesn't matter if some users of the software don't know about it. The name also communicates to future developers that this is just part of the background and shouldn't host anything important like the content.

This would be like the existing Image control but also add a required description property. The value assigned to this property would be made available to accessibility tools so that anyone using the app but unable to view the image wouldn't miss out on important content information.
The description could also be used as a fallback if the image couldn't be used, similar to how alt text is displayed on websites when images don't load.
Tooling could easily be added to check that this property is set and a suitable (non-empty) value is provided.

I might have missed something obvious but I think almost all uses of images in apps could be classified as background or content.

That's it. It's quite simple.

  • Stop using Image.
  • Use BackgroundImage for visuals that aren't important and only part of the visual aspect of the page.
  • Use ContentImage for pictures that do contain important information that should be communicated to the user even if they aren't able to view the image.

As this is the internet, feel free to tell me why I'm wrong, what a silly idea this is, and the obvious things I've overlooked. ;)

Monday, March 16, 2020

Introducing: Clearly Editable - making it clear which documents can be edited in Visual Studio

The way some people* use Visual Studio means that they may use or open generated or read-only documents.

There can be lots of reasons for this:

  • They might generate code with a tool.
  • They may need to debug the compiler-generated code.
  • They might use a version control tool that locks files by making them read-only.
  • Many other, valid, reasons...

When working with such files, it can be REALLY frustrating when:

  • you start typing in a document but nothing happens (because it's read-only.) or
  • you make some changes in a generated document (because you don't realize it's generated) and those changes are lost when the file is regenerated.

Visual Studio already has some ways to try and help avoid the above scenarios but they're not always enough.

When a read-only file is open this icon is shown in the tab.
But it's small and easy to miss.

Generated documents typically have a comment in the header of the document to point out that it's been generated and should not be edited directly.
// <auto-generated>
//     This code was generated by a tool.
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
But, comments aren't always read, or even visible. It can also be easy to forget that a document is generated when switching between documents or if it's been open for a long time.

I present an alternative solution.

It changes the background color of the editor to make it harder to forget or miss if a file is read-only or generated.

The image below shows three open documents.

  • The document on the left is a generated file and has the background set to a pale green color.
  • The middle document is a read-only file and has the background set to a pale red color.
  • The document on the right is neither generated or read-only, just like most files you work with and so there are no modifications to the configured theme colors.

The intention here is that different background colors are harder to miss.

The colors are configurable.

Change them to what you prefer and what works with your other theme/color settings.

You can set the color by specifying a color name or an RGB HEX code.
Opacity is set by providing a percentage so that is can work with named colors and because calculating RGBA (or ARGB) isn't the simplest thing in the world for everyone.
You can also disable the highlighting of either type of file. Or, disable all functionality without having to uninstall the extension and restart Visual Studio.

Go to Tools > Options > Clearly Editable

Options dialog showing the default settings.

Give it a try by installing it from the Visual Studio Marketplace.
If you like it, please leave a review.
If you encounter any problems or have suggestions, please open an issue on GitHub.

* If this isn't you, that's fine. I have other extensions that might be useful to you.

VB.NET is done, not dead

This post on Visual Basic support planned for .NET 5.0 has caused some to complain that Microsoft is abandoning or killing Visual Basic. Discussions on plans for alternatives or open-source continuations or extensions to the language have picked up.

In amongst all the hype, hyperbole, and over-reactions, it's important to take a step back and think about the big picture.

There are plans from Microsoft to continue to support Visual Basic going forward.

  • If you use Visual Basic to build software based on the .NET Framework that will continue to work and be supported.
  • If you use (or want to use) Visual Basic to build software based on .NET Core (& .NET 5 going forward) that will work and be supported. And, as per that blog post, more application types will be supported than are currently.

There are plans to stop evolving the language and adding new features.

  • Adding new features makes it hard for people new to a language to learn it as there is more to learn. Visual Basic has always focused on making it easy to get started.
  • Every language doesn't need every feature. 
  • It's ok to use more than one language. No, you can't use them in the same project, but you can use them in different projects in the same solution.
  • This may mean that there is future functionality added to .NET Core that isn't as easy to use in Visual Basic. I'm sure workarounds and alternatives will be found though. A similar impact has also been had on C# where there are C#8.0 features that can't be used in software based on .NET Framework. At least VB developers will be spared the "what features of the language can I use in this code-base?" question.
  • Trust that Microsoft isn't making this decision to be difficult or pick on people who like using Visual Basic. Assume this is a business decision based on lots of data and discussion with the understanding of the consequences of doing this, as well as the benefits that can be gained by focusing efforts elsewhere.

If all you know is Visual Basic and you worry your skills are becoming less relevant, don't panic.
Learning new programming languages can be easier than you might imagine and typically brings insights into how you may want to use the language(s) you already use.

Also know that you know more than just a programming language.

  • You know how to put software together.
  • You know what good and bad coding practices look like.
  • You know how to work with other developers and other people in a business to deliver a software product.
  • You know how to solve problems when code doesn't do what you want.
  • You know how to ask and look for help.
  • You know what people using your software do and don't want.
  • You know much more than just a programming language.

Of course, things may change. But this is the world of technology. New things are created, adoption and usage changes, and older things are used less. Software is a world of constant change. If that's something you can't cope with it might not be for you.

And remember:

Wednesday, February 12, 2020

Resource Pseudo Localization - Protecting developers from themselves

I have a tool to help test the localization of strings in an app. It does this by making changes to the resource files (.resx & .resw) to help make it easy to test that all content is coming from the resource file. There are a number of different options available and more on this is covered in my book.

I've just released a new version (3.0) that adds a single new feature.

The new feature is that it creates a backup of the original file before it changes the content.

I know that it can be frustrating when tools create unnecessary extra files but I feel this is better than someone getting into a situation where they lose lots of work.

There's an option to turn this off if it's not wanted but it's on by default as that's better for avoiding unexpected negative consequences.

This isn't the result of someone having a problem. Rather, it's me trying to avoid a problem before it occurs.
Someone did ask how to get back after they'd toggled one of the options (you just need to toggle it again to undo the change) but I realized that not everything is obvious to everyone and there are all sorts of developers with various skills, knowledge, and experience.
In case anyone ever converts all their resources to something that can be automatically reversed, and they don't have another copy, and they don't have source control. At least they'll now have a backup.

If you're interested in trying out this extension, you can get it from the VS Marketplace.

Monday, February 10, 2020

Modern XAML Development - slides and overview

Slides! - because that's all some people think a talk is.

Let me add some background.

Above are a modified version of the slides used in this talk. The modifications remove things that aren't relevant, were there just as a backup for the more risky demos, and strip out the animations.

This is not the whole talk!
There is no way you could take this deck and give the same talk.
For starters, there are 10 (yes ten) demos that aren't included here.

I do not have slide notes.
Sorry, no. For what the slide doesn't make clear you're out of luck.

It's a talk, and the slides are there to support what I say. I'm not there to talk about the text on the screen. I know some people do it that way but I don't.

The basic structure of the talk is as follows:
  • Why XAML was created?
  • How it's developed and evolved.
  • XAML has multiple versions, allows you to build for multiple platforms, and has multiple ways of doing things.
  • Given all those variations, tooling hasn't always been great, but that is starting to change.
  • There is a lot to be gained when thinking about XAML as code and what you expect from the tooling for other languages.
  • Given that comparison:
    - What about creating apps that use XAML?
    - What can be done in the editor?
    - What can be done in the designer?
    - What can be done at run-time?
  • What's coming in the future?
  • Conclusion and questions
I don't have a script for the whole talk. That's why I can't share one here.
Instead, I plan by focusing on the overall structure. I then look at how different elements can fit into that structure.

The structure comes down to two parts.

  1. Provide background
  2. Walkthrough building an app and show how the tooling can help at different stages.

Within the walkthrough, I combine a number of small demos to show different features and that things work with different platforms. This means jumping between WPF, UWP, and Xamarin.Forms projects but this shows that the tools apply regardless of the platform without repeating everything three times or just claiming what's possible.
Having multiple small demos also allows me to focus on one thing in each demo. Trying to put everything in a single demo was more complicated than I could manage and involved too many things being on screen at once which was potentially distracting and confusing.
Having multiple small demos made them easy to practice. I practiced the demos many many times in preparation for giving the talk. Having small, simple demos allows me to experiment within the rehearsal to become familiar with variations. It allowed me to explore things like "what if I did this differently?", "How could this go wrong?", or "How could I make this simpler?".
Because each demo doesn't depend (much) on what's gone before it I can make changes in one demo without having to worry about possible negative consequences in subsequent demos.
Finding times to practice small demos is easier for me to do than finding the time to practice a long, complicated demo.
Not being tied to a specific, strict format allows me the flexibility to adjust the talk when given based on anything that may happen on the day, has been said in other talks earlier in the conference, or where my mind goes at the time.

Preparing this way takes ages. It's not something that can be done without a lot of time to prepare and so it's not a technique that can always be used. I do it where/when I can.

I made sure to know the content inside out and roughly how long each section takes and then adjusted what I said accordingly on the day.

I deliberately include some questions on slides at the end. This is for a number of reasons.
  • It shows I'm open to answering difficult questions.
  • It provides an easy way to answer common questions that I didn't cover earlier.
  • It provides an opportunity to cover questions that don't naturally fit into the rest of the talk.

When I gave this talk in Stokholm I finished, including the Q&A section with 3 seconds remaining.
Additional questions were taken 1-to-1 immediately after the talk.

Hopefully, this is useful if you're interested.

Also, links to tools mentioned in the talk can be found at https://www.mrlacey.com/2020/02/modern-xaml-development-notes-from.html

Tuesday, February 04, 2020

Modern XAML Development - notes from SWETUGG

Today (at the time of posting) I'm talking in Stokholm about Modern XAML Development.

Here for your simple consumption are links to all the things I talked about, demonstrated or otherwise mentioned.

Sorry, it's not the actual slides. There are only so many cat pictures I want to contribute to the web. ;)

Slides and notes can be found at https://www.mrlacey.com/2020/02/modern-xaml-development-slides-and.html

Friday, January 24, 2020

Feb 25th is UnoPlatform day (in London & Birmingham)

Are you in London or Birmingham (in the UK)?
Want to learn more about the Uno platform?

Uno logo

You're in luck, as I'm giving introductory talks:

In London, on the morning of Feb 25, at 9AM

In Birmingham, on the evening of Feb 25, at 6PM

More details and registration can be found by following the above links.

If you're in (or near) London but can't attend at this time (maybe you have work or something like that) stay tuned for details of an evening event coming soon...

Thursday, January 23, 2020

Usability Matters for the Surface Neo and the Surface Duo

Concept images of Surface Neo and Surfsce Duo devices

In my book (Usability Matters), I cover details about identifying reasons for building apps and planning app development.

Before the new surface devices arrive and trying to avoid the hype, in this post, I want to use the structure and pointers from the book to highlight important areas about which to think.

Assuming you have an existing app and are thinking about adjusting it for these new devices.

Are these devices going to be available where your users are?
These devices are unlikely to be available globally when launched, or even in a few months after. Using the launch of previous Surface devices as a guide, expect them in North America and parts of Western Europe first. If that's not where your users are, then you may be able to wait and learn from the real experiences of others before needing to do work yourself.

Are your users likely to get these devices?
I don't know anyone who reasonably expects these devices to be cheap. They're new, cutting edge devices pushing the boundaries. Such devices aren't something that usually comes cheap. Other Surface devices do not have price tags that make them accessible to everyone. It's tough for device manufacturers to make money from selling devices*, and this also points to an expected higher price point.
If your users aren't already using high-end devices, it's unlikely that they'll start using these devices (or similar) as soon as they're released.

* As an aside, I heard recently of a manufacturer planning to leave the handset business as it is so hard for them to make money.

Will the devices provide opportunities appropriate for your app and users?
At the moment, it's hard to know. What will happen when "real people" get to use these devices? Will they use them in the ways you or Microsoft expect? You will need to research to find this out. While this may not be possible for you yet, what you can do is make sure you understand what your current users are doing. To do so will require adding usage analytics into your app if you don't have them already. 

What is your goal in attempting to understand and develop for these devices?
  • Is it curiosity?
  • Are you a Microsoft fan who is only interested as this is something they're doing?
  • Do you aim to ensure an adequate experience when someone uses your app on such devices?
  • Do you hope to take advantage of the unique opportunities the new form factors will provide in terms of ways of working or using a device?
  • Or, are you looking for a possible boost from being one of a (potentially) small number of apps specifically built or updated to work with these new devices upon their launch?
If you understand your motivation, you'll be able to work towards achieving the related goals. It'll also help you avoid setting inappropriate goals or retrospectively thinking you were setting yourself up for a different possible outcome.

What can you learn from other, existing, two-screen devices?
While there will be differences between the Surface devices and what's currently on the market, there are lessons that can be learned from the similarities or otherwise.

How might you need to think about redesigning different screens for larger sizes?
Do you need to think about dynamic layouts, different orientations, or assets of different sizes?
Will you need to make any changes to your existing logic regarding assumptions about devices based on screen sizes, the number of screens, or device input?

Have you thought about your expectations?
Document your expectations. Then you can act accordingly. Check how they reflect reality or need adjusting as more information comes out.

How are you planning for these new devices and being ready for them?
Set aside times and monitor timelines to learn about, research, and experiment with them. Think about how SDKs, tools, emulators, controls, design concepts, device specs, and announcements about distribution and availability.

Tuesday, January 21, 2020

What I learned about PowerApps at #MSIgniteTheTour (London)

Lots of people who self-identify as "developers" (rather than "IT Pros") attend Ignite The Tour, but the focus of the event is more on the world of the IT Pro.

I see myself as a developer more than an IT Pro but attended anyway. With no sessions immediately applicable to my day-to-day work(?), I went to learn something new. Specifically, I wanted to learn about PowerApps.

(Yes, my recent post about Citizen Development is related to this.)

The existing knowledge I took with me was this:
  • I've used and evaluated many "no-code" tools over my career and am familiar with the concept and some common issues.
  • I was excited by the idea of PowerApps when it was announced (several years ago) but never find the time to learn more.
  • Apart from watching a few introductory sessions from an online PowerApps conference a few years ago, that reinforced some of my concerns.

I approached this as a complete beginner with a vague understanding of what it is and a healthy skepticism.

Here, in no particular order, is what I've learned.

  • It's not just one thing. PowerApps is part of the "Power Platform." Power Automate (recently renamed from Flow) is closely connected with PowerApps, and it's common to use both. There's also Power BI as part of the power family and is for analytics and data visualization.
  • If you talk to people focused on Power Platform, they'll say it has a lot in common with Dynamics. The "Dynamics people" I spoke to said they're very different.
  • All data access is through the Common Data Service. The CDS is a gateway to all information inside an enterprise (and is also used by the Dynamic family), plus it has connectors to other data sources and actions.
  • They're all very focused on the enterprise.
  • There are three types of Power App: Model-Driven, Canvas, and Portals.
  • Model-Driven apps are suitable for admin tasks and make elementary forms over data solutions possible.
  • Canvas apps (so-called as you start with a "blank canvas") let you do anything(?) and are what you build for distribution to people within your organization.
  • Portal apps are what you make for people outside your organization. Useful for simple websites or kiosk-style displays within company premises.
  • All types of PowerApp can run in a browser or a host app.
  • There's a new thing called AI builder. It's a simple way to introduce AI (based on simple ML models) into Power Apps (and automations.)
  • The knowledge needed to build custom apps is apparently equivalent to that required to create Excel macros.
  • There are a lot of built-in functions available in Power Apps. Apparently, 50% of them are from Excel, and the other 50% "are things you'll never need." - I'm very suspicious of this claim.
  • The cost of licensing of PowerApps is something over which lots of people have concerns (complaints?). I haven't looked at this yet, but it's something to be aware of.
  • Custom components can be created in Visual Studio Code with the PowerApps Component Framework.
  • Other developer-related tools are CLI based.
  • Authorization and governance to create, distribute, and use PowerApps are built into the platform. 
  • As I expected, apparently, "it's very easy to write a bad canvas app."
  • The accessibility of created PowerApps isn't always great but something that is being worked on.
  • There is some level of app diagnostics built-in.
  • There is a custom framework for testing PowerApps, but it's relatively new.
  • There's a new "solution checker" coming soon that will highlight possible issues in an app.
  • There appears to be minimal support for common mobile scenarios like occasional connectivity.
  • The Common Data Service provides a way to centralize authentication, access management, and business logic. When someone from the audience asked how to take advantage of those things in an app built separately (i.e., not a Power App), the answer from the stage was to rewrite it as a PowerApp. That's the wrong answer. Wrong in that it's unacceptable. It doesn't appreciate the realities of many business and development environments.
  • I'm unconvinced it's as easy and straight forward to use as many people claim. Of the many demos I watched (given by Microsoft staff and industry experts--MVPs), even though they were doing simple tasks, they frequently chose the wrong options or switched to pre-prepared items to use as part of a solution.

This isn't the end.
I now know where to go to learn more and try it out for myself.
Apparently, anyone can try a demo version at https://powerapps.microsoft.com/, and there are excellent resources on Microsoft Learn.

When I find the time to go further, I'll share more of my experiences here.