Monday, October 09, 2017

The end of Windows Mobile/Phone just leaves more questions

With posts like this, it seems that Microsoft is starting to publicly acknowledge the end for Windows Phone/Mobile.

So should we just shut up and move on?
It's not that clear-cut. There are still some things to consider.

If you've built Phone/Win10Mobile apps that doesn't mean you should abandon them. If you still have users keep serving them while it makes sense to do so.

Windows isn't dead.
It's part of three areas that cover the broad spectrum of computing that Microsoft support.

There's Azure for Web/Cloud
There's Xamarin for X-Platform Mobile development
There's UWP for everything else (PC, Gaming, IOT, & more)


This still leaves lots of questions/thinking points.

Questions specific to the Windows app ecosystem

  • What, exactly, does "not the focus" mean?
  • Will anything be done to push the consumer focus of UWP apps?
  • Will the mobile version of Windows 10 ever go away?
  • What about small tablets? Will they ever be a thing? And, if so what version of Win10 would they run?
  • What about Windows on ARM?
  • Will we see greater investment and support for UWP and Xamarin? So there's a single solution for client apps on all platforms?

Broader questions

  • Is it good that there are only 2 mobile platforms (iOS & Android) out there?
  • Are there other mobile platforms that could make a challenge or drive innovation?
  • How important are devices other than the portable computers we carry in our pockets?
  • Will anything ever come of "continuum" style devices where a mobile can become a PC or it becomes your personal, portable storage, and identity?
  • Will people ever get over the silver bullet idea of "write once, run everywhere" (with no specialist knowledge or extra effort required)?
  • When will offline web support be good enough we can all just use the web all the time?
  • How will Microsoft's push for AR/VR/MR with dedicated devices sit with so many other platforms building solutions on top of mobile?
  • Does any of this really matter?


One of the joys of technology is that there are always more questions.....

Thursday, October 05, 2017

Optimizing the comparison of a variable with multiple options in C#


Yesterday, I wrote about my thoughts around optimising the comparison of a variable with multiple options and how I prefer to optimize for readability over theoretical or potential performance issues.
After some discussion on twitter about how my sample code might be optimized I thought it was worth doing some proper analysis.

The big potential optimizations are

  • The removal of LINQ
  • Not creating a new array for each check
  • Removing the need for boxing

Using BenchmarkDotNet I was able to quickly run some comparisons to see which method would be the quickest. I tried a number of variations with the type of object and array creation.

The results.

                               Method |        Mean |     Error |    StdDev |
------------------------------------- |------------:|----------:|----------:|
                       MultipleEquals |   0.0013 ns | 0.0041 ns | 0.0034 ns |
                        IsOneOfObject | 132.7228 ns | 2.2074 ns | 2.0648 ns |
       IsOneOfObjectWithExistingArray |  93.5959 ns | 1.7975 ns | 1.8459 ns |
                       IsOneOfGeneric |  63.4804 ns | 0.8762 ns | 0.7317 ns |
      IsOneOfGenericWithExistingArray |  58.5615 ns | 0.8739 ns | 0.7747 ns |
                        IsOneOfMyEnum |  64.2691 ns | 1.3435 ns | 1.3195 ns |
       IsOneOfMyEnumWithExistingArray |  58.2238 ns | 0.9457 ns | 0.8383 ns |
                  IsOneOfMyEnumNoLinq |  12.1887 ns | 0.2395 ns | 0.2123 ns |
 IsOneOfMyEnumNoLinqWithExistingArray |   6.2302 ns | 0.0519 ns | 0.0433 ns |

Full benchmark code is at https://gist.github.com/mrlacey/1b3eef0a9945b67883486bb9540b533d

While using multiple equality checks was by far the fastest approach, by removing LINQ, not boxing, and not creating a new array for each test I was able to achieve the best performance.


Conclusion
While using multiple equality checks is by far the fastest, I still think writing
if (MyEnum.Value1 || someVariable == MyEnum.Value2 || someVariable == MyEnum.Value3 || someVariable == MyEnum.Value6)
{
    /// do something
}
is far less preferable to
if (someVariable.IsOneOf[MyEnumNoLinq](targetValues))
{
    /// do something
}

And the code can still be pretty darn fast.
You just might need a few overloads to get the best performance from all comparisons.

Disclaimer.
Yes, I am aware that:

  • I only ran the tests with enums and you might get different results with different types.
  • It might not be possible to have a fixed array to compare with each time.
  • There may be further optimizations available. This is good enough for me though.
  • Based on the speeds involved this does feel like a micro-optimization unless you really are making such calls many, many times in quick succession.
  • I haven't looked at memory usage. If you're interested, go ahead, but standard warnings about premature micro-optimizations exist.

*** UPDATE ***

Ok, I gave in and looked at the memory profiling too:

                               Method |  Gen 0 | Allocated |
------------------------------------- |-------:|----------:|
                       MultipleEquals |      - |       0 B |
                        IsOneOfObject | 0.0558 |      88 B |
       IsOneOfObjectWithExistingArray | 0.0178 |      28 B |
                       IsOneOfGeneric | 0.0178 |      28 B |
      IsOneOfGenericWithExistingArray |      - |       0 B |
                        IsOneOfMyEnum | 0.0178 |      28 B |
       IsOneOfMyEnumWithExistingArray |      - |       0 B |
                  IsOneOfMyEnumNoLinq | 0.0178 |      28 B |
 IsOneOfMyEnumNoLinqWithExistingArray |      - |       0 B |


Yeah, I think it's safe to say that it's not an issue. If you're really concerned over 28 (or even 88) bytes you're in a really constrained environment and nothing I have to say about optimization or readability will be relevant or new to you. In fact, if you're in such a constrained environment you're probably best not writing in a managed language.


Wednesday, October 04, 2017

Comparing a variable with multiple options in C#

In a code review recently there was some debate about how to compare a variable with multiple values.
I'm writing this to put all my thoughts on the subject into one place and in a coherent (hopefully) manner.

As an example, consider this `if` statement.

if (new[] { MyEnum.Value1, MyEnum.Value2 }.Contains(someVariable))

It's the equivalent of "if (X or Y) = Z".

Also, consider this variation

if (someVariable == MyEnum.Value1 || someVariable == MyEnum.Value2)

The repetition of the variable typically makes it longer than the version using the array and reads, IMO, less naturally. It's the equivalent of "if (X = Y) or (X = Z)".

People tend to prefer the second option.

The argument against the first option basically comes down to:
I know an array of 2 doesn't add too much memory but it's just good practice.
I'm not convinced about the "good practice" argument.

  • Yes, an array is created, but it's tiny and there's nothing keeping it around and so can be collected as soon as is necessary.
  • It's not "common practice" I'll admit, but I've never seen code guidelines that explicitly say anything about how to do multiple comparisons. Is the first option considered wrong as it's not seen as frequently as the second?
  • It feels like a premature optimization. The argument of don't create anything that uses memory unless you need to puts preserving memory consumption above all else. I don't think that's right or something that anyone making the above argument sticks too rigidly.
If someone was really concerned about performance, I'd expect them to point out that the array method can cause boxing and this is likely to have more impact on performance than array creation. For a one-off check though the impact is still so small as to not be noticeable. This makes me think the above argument comes from a convention and perception that "creating arrays is bad" and should be avoided.


I also prefer the first option as it makes it easier to add another option. The adding of an item to a list is simpler than another comparison. As the variable needs to be compared with more options lines get very long if using direct comparisons.  Both options get longer but this gets much longer faster.
This isn't great.

if (someVariable == MyEnum.Value1 || someVariable == MyEnum.Value2 || someVariable == MyEnum.Value3 || someVariable == MyEnum.Value4 || someVariable == MyEnum.Value5)

I prefer a solution that uses an array rather than multiple explicit comparisons because I follow this maxim in my code:

Readability of code is more important than performance unless performance is an issue.

IMO, reading multiple comparison statements is harder.

In my own code, I don't actually do the above. I wrap it in a call to an extension method so it's even shorter and, IMO, reads even more naturally,

if (someVariable.IsOneOf(MyEnum.Value1MyEnum.Value2))

This reads like "if X = (Y or Z)" which is closest to spoken English.
It's also easy to add options to.


The extension method, if you're interested, is really simple.

public static bool IsOneOf(this object item, params object[] options)
{
    return options.Contains(item);
}


Some potential questions.

What if calling this type of code enough times that there is a performance impact?
- Then do what's necessary to improve performance. That's what the clause in my maxim is for.

What about not using an if statement?
- It might be more appropriate to use a `select` statement. However, if the `if` statement doesn't have an `else` clause then this leads to a `select` statement with only a single match which feels odd to me. (As above though, this may be just because I'm not used to seeing code like that.)

What about starting with direct comparisons if there are only two options and then switch to the "IsOneOf" methods when multiple comparisons are made?
- You could go that way but I'm not a fan as it becomes hard to enforce a consistent style across a codebase. It also means that the change to add functionality unnecessarily requires changing the structure of code which can make it harder to identify the meaningful differences in the change.


Thoughts?


follow up post on optimizations for the above.


Tuesday, May 30, 2017

What is a "bug bash"?

Disclaimer: I'm thinking this through as much as anything. Don't expect any amazing conclusions but I'd be interested to hear your thoughts and opinions on this.
Microsoft uses the term "bug bash" (example - but I first heard them use this a few years ago) to mean to hunt for bugs. Everyone stops what they're doing to try and find bugs for a period of time. The aim is to find as many bugs as possible.
At every company I've known use the term previously, the term meant something different. I'd always heard it used to describe a period of time set aside to try and fix bugs. Any bugs. The aim was to reduce the number of known bugs.

Bash the product until the bugs fall out. - vs - Bash the actual bugs.

As I start to write this I realize I haven't asked the internet about this. It seems Wikipedia sides with Microsoft in the definition.

I prefer the other meaning more.

I get it. Hunting for bugs is good. It's also really hard to fix bugs that haven't been found.
But there are problems with how I've seen the Microsoft approach used in practice.

  • It can only really happen late in the development process. When it happens earlier there are issues with separating actual bugs from things that are missing or known to not be finished yet.
  • It doesn't guarantee coverage of the app/software. Just because you have lots of different people using/testing the app at once doesn't mean they'll use all of it. In bug-bashes I've seen before they tend to generate a disproportionately large number of bugs in a small number of areas.
  • It can be seen as an excuse for no, or minimal, beta testing. Also, note that beta testing should be monitored with usage analytics to ensure appropriate coverage.
  • They can easily value quantity over quality. When the aim is on finding bugs in a restricted period of time the amount of effort put into writing a good bug report is often reduced.
  • The quality of bug reports often isn't as high from a random person on the team when compared with a professional tester. Poor quality bugs cost more to verify, investigate, and fix, so it's worth the time and effort to get a good bug report.
  • Even professional testers slip into bad habits and raise low-quality bugs.
  • It ignores automated testing.
  • The details of what's tested aren't correlated with any test plans. This means that in addition to the uncertainty of code coverage (as above) no details of things that are tested as part of the "bash" are recorded. This means that gaps in test plans aren't identified or filled unless a bug happens to be reported for that area.

Why bashing actual bugs is better.

  • Getting overall bug counts down is good. It enables you to "see the wood for the trees". With fewer known bugs you can prioritize better and work on new features. You also avoid duplicate bugs.
  • Bugs get fixed sooner. And fixing bugs sooner is cheaper.
  • It is an easy way to give the impression and feeling of progress. While trivial bugs may be fixed, having the number of outstanding bugs go down can be good for morale.
  • They encourage actually fixing bugs. It can be tempting for many teams to consider known bugs to be of lower priority than new work. Fixing known bugs before adding or changing features stops this and avoids a system full of known bugs.
  • Gives autonomy to developers to chose what they work on and can even allow them to fix bugs in their favorite parts of the code or pet feature. A culture where the fixing of bugs is encouraged leads to better software and happier developer teams.

I still like my approach better.

Is "bug bash" a term you use in your development/test process? How do you use it? What's good or bad about it?


Wednesday, April 26, 2017

3 reasons to use the MVVM pattern

MVVM (Model - View - ViewModel) is a separation pattern that was based on the MVP (Model - View - Presenter) pattern. It's very popular in XAML and some web development camps but is frequently abused.


As a separation pattern MVVM aims to provide 3 specific benefits:

#1 Collaborative working

By separating the visual part of the app (the user interface, or UI) from the related code it becomes possible to have specialists in each area work on related items at the same time. The theory is designers can work on the UI at the same time as developers are working on the code without needing to have them both work on the same files at the same time.
Unfortunately, very few people see this benefit as they don't work in teams or on projects where the are enough people with specific skills on the design and development sides that they can work on both simultaneously.

#2 Code reuse

Doing the same thing multiple times gets boring quickly.
Having the same code in more than one place creates a duplication of effort when the code if first created and adds extra effort to maintain the different copies of the same (or very similar) code.
As a separation pattern, one of the intentions is that it allows the different layers to be reused. The model layer is the most obvious candidate for use in multiple apps or versions of an app (i.e. for different platforms) but ViewModel should be able to be reused as well. If you're only building a single app for one platform you have an excuse for ignoring this but if your ViewModels could be being used on multiple platforms then they should be. The biggest barrier to being able to do this is having ViewModels that reference or are strongly tied to something in the View layer or the UI of a particular platform. The associated downside to this is that it also makes testing hard.

#3 Ease of testing

One of the long-time criticism of apps with graphical UIs is that they are hard to test. A separation pattern, like MVVM, should break the coupling between the application logic and the UI and so make testing more accessible. It shouldn't be necessary to do all testing via the UI and so tests become quicker and easier to set up and run. Sadly, many developers using the MVVM pattern still aren't getting the benefits that come from automated testing. Or, they're still creating links between the layers of the app that make automated testing much harder than it need be.



It is disappointingly common that I see apps and developers who are not getting any of the benefits mentioned above. Such developers are still enthusiastic about the pattern and encourage others to use it because of secret bonus reasons numbers four and five.

bonus #4 Bindings make UI updates easier to handle

Bindings simplify many of the challenges of manipulating data, capturing entered data, and monitoring changes. While definitely useful, this shouldn't be the only benefit you get from the MVVM pattern.

bonus #5 Ease of maintainability

By having a separation between the different parts of an app's code it brings a level of structure and uniformity to the code. It's easy to see where things should go or where they're likely to be. It also encourages the use of other patterns (dependency inversion, services, messaging, etc.) and so brings the benefits of good development practices. These aren't unique to the MVVM pattern. The benefits come with almost any architectural pattern that is followed and applied to a codebase.


Just because your code has some classes with the suffix ViewModel that you bind to your views doesn't mean that you are getting the full benefit the MVVM pattern could be providing.
This may or may not be an issue but I can almost guarantee that your codebase would be better served by having more tests. ;)

Do you use the MVVM pattern? What benefits do you get from it?