Igor Popov

Asynchronous Programming in C#

2018-06-30T00:00:00+00:00

Asynchronous programming causes a lot of confusion because the documentation is a bit lacking and this results in awfully bad implementations. This post compiles my research on this subject so you’ll see lots of quotes from various sources (official and trusted third parties).

WTF is asynchronous programming?

To clear up the confusion we’re going to see what all the fancy words below actually mean:

synchronous
asynchronous
multithreading
concurrency
parallelism

Synchronous vs Asynchronous

When you execute something synchronously, you wait for it to finish before moving on to another task. When you execute something asynchronously, you can move on to another task before it finishes.

source: Stackoverflow

Multithreading

Multithreading is the ability of a central processing unit (CPU) or a single core in a multi-core processor to execute multiple processes or threads concurrently, appropriately supported by the operating system.

source: Wikipedia

Concurrency vs Parallelism

Concurrency is when two or more tasks can start, run, and complete in overlapping time periods. It doesn’t necessarily mean they’ll ever both be running at the same instant. For example, multitasking on a single-core machine.

Parallelism is when tasks literally run at the same time, e.g., on a multicore processor.

source: Stackoverflow

When to use synchronous/asynchronous?

This post is about asynchronous programming in C# with the Task-based Asynchronous Pattern, so let’s see when and how to use it. There are 2 types of operations that have to be considered: CPU bound and I/O bound when deciding what to use. Here’s what Stephen Toub has to say about this:

Both compute-bound and I/O-bound asynchronous operations may be implemented as TAP methods. However, when exposed publicly from a library, TAP implementations should only be provided for workloads that involve I/O-bound operations (they may also involve computation, but should not be purely computation). If a method is purely compute-bound, it should be exposed only as a synchronous implementation; a consumer may then choose whether to wrap an invocation of that synchronous method into a Task for their own purposes of offloading the work to another thread and/or to achieve parallelism.

At the API level, the way to achieve waiting without blocking is to provide callbacks. For Tasks, this is achieved through methods like ContinueWith. Language-based asynchrony support hides callbacks by allowing asynchronous operations to be awaited within normal control flow, with compiler-generated code targeting this same API-level support.

source: the TAP.docx document (check in the resources below)

The essential information is this:

I/O-bound operations? - then await asynchronous I/O methods provided by the .NET framework
CPU bound operations? - then expose it as a synchronous/plain implementation, the caller/user of the operation will wrap it in a Task.Run if needed

What is CPU bound?

Sometimes concepts are difficult to follow without proper examples. CPU bound or compute bound means that you have a problem to solve/calculate and you actively need to use the processor to perform the calculation. One such example (maybe not the best one, but it illustrates my point exactly) would be calculating the sine of an angle. This is pointless (we’re not even storing the result), but is a great example of a CPU bound operation:

for (int i = 0; i < 99999999; i++) Math.Sin(i);

What is I/O bound?

I/O bound means that you request the disk to save or load some information for example. Another example would be requesting to download a file from an HTTP server like below:

new WebClient().DownloadFileTaskAsync(Url, i + File);

Downloading is a network operation which requires opening a TCP connection to a server and receiving data through multiple network devices (ex. routers) - this operation takes time. One (wrong) way of doing it is to offload the work to a separate thread, but then this thread will get execution time from the CPU for doing nothing else then waiting for the server to send back a response.

The right way to do the download would be to use the async methods provided by .NET. These are actually wrappers for native code that actually do the work in an async way, meaning sending the request to the server and then suspending the thread until it gets the response back.

More details about CPU bound and I/O bound

More importantly, because I/O-bound work spends virtually no time on the CPU, dedicating an entire CPU thread to perform barely any useful work would be a poor use of resources.

The call to GetStringAsync() calls through lower-level .NET libraries (perhaps calling other async methods) until it reaches a P/Invoke interop call into a native networking library. The native library may subsequently call into a System API call (such as write() to a socket on Linux). A task object will be created at the native/managed boundary, possibly using TaskCompletionSource. The task object will be passed up through the layers, possibly operated on or directly returned, eventually returned to the initial caller.

source: MSDN: Async in Depth

A program is CPU bound if it would go faster if the CPU were faster, i.e. it spends the majority of its time simply using the CPU (doing calculations). A program that computes new digits of π will typically be CPU-bound, it’s just crunching numbers.

A program is I/O bound if it would go faster if the I/O subsystem was faster. Which exact I/O system is meant can vary; I typically associate it with disk. A program that looks through a huge file for some data will often be I/O bound, since the bottleneck is then the reading of the data from disk.

source: Stackoverflow

Examples and comparison

Now we’re going to compare performance and resource usage for I/O and CPU bound operations. For this we’ll use the Parallel Stacks and Tasks windows from Visual Studio -> Debug -> Windows -> Parallel Stacks and Tasks. These windows show something only when the application is in debug mode and in Break All state.

For more info on how to use the Parallel Stacks feature please check the Official MSDN Walkthrough: Debugging a Parallel Application in Visual Studio.

NOTE: all the examples below are done on a single machine and in the same conditions. If you do them you’ll get different numbers but you should have the same relative performance and resource usage.

The bad use of `async` I/O

The implementation below is stupid! NEVER DO THIS!!! I did it just to show you what actually happens when you do it and to demonstrate that it’s an extremely bad way of achieving what you want.

const string Url = "https://apod.nasa.gov/apod/image/1806/IMG_5938Mauduit_2048.jpg";
const string File = "file.jpg";

private Task IoBoundOperationBadAsync(int i)
{
    return Task.Run(() =>
    {
        new WebClient().DownloadFile(Url, i + File);
    });
}

private async void Button_Click(object sender, RoutedEventArgs e)
{
    button.IsEnabled = false;

    var tasks = new List<Task>();
    for (int i = 0; i < 10; i++)
        tasks.Add(IoBoundOperationBadAsync(i)); // 29 seconds, 10 worker threads

    var watch = Stopwatch.StartNew();

    await Task.WhenAll(tasks);

    watch.Stop();
    var elapsedMs = watch.ElapsedMilliseconds;

    button.IsEnabled = true;
    MessageBox.Show(this,
        $"Async task completed in {elapsedMs / 1000} seconds!",
        "Information",
        MessageBoxButton.OK,
        MessageBoxImage.Information);
}

In this case the download takes 29 seconds and uses 10 worker threads (and 14 threads in total). You can verify this by running the app, pressing the button and then Break All from Visual Studio to get the status in Parallel Stacks window.

The good use of `async` I/O

const string Url = "https://apod.nasa.gov/apod/image/1806/IMG_5938Mauduit_2048.jpg";
const string File = "file.jpg";

private Task IoBoundOperationGoodAsync(int i)
{
    return new WebClient().DownloadFileTaskAsync(Url, i + File);
}

private async void Button_Click(object sender, RoutedEventArgs e)
{
    // code you already saw in the previous example

    for (int i = 0; i < 10; i++)
        tasks.Add(IoBoundOperationGoodAsync(i)); // 24 seconds, 0 worker threads

    // code you already saw in the previous example
}

In this example I used the special async method from WebClient that downloads a file in an async way. It took only 24 seconds and used no worker threads. The 4 threads you see in the screenshot below are from the thread pool that’s created for all apps anyway.

Compared to the previous example (for the bad I/O) this one was not only faster, but also didn’t use any worker threads! By using less, we achieved more!

The good use of `async` CPU

private Task CpuBoundOperationGoodAsync()
{
    return Task.Run(() =>
    {
        for (int i = 0; i < 99999999; i++) Math.Sin(i);
    });
}

private async void Button_Click(object sender, RoutedEventArgs e)
{
    // code you already saw in the previous example

    for (int i = 0; i < 10; i++)
        tasks.Add(CpuBoundOperationGoodAsync()); // 12 seconds, 8 worker threads

    // code you already saw in the previous example
}

In this case the operation took 12 seconds and 8 worker threads - you may wonder why not 10 (since we used Task.Run in a loop of 10 iterations)? The answer is simple Task.Run only queues the given work on the thread pool which automatically adjusts the number of threads it uses - that means it doesn’t start a new thread every time you call Task.Run.

This is a good example of when to use Task.Run for CPU bound code. A really bad way of doing this would be to have Task.Run inside the Math.Sin implementation (not that you can control that, it’s just an example: it could be in a CPU bound method that you could write): always leave calls to Task.Run at the highest level possible - definitely not in library methods (or any lower level APIs for that matter).

If you’d like to read more about when to use Task.Run please check out this blog post from Stephen Cleary: Task.Run Etiquette and Proper Usage.

How do I made an async method? And how do I use async/await?

Put simply, you start by writing the normal synchronous method and then check what methods can be called asynchronously.

Basically follow these steps:

write the normal synchronous method
check if the I/O methods that you call from .NET API have an equivalent method whose name ends with Async and returns a Task
await those method calls
propagate await and async keywords up the call stack

.NET types with async methods

These types have async methods that you can use for true asynchronous/non-blocking I/O with the web/filesystem:

Web access: HttpClient
Filesystem access: StreamWriter, StreamReader, XmlReader

Recommendations from Lucian Wischik

There’s a great presentation given by this guy (check out the resources section) that you should watch. I extracted the tips that I find absolutely essential:

Tips summarized

The app is in the best position to manage its threads
Provide synchronous methods that block the current thread
Provide asynchronous methods when you can do so without spawning new threads
Let the app that called you use its domain knowledge to manage its threading strategy!

Source Code

The full source code is available on GitHub. You can clone the repo and try it locally.

Resources

These resources are official, which means that they are either written by Microsoft or recommended/recognized by them.

Lucian Wischik is a Senior Program Manager for Managed Languages at Microsoft. He made several presentations at conferences that explain in depth what to do in various scenarios related to asynchronous programming:

Stephen Toub is a Microsoft Employee. He’s the guy that wrote the detailed Task-based Asynchronous Pattern Document.

Stephen Cleary is a Microsoft MVP.

Asynchronous programming in C# with WPF

2018-06-16T00:00:00+00:00

I know nothing about the Task Parallel Library and writing a blog post about this is a great opportunity to learn about it. This post won’t be exhaustive: I’ll just explore Microsoft’s recommended way of implementing asynchronous programming.

Way of working

I’m more focused now only on the specifics of asynchronous programming so I won’t write the app using best practices like MVVM. For that you should check my previous posts about it.

Starting out: the unresponsive app

The app is very simple: just 2 buttons - one for a long running task (which we are going to simulate using Thread.Sleep) and another, quicker one that just updates a counter. We’re going to see how different approaches work.

The first approach is the dumb implementation which makes the app unresponsive while the long task executes. We’re doing this just so we have something to compare to.

Here’s the source code for the long task button click. As you can see, we’re just simulating that it takes long with Thread.Sleep and then updating the interface to signal that we’re done.

private void LongTaskButton_Click(object sender, RoutedEventArgs e)
{
    Thread.Sleep(2000);
    LongTaskTextBlock.Text = "Completed long task";
}

And here’s how the application looks like. While the task is executing in background the interface freezes and you can’t do anything else (like clicking the other button).

Introducing the Task Parallel Library

Now let’s use the Task Parallel Library to put the long running task in a background thread and also make a few improvements to the user experience like disabling the button while the task executes and finally updating the interface when the task completes.

private void LongTaskButton_Click(object sender, RoutedEventArgs e)
{
    LongTaskButton.IsEnabled = false;
    LongTaskTextBlock.Text = "Starting long task";

    var task = Task.Run(() =>
    {
        Thread.Sleep(2000);
    });

    task.ContinueWith((t) =>
    {
        Dispatcher.Invoke(() =>
        {
            LongTaskButton.IsEnabled = true;
            LongTaskTextBlock.Text = "Completed long task";
        });
    });
}

The Task.Run will queue the operation to run on the thread pool and will return a Task object. In order to update the interface when the task is complete we’re using Task.ContinueWith. An important thing to notice here is the use of a Dispatcher. WPF requires all interface updates to be done from a single thread: the UI thread, which queues work items inside an object called a Dispatcher.

If you try to update the interface from a different thread then the UI thread you will get an System.InvalidOperationException: The calling thread cannot access this object because a different thread owns it.

Here’s how the application works now:

As you can notice, the app no longer freezes after the long task starts: we can still click on the second button to increase the count.

In case the task fails, we have to check if the task IsFaulted and if so, then show a message to the user:

private void LongTaskButton_Click(object sender, RoutedEventArgs e)
{
    LongTaskButton.IsEnabled = false;
    LongTaskTextBlock.Text = "Starting long task";

    var task = Task.Run(() =>
    {
        throw new Exception("Something crashed!");
    });

    task.ContinueWith((t) =>
    {
        Dispatcher.Invoke(() =>
        {
            LongTaskButton.IsEnabled = true;
            LongTaskTextBlock.Text = t.IsFaulted ?
                t.Exception.InnerException.Message :
                "Completed long task";
        });
    });
}

You can also return a status result from the task which you can later access in ContinueWith by checking the task Result property:

private void LongTaskButton_Click(object sender, RoutedEventArgs e)
{
    LongTaskButton.IsEnabled = false;
    LongTaskTextBlock.Text = "Starting long task";

    var task = Task.Run(() =>
    {
        Thread.Sleep(2000);
        return "Completed long task";
    });

    task.ContinueWith((t) =>
    {
        Dispatcher.Invoke(() =>
        {
            LongTaskButton.IsEnabled = true;
            LongTaskTextBlock.Text = t.IsFaulted ?
                t.Exception.InnerException.Message :
                t.Result;
        });
    });
}

Handling exceptions in tasks

Here’s what Microsoft has to say about handling exceptions in tasks:

When a task throws one or more exceptions, the exceptions are wrapped in an AggregateException exception. That exception is propagated back to the thread that joins with the task, which is typically the thread that is waiting for the task to finish or the thread that accesses the Result property. This behavior serves to enforce the .NET Framework policy that all unhandled exceptions by default should terminate the process. The calling code can handle the exceptions by using any of the following in a try/catch block:

The Wait method

The WaitAll method

The WaitAny method

The Result property

async and await

These keywords simplify work with Task Parallel Library since you no longer need to use explicit continuations. You simply need to await a long running task and the current thread will be suspended until that task completes. Everything after await will be executed when the task completes so we no longer need to call ContinueWith on the returned task.

private async void LongTaskButton_Click(object sender, RoutedEventArgs e)
{
    LongTaskButton.IsEnabled = false;
    LongTaskTextBlock.Text = "Starting long task";

    var result = await Task.Run(() =>
    {
        Thread.Sleep(2000);
        return "Completed long task";
    });

    LongTaskButton.IsEnabled = true;
    LongTaskTextBlock.Text = result;
}

And here’s how we handle exceptions in this case:

private async void LongTaskButton_Click(object sender, RoutedEventArgs e)
{
    LongTaskButton.IsEnabled = false;
    LongTaskTextBlock.Text = "Starting long task";

    string result = "";
    try
    {
        result = await Task.Run(() =>
        {
            Thread.Sleep(2000);
            throw new Exception("Something crashed!");
            return "Completed long task";
        });
    }
    catch (Exception ex)
    {
        result = ex.Message;
    }

    LongTaskButton.IsEnabled = true;
    LongTaskTextBlock.Text = result;
}

Awaiting on multiple tasks

Besides declaring each task, you need to call Tasks.WhenAll with all the tasks you want to await upon:

private async void LongTaskButton_Click(object sender, RoutedEventArgs e)
{
    LongTaskButton.IsEnabled = false;
    LongTaskTextBlock.Text = "Starting long tasks";

    var firstLongTask = Task.Run(() =>
    {
        Thread.Sleep(1000);
        return "first";
    });

    var secondLongTask = Task.Run(() =>
    {
        Thread.Sleep(2000);
        return "second";
    });

    var thirdLongTask = Task.Run(() =>
    {
        Thread.Sleep(500);
        return "third";
    });

    var results = await Task.WhenAll(firstLongTask, secondLongTask, thirdLongTask);

    LongTaskButton.IsEnabled = true;
    LongTaskTextBlock.Text = "Completed " + string.Join(", ", results) + " tasks";
}

Source Code

The full source code is available on GitHub. You can clone the repo and try it locally. Just a note though: the examples are available all in the same file, but in different commits - you need to check the git log.

Resources

Executing the right project in Visual Studio

2018-06-13T00:00:00+00:00

Often, when you’re working you want to quickly open a file, edit that and run it so you can test it. What happens when you press F5 in Visual Studio is that it will start some other project (when you have a solution with more than 1 project). In this post you’ll learn a simple trick that allows you to start the project where the file you just edited is.

The trick

You just need to go to the solution settings and choose Current selection as the Startup Project like so:

Once you do that, every time you select a file, the project in which that file resides will become active so that when you press F5 to run it will start that specific project. Notice how when you select a different file, the project name becomes bolded in the Solution Explorer.

Hopefully, this trick will help you at least in some cases. Of course, it won’t every time (in library projects for example).

C# Reflection API

2018-06-02T00:00:00+00:00

In this post we’re going to see how to dynamically get the value of a property by using only its name. This started from me trying to understand how data binding works in XAML and implementing it myself. For this, I needed a view model which implements the INotifyPropertyChanged and then subscribe to its PropertyChanged event.

The view model

using System.ComponentModel;

namespace CSharpEventsReflectionAndDataBinding {
    public class Robot : INotifyPropertyChanged {
        public string FirstName { get; set; }
        public string LastName { get; set; }

        private int years;
        public int Years {
            get { return years; }
            set {
                years = value;
                OnPropertyChanged("Years");
            }
        }

        public override string ToString() => $"{FirstName} {LastName}";

        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged(string propertyName) {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}

The main program

Just for fun I used R. Daneel Olivaw as an example…

using System;
using System.Timers;

namespace CSharpEventsReflectionAndDataBinding {
    public class Program {
        static void Main(string[] mainArgs) {
            new Program().Run();
            Console.Read();
        }

        private void Run() {
            var rDaneelOlivaw = new Robot {
                FirstName = "Daneel",
                LastName = "Olivaw",
                Years = 19200,
            };

            PrintYearsWhenItIsChanged(robot: rDaneelOlivaw);
            CreateTimerToIncreaseYears(seconds: 3, robot: rDaneelOlivaw).Start();
        }

        private void PrintYearsWhenItIsChanged(Robot robot) {
            robot.PropertyChanged += (sender, args) => {
                var propertyName = args.PropertyName;
                var propertyValue = typeof(Robot)
                    .GetProperty(propertyName)
                    .GetValue(robot);

                Console.WriteLine($"{robot} now has {propertyValue} {propertyName}");
            };
        }

        private Timer CreateTimerToIncreaseYears(int seconds, Robot robot) {
            var timer = new Timer(seconds * 1000) { AutoReset = true };
            timer.Elapsed += (sender, args) => { robot.Years++; };
            return timer;
        }
    }
}

Explanation

To get the property value we first need to know on what Type it resides, then the property name and finally the target object.

var propertyValue = typeof(Robot)
    .GetProperty(propertyName)
    .GetValue(robot);

This is a simple concept and in case I ever need it I know where to look for a quick refresher.

StringFormat in XAML

2018-05-26T00:00:00+00:00

In an usual application sometimes you need to “adapt” the values from the view model. This is normally done using StringFormat, but we’ll see some other options as well.

Simple StringFormat with binding escape

Let’s say that you need to display a temperature in degrees. In the view model you have just the numerical value and in the interface you want to append the °C string to make it clear what type of degrees are displayed. Here’s how that’s done:

<TextBlock Text="{Binding CelsiusTemp, StringFormat={}{0}°C}" />

MultiBinding

The zero from XAML binding is actually the first binding. In the next example Name is the {0} part and ID is the {1} part:

<TextBlock>
    <TextBlock.Text>
        <MultiBinding StringFormat="{}{0} + {1}">
            <Binding Path="Name" />
            <Binding Path="ID" />
        </MultiBinding>
    </TextBlock.Text>
</TextBlock>

There are however some other ways you can concatenate string values in XAML. Let’s review them quickly:

TextBlock with Run text
Using StackPanel to group
Using Converters

TextBlock with Run text

TextBlock supports an inner element called Run which can be helpful when you want to concatenate more things.

<TextBlock>
  <Run Text="Temperature is " />
  <Run Text="{Binding CelsiusTemp}" />
  <Run Text="°C" />
</TextBlock>

Using StackPanel to group

In this case you can just dump everything in a StackPanel having the Orientation set to Horizontal.

<StackPanel Orientation="Horizontal">
    <TextBlock Text="Temperature is "/>
    <TextBlock Text="{Binding CelsiusTemp}"/>
    <TextBlock Text="°C"/>
</StackPanel>

Using Converter

And the last example, although I wouldn’t really use it in this case (but shown nonetheless just for completeness sake):

public class TemperatureConverter : IValueConverter {
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture) {
        return $"Temperature is {value} °C";
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) {
        throw new NotImplementedException();
    }
}

And here’s how to use it in XAML:

<Grid>
    <Grid.Resources>
        <local:TemperatureConverter x:Key="temperatureConverter"/>
    </Grid.Resources>
    <TextBlock Text="{Binding CelsiusTemp, Converter={StaticResource temperatureConverter}}"/>
</Grid>

Most common formatting specifiers

Formatting numbers using 2 decimal points is done using F2 - F means floating point and the following digit is the number of decimal digits. In this case I used 2, but it can be any value. If you want to show only the integral part then use F0.

If you also want to display the thousands separator you can use N2.

<!-- Consider CelsiusTemp = 1234.5678 -->
<!-- Also take note that the values will be rounded! -->

<!-- This will be: 1234.57 -->
<TextBlock Text="{Binding CelsiusTemp, StringFormat={}{0:F2}}"/>

<!-- This will be: 1235 -->
<TextBlock Text="{Binding CelsiusTemp, StringFormat={}{0:F0}}"/>

<!-- This will be: 1,234.57 -->
<TextBlock Text="{Binding CelsiusTemp, StringFormat={}{0:N2}}"/>

<!-- This will be: 1,235 -->
<TextBlock Text="{Binding CelsiusTemp, StringFormat={}{0:N0}}"/>

Here are some more examples showing how to display currency and dates:

<Window x:Class="PlayingWithXAML.MainWindow"
        x:Name="wnd"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:system="clr-namespace:System;assembly=mscorlib"
        Width="300"
        Height="200">
    <StackPanel Margin="10">
        <TextBlock Text="{Binding ElementName=wnd, Path=ActualWidth, StringFormat=Window width: {0:#,#.0}}" />
        <TextBlock Text="{Binding ElementName=wnd, Path=ActualHeight, StringFormat=Window height: {0:C}}" />
        <TextBlock Text="{Binding Source={x:Static system:DateTime.Now}, StringFormat=Date: {0:dddd, MMMM dd}}" />
        <TextBlock Text="{Binding Source={x:Static system:DateTime.Now}, StringFormat=Time: {0:HH:mm}}" />
    </StackPanel>
</Window>

Resources

Visual Studio Productivity Tips & Tricks

2018-05-13T00:00:00+00:00

You can boost your Visual Studio productivity if you know these little tips and tricks. We’ll go through some of the most useful code snippets, keyboard shortcuts and extensions.

Code snippets

Code snippets are a way to write frequent code faster. This is achieved by typing a mnemonic followed by TAB TAB in order for it to be replaced with the final code.

1. `svm` - `static void main`

When you start a new project you obviously want to write the main method first. In order to do so faster you can use the svm snippet. After you write svm press TAB TAB and the snippet will be replaced with the main method:

2. `cw` - `Console.WriteLine`

Normally you would be making GUI programs so why should you care about being able to write to the command line faster?!

Well, if you’re like me, when you encounter a problem that it’s more difficult you want to simplify it as much as possible. One way of doing this is to create a separate command line project to isolate the problem to the most essential parts. In that case, if you want to quickly display a message you can use the cw snippet (as before - followed by TAB TAB):

3. `mbox` - `MessageBox.Show`

In the same style as the previous snippet, this one helps us when we want to show a quick message to the user. Normally the MessageBox is a bit old and not so user friendly, but it works quite well when debugging.

One quick note, though, if you’re using Windows Forms then you can leave the namespace untouched, but if you’re using WPF you have 2 options: either add the System.Windows.Forms reference or just delete the Forms part from the inserted line. I prefer the second options (also demoed below) because you keep using WPF without needing to depend also on Windows Forms:

4. `prop` & `propfull` - C# Properties

Another thing that’s quite often and useful is adding C# properties quickly. After the snippet is inserted, you can continue pressing TAB to cycle between the type and the name. If you need also the property backing field you should use propfull.

5. `propdp` & `propa` - Dependency Properties & Attached Properties

When creating a new user control you often need to write new dependency properties. Unfortunately, the syntax for doing so is quite complex and difficult to get right the first time. In the same style there’s also propa that inserts an attached property.

Keyboard shortcuts

Keyboard shortcuts are by far the quickest way to improve your productivity. In the next lines I’ll show the shortcuts that I consider critical.

The most potent shortcuts

quick fix: CTRL + .
search commands: CTRL + Q
search type: CTRL + T

navigate to definition: F12
find references: SHIFT + F12
navigate backward: CTRL + -
navigate foreward: CTRL + SHIFT + -

Code handling

format code: CTRL + K,D
comment code: CTRL + K,C
uncomment code: CTRL + K,U
move line up: ALT + ↑
move line down: ALT + ↓
rename: F2

Personal favorite: quick fix

The most amazing shortcut has to be the quick fix! If you have an error, a warning or a code suggestion you just have to press CTRL + . to get a list of quick fixes and choose the one you want. It’s the shortcut that can fix almost any problem.

In the example below I used programming by intention to first call the method I need and then using quick fix to add a placeholder for the method thus saving my time I would have spent writing it. I know, I know, it’s so small it doesn’t matter… but it adds up after a while.

Personal favorite: expand/contract selection

expand selection: ALT + SHIFT + =
contract selection: ALT + SHIFT + -

This shortcut is very useful when you want to refactor code. Let’s say that you want to extract a method for the conditional expression in an if statement. If you move your caret (using the keyboard) you could press ALT + SHIFT + = until you select the expression you want and then press CTRL + R,M to extract a method. Here’s how the selection works:

Just a quick warning though: this was added in Visual Studio 2017 15.5.2 so in previous versions you won’t be able to do this (although this functionality might be supported through an extension).

Extensions

Extensions are the last pillar - they offer stuff that’s not built-in Visual Studio. WARNING: Please be aware that too many extensions will slow down Visual Studio.

Here are the extensions that I consider most useful:

Hopefully all these tips and tricks will help you improve your productivity.

Mutation testing and the quest for quality

2015-06-01T00:00:00+00:00

In this post you’ll learn the differences between mutation testing and code coverage by comparing several code examples and you’ll also receive practical advice on improving software quality.

The best ways to teach someone a new concept that I know of are:

comparing the new concept with an existing one which they already know
showing a lot of examples

In this post I’ll do both.

To understand mutation testing, let’s review what code coverage is… If we were to check the Wikipedia page (as of 01.06.2015), code coverage is defined as:

“a measure used to describe the degree to which the source code of a program is tested by a particular test suite. A program with high code coverage has been more thoroughly tested and has a lower chance of containing software bugs than a program with low code coverage.”

Unfortunately, the statements above are not very acurate. Code coverage is the degree to which the source code of a program is executed, not tested which is not the same.

You can execute the code without testing anything. In the next example you’ll see what I mean, but first let’s setup the demo project.

The Gilded Rose Kata

I’m going to use the Gilded Rose Kata as an example codebase so you can follow my explanation. This project is specifically designed so you can practice working with legacy code and it fits perfectly for learning about code coverage and mutation testing coverage. The story behind the project is that you are working for a shop and have to add support for a new item type while keeping the current behaviour (not breaking it).

You can find the project on GitHub. Read the README.markdown file for more instructions.

Code coverage

Now that you have the project let’s see how we can get the code coverage by executing the main method. While this is not the first thing someone thinks of when hearing about code coverage it will help illustrate my point.

Execute the following command:

./gradlew appCodeCoverage

This will run the main method and collect code coverage using the JaCoCo Gradle plugin. After the command finishes you should check the build/reports/jacoco/applicationCodeCoverageReport/html/index.html file to read the coverage report.

This is the project level code coverage. In the first column you can see the packages and in the next 2 columns you can see the line coverage which is also called statement coverage and it means the percent of lines that were executed from the total. The following 2 columns (columns 4 and 5) show the branch coverage which means the percent of conditional branches (if, for, while) that were executed from the total.

The branch coverage is usually lower than the statement coverage. For example, in an if statement you can execute just one branch and have 100% statement coverage, but you only have 50% branch coverage because you executed just a single branch, not both. You can see in the image above that we have 76% branch coverage versus 81% statement coverage.

In the next view (which you get by clicking on the package name) you can see the code coverage distribution for all classes in the package. For this specific project we are interested only in the GildedRose class.

By clicking on the GildedRose class and then one of the methods you get to the code level view where you can see each line with a different background based on the executed status:

green line - was executed
red line - was not executed
yellow line - only one branch of the conditional statement was executed

Partial test coverage

There is another way to obtain code coverage: by running the automated tests, which is the most widely accepted definition.

I prefer to call it test coverage instead of merely code coverage just to highlight the way they have been obtained. The code coverage is obtained by running the main method (see previous example) and test coverage by running the automated tests.

You can git checkout incomplete_tests, run ./gradlew jacoco and open the report available in the build/reports/jacoco/test/html/index.html file.

In the test coverage report you will see that the code dealing with backstage passes is not executed at all from the tests. The reason for that is simple: there are no tests for it.

The test coverage is a pretty good way for you to find out (at least in the beginning) what new tests to write, but as you’ll see in the next examples it has certain limitations.

Full test coverage?!

Now, let’s improve that test coverage we have. I mean if we get to 100% test coverage that means the code is fully tested, right? Wrong… and you’ll see why by checking out the tests_without_asserts branch. If you execute again the command to gather test coverage: ./gradlew jacoco you’ll see that the coverage jumped to 100% (for the GildedRose class which contains the logic we want to test).

Unfortunately, if you check the test code you’ll see that all the asserts are commented out… Obviously, this is just to demonstrate the test coverage weaknesses and I’m sure none of you have seen such things in The Real World.

The most likely case is that you are missing some asserts in your test code, but it is hard to see which ones because you already have high test coverage as demonstrated in this example - 100% test coverage even without asserts.

Is the code actually tested?

We saw that having high test coverage doesn’t mean anything else that the code was executed. But, you may ask, how can we actually ensure that the code is tested now that we can’t trust the test coverage?!

Well, there’s an easy answer for that: the tests you have should fail if the production code is broken…

Oh, yeah, you couldn’t state something more obvious you say…

Knowing that, you could try breaking the production code and running the tests. If the tests fail, then the code is tested. If the tests still pass then obviously they aren’t any good since they should act as your safety net in case you break something.

This is all about increasing the confidence in your tests and ensuring that you won’t fall right through your “test” safety net.

Here’s a nice story that illustrates it from The Way of Testivus by Alberto Savoia (you should check the other stories as well - they contain a lot of wisdom):

How to break the production code?

Following the previous advice, let’s see how we can break the code to highlight the problems in our tests…

If we try deleting random parts of the code we could break the code in such a way that it doesn’t compile anymore and obviously we wouldn’t be able to run the tests in that case. Clearly this is not what we want. So while we break the code we must ensure that the code still compiles.

If we try deleting a lot of code at once (keeping the code compilable) then it’s very likely that all (or almost all) the tests will fail. We don’t want that… What we want instead is to find the minimum things to break in the production code so that the tests will all pass.

The best approach is to emulate a programmers usual mistakes: off by one errors, edge cases, removing calls to functions (programmer forgot to call it), exceptions, negating boolean expressions, replacing addition with subtraction and the other way around. These are all subtle changes and it’s very likely you will discover that for some of these your tests still pass. Obviously you have to add a unit test that detects that issue.

Mutation testing concepts

We finally got to the mutation testing part which is the easiest to understand. You have to know these three concepts:

a mutant is created by making (manually or automatically) a small change in the production code
the mutant is killed means that your tests fail when run after creating the mutant
the mutant survived means that your tests still pass when run after creating the mutant

To ensure the production code is fully tested your tests must kill all the mutants.

Manual mutation testing

Let’s take an example and do it manually just so we understand better the process. Checkout the almost_complete_tests branch. Now we have almost all the tests and 100% test coverage. Let’s see which tests are missing.

If we try changing something small (creating our mutant), like a subtraction to an addition:

and we run the unit tests again, we’ll see that they fail… this means the tests killed the mutant.

If we try doing the following change and running all the tests:

we’ll see that they pass… the mutant survived. This is a bad thing - it means that we are missing some tests…

Let’s check again the requirements for Sulfuras (you can find them in the README.markdown file):

Sulfuras, being a legendary item, never has to be sold or decreases in quality

Well, now we can write a test for this requirement:

and sure enough, when running the tests again for the previous mutant we can see that they fail:

Automated mutation testing

While creating these mutants for one or two lines of code is trivial, we wouldn’t want to do it manually for a whole class or for the whole code base. Fortunately, there are solutions for that - plugins and automated tools that can create the mutants, run the tests automatically and show you a coverage report - that is a mutation test coverage report - which gives you a lot more confidence in your tests.

I set up everything so you can get the true coverage by running ./gradlew pitest and opening the build/reports/pitest/index.html file.

Now you will see what parts of the code are not actually tested (even though we have 100% test coverage):

I will leave writing the missing tests as an exercise. If you want to check your answers you can look in the with_tests branch which contains the complete tests that lead to 100% mutation test coverage - the highest coverage you can get.

The parameterized_tests branch has the same tests as the with_tests branch except that I have removed (almost) all the duplicate code - the tests were looking very similar so I used the JUnitParams library to parameterize a single method:

Mutation testing - not a silver bullet

Sure, now you achieved 100% mutation test coverage and you’re absolutely sure that the tests will protect you from breaking the code. But will they also help you and not hinder the development by slowing you down?

Let’s see an example of how we could have written the tests by checking out the messed_up_tests branch. If you run again ./gradlew pitest and check the mutation test coverage you’ll see that we have 100% coverage, but something tells me you wouldn’t want to maintain those tests (which I wrote just as a proof of concept):

The Pyramid of Software Quality

I have discovered that the software quality, as the end user sees it, is highly influenced by a set of factors which I arranged into a pyramid of software quality:

Code quality influences software quality
If the code is not maintainable then every change you make will break something else in the codebase. No change will be trivial. Every addition or modification to the code will require all the tangles, twists, and knots to be “understood”.

The logic should be straightforward to make it hard for bugs to hide. C.A.R. Hoare put it best, although it applies to everything, not just software design:

“There are two ways of constructing a software design. One way is to make it so simple that there are obviously no deficiencies. And the other way is to make it so complicated that there are no obvious deficiencies.”

Test quality influences code quality
If you want to keep the code quality high then you have to refactor often and you can’t do it if you don’t have tests or if they don’t cover the code you’re interested in.

Mutation testing influences test quality
To have confidence that your tests will keep you from breaking the production code you need to have a high mutation test coverage. If you note, in this pyramid, I didn’t include “normal” test coverage because mutation test coverage is a stronger/better version of it.

Craftsman programmers influence everything
Finally, craftsman programmers influence every aspect of software development: they increase software quality by improving both: the production code and the test code. It doesn’t matter if you have high mutation test coverage if you have flickering tests and/or they are unreadable and have a high maintenance cost.

Michael Feathers put it best in this quote from the “Clean code” book by Robert C. Martin:

I could list all of the qualities that I notice in clean code, but there is one overarching quality that leads to all of them. Clean code always looks like it was written by someone who cares.

Mutation testing and performance

Mutation testing tools like pitest have to run the automated tests for each mutant they produce. This means that it will take quite a lot of time to run them compared to simply running the tests. Of course, good tools don’t run all the tests. They perform optimizations like running only the tests that execute the changed code based on the (normal) test coverage. This is very helpful and improves the performance quite a bit.

However, there are still things that you can do to get the mutation test coverage faster. One of these is to write true unit tests like Michael Feathers defines them:

A test is not a unit test if:
- It talks to the database
- It communicates across the network
- It touches the file system
- It can’t run at the same time as any of your other unit tests
- You have to do special things to your environment (such as editing config files) to run it.

Another thing you can do is to make the tool gather the coverage just for the module you’re currently working on and to also limit the mutators used. In pitest you can do this by specifying the targetClasses, targetTests and the mutators in the build.gradle script:

group = 'com.gildedrose'
// ...
pitest {
    targetClasses = ["${project.group}.GildedRose"]
    targetTests = ["${project.group}.AllTests"]
    mutators = ["ALL"]
}

Coverage and quality targets

Don’t transform coverage (of any type: being it normal or mutation test coverage) into a target if you don’t want programmers to cheat it by writing the worst tests possible that will hinder the maintenance/development more than anything else. I showed you an example in the messed_up_tests branch how bad can the tests be.

The only purpose any coverage has is to help you find untested code and to reduce risks when improving the codebase.

Mutation testing tools

For some languages the tools aren’t that well developed. The highest quality tools seem (haven’t tried all of them) to be for java, ruby and php. The .NET and python tools are quite limited.

Other languages (like C/C++) don’t have any tools but this doesn’t mean you can’t write tests and before refactoring try them out by changing manually some lines and checking if the tests fail. That’s the least you can do in that case.

For java there is pitest. There are others as well, but pitest seems the best considering the integration with build tools.

For ruby you have Heckle and Mutant.

For php you can use Humbug.

For .NET the tools are seriously limited so don’t be dissapointed:

For python there’s Pester. Don’t be surprised you see Java and JUnit - if you continue reading the page you’ll see links for pester too. Another (not very mature) tool for Python is elcap.

Rocking with Jira’s Script Runner

2014-11-24T00:00:00+00:00

In this post I will show you how to get up to speed with scripting in Jira. You will learn how to develop scripts, test them and various tips and tricks on how to develop in a productive way. I will show you a lot of examples and also provide a separate git repository which you can clone and play with.

I found out that there are a lot of great tools out there, but there’s no documentation on how to make them all work equally great together. This post aims to change that and show you how to use Jira, Jira’s API, the Script Runner add-on, the Groovy language, the Gradle build system and the IntelliJ IDEA IDE the best way possible.

How to develop your scripts

Install IntelliJ IDEA - the Community Edition which is free to use and has built-in support for Groovy.

Run git clone https://github.com/igorpopovio/jira-scripting.git.

Run gradlew or ./gradlew (depending on your operating system: Windows or Linux) to generate the IntelliJ IDEA projects… this will take a while since it will download all the required libraries from Atlassian’s maven repository.

After the previous step finishes, open the ipr file in IntelliJ IDEA then open any script from the project and begin experimenting. When you finish writing the script just copy paste it into the Script Runner Console and run it.

Code completion with IntelliJ IDEA

After you generate and import the IntelliJ IDEA project you should get code completion automatically when typing a variable and . (dot). If the popup doesn’t show up like in the image below then you can force it with CTRL + SPACE.

How to test your scripts

After you write your scripts you might want to test them on a test server just to make sure you don’t mess up the production server… To set up a testing server locally you need to install the Atlassian SDK.

After installing it you can start an instance of Jira from the command line:

atlas-run-standalone --product jira

You might also want to specify which version you want to start:

atlas-run-standalone --product jira --version 6.3.10

You might want to grab a coffee or something since this command will take a bit of time to download everything it needs.

When the previous command finishes go to the URL printed in the command line (should be http://localhost:2990/jira or something similar). Login with user/password: admin/admin and create a new demo project (see the next section). This project will already have some issues created so you can go on directly to the testing part.

Install the Script Runner plugin from the Atlassian Marketplace and go to Administration -> Add-ons -> Script Console (see the image below).

Creating a test project

Luckily, Atlassian made a demo project with several issues. Here’s how to create it:

The build script

The build script is done in Gradle because it is much easier to use than other tools: you don’t even need to have it installed. You just need to have the Java Development Kit installed which I assume you have because you installed the Atlassian SDK which requires it.

The build script will download the jira-core libraries from Atlassian’s maven repository and will also generate the IntelliJ IDEA project which you’ll later use. All that you have to change in this script is the Jira version:

com.atlassian.jira:jira-core:<REPLACE WITH YOUR JIRA VERSION>

Now run gradlew from the command line to generate the project and then import it in IntelliJ.

Here is the full Gradle build script:

apply plugin: 'groovy'
apply plugin: 'idea'

defaultTasks 'idea'

repositories {
    mavenCentral()
    maven { url = 'https://maven.atlassian.com/repository/public' }
}

dependencies {
    compile 'org.codehaus.groovy:groovy-all:2.3.6'
    compile 'com.atlassian.jira:jira-core:6.3.6'
}

Jira’s `ComponentAccessor`

To achieve anything when scripting for Jira you need some kind of manager for the objects you want to change. Examples include (but are not limited) to: ProjectManager, IssueManager, UserManager, PermissionManager, VersionManager, FieldManager, CommentManager, IssueEventManager and ServiceManager.

You can access them easily by typing ComponentAccessor.manager in IntelliJ IDEA and select the one you need like in the image below:

Please note that only some of the managers appear as properties on ComponentAccessor. There are others as well which you can find about by browsing the javadoc documentation.

Here are some examples on how to get those managers (some of them, like the SearchProvider don’t even have “manager” in their names):

def issueManager = ComponentAccessor.issueManager
def user = ComponentAccessor.jiraAuthenticationContext.user
def jqlQueryParser = ComponentAccessor.getComponent(JqlQueryParser.class)
def searchProvider = ComponentAccessor.getComponent(SearchProvider.class)

There are 2 ways of getting something. First you have some fields for the really common stuff. For the uncommon stuff just use getComponent.

Also please use the Groovy way instead of classical getters. Use just the property name: ComponentAccessor.issueManager, not ComponentAccessor.getIssueManager().

Now, why would you need that `ComponentAccessor`?

Let’s assume you need an IssueManager - it is the most used one: how would you get it?

If you check the javadoc you would see that it is just an interface with 2 implementations: DefaultIssueManager and MockIssueManager. The MockIssueManager is just a replacement class used in Atlassian’s unit tests, so we’re left with just one choice: the DefaultIssueManager.

Let’s see how we can create it… here is the constructor taken from the javadoc:

DefaultIssueManager(OfBizDelegator ofBizDelegator, WorkflowManager workflowManager, NodeAssociationStore nodeAssociationStore, UserAssociationStore userAssociationStore, IssueUpdater issueUpdater, PermissionManager permissionManager, MovedIssueKeyStore movedIssueKeyStore, ProjectKeyStore projectKeyStore)

To create that issue manager you would first need to create all the objects given as a parameter and before doing that you’d need to create all the objects that those objects need and so on…

In case you’re wondering how Jira manages all those objects: they use an Inversion of Control container called PicoContainer. You can Google it for more information…

Finding issues using JQL

Probably the most common thing you’d want to change in Jira is an issue. To get hold of it you need to use the Jira Query Language which is a kind of query language designed for interrogating Jira about issues.

I have written a groovy method that can return a list of issues based on a query that you give as a parameter. After obtaining the list of issues you can change them however you want.

def findIssues(String jqlQuery) {
    def issueManager = ComponentAccessor.issueManager
    def user = ComponentAccessor.jiraAuthenticationContext.user
    def jqlQueryParser = ComponentAccessor.getComponent(JqlQueryParser.class)
    def searchProvider = ComponentAccessor.getComponent(SearchProvider.class)

    def query = jqlQueryParser.parseQuery(jqlQuery)
    def results = searchProvider.search(query, user, PagerFilter.unlimitedFilter)
    results.issues.collect { issue -> issueManager.getIssueObject(issue.id) }
}

jqlQuery = "project = DEMO and text ~ 'shortcut'"
logImportantMessage "Executing query: <pre>${jqlQuery}</pre>"
def issues = findIssues(jqlQuery)

I don’t know JQL! What should I do?

Well, you can always learn by example: first of all search the issues in Jira, switch to advanced mode and copy paste the JQL query. See the screenshots below:

Besides the copy paste you can always check Atlassian’s documentation on JQL queries…

Jira issue objects

IntelliJ IDEA gives you all the code completion suggestions but not all of them are useful in Jira’s case - some of the methods are internal and shouldn’t be touched (unless you know what you’re doing). I recommend you stick to the methods that have Object in name - these are the actual domain objects that have all the properties easily accessible:

Updating issues

Just changing the issue won’t actually update it in Jira’s internal database. To do that you have multiple options. There doesn’t seems to be a standard way of doing it, so I’ll just describe and provide examples for each method I encountered.

This initial example is using the manager for labels. There are managers for pretty much everything in Jira - you just need to get it using the ComponentAccessor.

def addLabelToIssue(MutableIssue issue, String label) {
    def labelManager = ComponentAccessor.getComponent(LabelManager.class)
    def user = ComponentAccessor.jiraAuthenticationContext.user.directoryUser
    def sendEmailUpdates = false
    labelManager.addLabel(user, issue.id, label, sendEmailUpdates)
}

addLabelToIssue(issue, "productivity")

Jira Bulk Change vs Script Runner

You can do almost the same thing using Jira’s Bulk Change with a single exception: you cannot append something to a list (of labels, of versions, of anything actually…). You can just overwrite the previous values which is probably not what you expect… See the images below to get an idea…

The change that appears at 12 minutes ago was done using the Script Runner and my example script… The change from 4 minutes ago was done using Bulk Change… Note the difference: when using Bulk Change you lose the previous values!

Updating issues with `ModifiedValue`

This is an example on how to add and update the fix versions. This way of updating issues is very coupled to the field name, much like the previous example. In the next section I’ll show a better and more general way of updating.

def addFixVersionToIssue(MutableIssue issue, Version fixVersion) {
    def oldFixVersions = issue.fixVersions
    def newFixVersions = oldFixVersions + fixVersion
    def value = new ModifiedValue(oldFixVersions, newFixVersions)

    def field = ComponentAccessor.fieldManager.getOrderableField("fixVersions")
    field.updateValue(null, issue, value, new DefaultIssueChangeHolder())

    issue.fixVersions = newFixVersions
}

def getVersion(String projectKey, String versionName) {
    ComponentAccessor.versionManager.allVersions.find { version ->
        version.projectObject.key == projectKey && version.name == versionName
    }
}

def projectKey = "DEMO"
def fixVersionName = "Version 1.0"
def fixVersion = getVersion(projectKey, fixVersionName)

addFixVersionToIssue(issue, fixVersion)

Finding out dynamic fields

In some cases you’ll need methods that receive field names or other similar things. This is the case we had in the previous example:

def field = ComponentAccessor.fieldManager.getOrderableField("fixVersions")

How were we supposed to know what we have to use "fixVersions" as parameter??? Well, you can use the Script Runner to help you find out the orderableFields like this:

Better way to update issues

This is the most general way to update something related to an issue. Normally you should call it no matter what you update.

def updateIssue(MutableIssue issue) {
    def user = ComponentAccessor.jiraAuthenticationContext.user
    def issueManager = ComponentAccessor.issueManager
    issueManager.updateIssue(user, issue, createIssueUpdateRequest())
}

def createIssueUpdateRequest() {
    new UpdateIssueRequest.UpdateIssueRequestBuilder()
            .eventDispatchOption(EventDispatchOption.DO_NOT_DISPATCH)
            .sendMail(false)
            .build()
}

updateIssue(issue)

Indexing updated issues

This isn’t always required, but here’s how to do it anyway…

def reindex(Collection<MutableIssue> issues) {
    def issueIndexManager = ComponentAccessor.issueIndexManager
    boolean wasIndexing = ImportUtils.isIndexIssues()
    ImportUtils.setIndexIssues(true)
    issues.each { issue -> issueIndexManager.reIndex(issue) }
    ImportUtils.setIndexIssues(wasIndexing)
}

reindex(issues)

Providing feedback on the results

By default the logs will get buried somewhere in Jira’s logs and while it is possible to go hunt them down it would be too much hassle. Instead you can return a string from the script and the Script Runner will show it after running your script. I made several methods that help with the logging - basically just appending stuff to a string and finally returning it.

finalMessage = ""

def logMessage(Object message) {
    finalMessage += "${message}<br/>"
}

def logImportantMessage(Object message) {
    logMessage "<strong>${message}</strong>"
}

return finalMessage

Finding the issue links

Although this is not required and doesn’t actually change anything in Jira, I prefer to have it. Basically instead of getting just a list of issues that can be updated you get a list where you can click on any issue and get more details. It saves me from having to copy paste the issue key from the list to the browser’s address bar.

def getIssueLink(MutableIssue issue) {
    def properties = ComponentAccessor.applicationProperties
    def jiraBaseUrl = properties.getString(APKeys.JIRA_BASEURL)
    "${jiraBaseUrl}/browse/${issue.key}"
}

def formatIssue(MutableIssue issue) {
    def issueLink = getIssueLink(issue)
    def htmlLink = "<a href=\"${issueLink}\">${issue.key}</a>"
    "<strong>${htmlLink}</strong> - ${issue.summary}"
}

logImportantMessage "Found ${issues.size()} issues. Here they are:"
logIssues(issues)

Script results

After running the script you should see the results in a nice format like in the screen shot below:

It can get even better: by using nicely styled tables from AUI (Atlassian User Interface):

You can check the repository with examples and see how it’s done.

How can I do `this/that/whatever`?

From what I noticed, in Jira, there are quite a lot of managers and these are available as directly accessible fields in the ComponentAccessor class. I would first look if there’s any manager that seems to have what I want then fumble up with IntelliJ IDEA’s code assistance and then look it up in Jira’s javadoc. If that doesn’t work you could check Atlassian Answers (either search or even ask questions) or Google.

More resources

7zip gotchas

2014-08-16T00:00:00+00:00

This is going to be a short post about some gotchas when archiving files with 7zip from the command line.

Archiving files

Let’s start from the following directory structure:

files
|-- file1.txt
`-- file2.txt

Here’s the simplest way to archive those files using 7zip:

7z a archive.zip files

This will create the following structure:

archive.zip
`-- files
    |-- file1.txt
    `-- file2.txt

This is fine, but what if you don’t want the files top directory? Like in this example:

archive.zip
|-- file1.txt
`-- file2.txt

In this case you should use the following command:

7z a archive.zip .\files\*

Slashes, the initial dot (current directory) and the final asterisk are required or else 7zip will fallback to archive everything including the top level directory.

Examples repository

I made a small PowerShell script that you can use to test the examples described in this post. Here’s the link.

Reducing boilerplate with Fody

2014-08-06T00:00:00+00:00

This post is regarding reducing boilerplate code when implementing the MVVM pattern for WPF applications. One of the great things about MVVM is that you can bind properties to GUI elements and when you change one of them the other will update automatically. To get this to work you need to implement the INotifyPropertyChanged interface.

The classic way

Normally you’d create an ObservableObject similar to this:

public class ObservableObject : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged = delegate { };
    public void OnPropertyChanged(string propertyName)
    {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }
}

Let’s say that you have an Item class and you want to bind it’s properties to the GUI. Here’s the class:

public class Item : ObservableObject
{
    public Item()
    {
        Name = "Testing Item";
        Description = "Just an item used for testing";
    }

    private string _name;
    public string Name
    {
        get { return _name; }
        set
        {
            _name = value;
            OnPropertyChanged("Name");
        }
    }

    private string _description;
    public string Description
    {
        get { return _description; }
        set
        {
            _description = value;
            OnPropertyChanged("Description");
        }
    }
}

And here’s the GUI:

<Window
        ...
        xmlns:src="clr-namespace:MyApp"
        >

    <Window.DataContext>
        <src:Item/>
    </Window.DataContext>

    <StackPanel Orientation="Vertical">
        <TextBlock Text="{Binding Name}"/>
        <TextBlock Text="{Binding Description}"/>
    </StackPanel>
</Window>

When you want to use binding you cannot use automatic properties so you have to provide similar implementations for all of them. Add a private field, make the getter return it and the setter call the OnPropertyChanged method from ObservableObject. It’s not difficult, but it’s code that I don’t want to write and I don’t want to see - because it’s code that has no (business) logic in it and it’s highly repetitive.

Of course, you might argue that if I don’t want to see them then I could use those #region directives, but I feel like I’m sweeping them under the carpet. It doesn’t really solve the problem. Some people (me being one of them) recommend that you shouldn’t use regions.

The Fody way

Fody is a “tool for weaving .net assemblies”. Probably this short intro doesn’t tell you much so here’s my explanation: Fody adds new attributes (based on the plugins you use) that generate (Intermediate Language) code during the build. That IL code is code that you don’t see and you don’t write, but does the job. It’s basically eliminating boilerplate code - really similar code that you must always write that doesn’t achieve much.

How to use it

In Visual Studio add the Nuget package for PropertyChanged.Fody:

After installing it just add the [ImplementPropertyChanged] attribute and the automatic properties. Here’s the Item class again:

[ImplementPropertyChanged]
public class Item
{
    public string Name { get; set; }
    public string Description { get; set; }

    public Item()
    {
        Name = "Testing Item";
        Description = "Just an item used for testing";
    }
}

I know that this isn’t much, but considering that in a normal project you can have a lot more properties this is pretty nice.

Classic way: 10 lines for each property (braces included, spacing removed)

private string _name;
public string Name
{
    get { return _name; }
    set
    {
        _name = value;
        OnPropertyChanged("Name");
    }
}

Fody way: 1 line for each property (disregarding the attribute line, since it’s once per class)

public string Name { get; set; }

This looks to me like a major win: 10 times less code!

Before Fody I found out about PostSharp which seems to do the same thing (regarding INotifyPropertyChanged - it also does a lot more), but they use the NotifyPropertyChanged attribute instead.

There are a lot of other cool plugins for Fody like: Equals and ToString (among many others). It’s worth checking them out.

The full code that I used for this blog post is available on GitHub:

Understanding Gradle

2014-05-01T00:00:00+00:00

In this blog post I’ll review a bit how Gradle works behind the scenes and how certain parts may seem magical if you don’t know Groovy. And, of course, I’ll explain how that DSL magic works.

When I started learning Gradle this was one of the major blockers in doing something with it. If you don’t understand that magic then you’re limited to the examples in the documentation which aren’t that revealing and don’t help you when you have similar issues.

Warning! this blog post just tries to bring you closer to understanding Gradle, but it’s not an exact overview of how Gradle works.

Gradle basics

Let’s say that you have a fairly standard java project. You’ll need the JUnit library, because, well, you do test your code, riiiight? We’ll add that as a dependency for the test code.

This is how the build script would look like:

apply plugin: 'java'

repositories {
    mavenCentral()
}

dependencies {
    testCompile 'junit:junit:4.11'
}

Basically, what’s happening here is that you add the java plugin that automatically adds some defaults for building java projects.

Then you configure the repositories that tell Gradle where to download it’s dependencies from.

After that you tell that in order to compile the tests you need an external library that will be downloaded from the above defined repository.

A billion Gradle questions for a total noob

Now, if you have a java background that syntax looks fairly alien. It seems like a dedicated language for specifying builds. But how does it work? What is apply or repositories or dependencies? How do I know what’s available so I can do my work? What’s that curly braces thing?! It looks like a code block… What about that testCompile? I don’t see where it is defined… I don’t even know what it is and what I can do with it…

I had all these questions initially and although I could create a basic Gradle script I couldn’t undestand it or make it do something that wasn’t described in the Gradle user guide.

Groovy closures and Gradle Nirvana

After reading the documentation, Gradle DSLs, the Gradle forums and lots of Googling I achieved nirvana. That is: the Gradle nirvana.

First, those apply, repositories, and dependencies thingys are just normal methods. You may ask: “Wooaah! Methods! But if they are methods then they must belong to an object, right?” Yes, they are defined in the Project class. Once you know this, more things start to get clearer. Now if there’s something you don’t understand you can look it up in the Project class documentation: method definition, etc.

Now, the way you call these methods may seem a bit strange. For example, what is that curly brace thing? It’s a Groovy closure! It’s something like an anonymous method that can be passed as a parameter to other methods. It’s actually implemented as an anonymous java class with just one method.

Here’s how to make that testCompile thing - add the following code to build.gradle and run it with ./gradle -q:

class DependencySpec {
    def testCompile(String libraryIdentifier) {
        println "Adding the $libraryIdentifier library..."
    }
}

def dependencies2(Closure configurationClosure) {
    def dependencySpec = new DependencySpec()
    configurationClosure.delegate = dependencySpec
    configurationClosure.resolveStrategy = Closure.DELEGATE_FIRST
    configurationClosure()
}

dependencies2 {
    testCompile 'junit:junit:4.11'
}

Ok, so I’ll take you through all the above code, since it’s quite a lot to take at once. First, I used dependencies2 so my code doesn’t conflict with what’s already provided in Gradle and it shouldn’t affect your understanding anyway :).

Then, the DependencySpec class and the dependencies2 method are present in the build.gradle script, but the dependencies method (from Gradle) is available in the Project class which is compiled and put in the class path of the build script. So, all that’s left for you to see is only the dependencies method call, which seems kind of magical if you don’t know how it’s implemented.

I left the supporting code in the same script so you can see and understand how everything works.

Let’s start from the dependencies2 method call:

dependencies2 {
    testCompile 'junit:junit:4.11'
}

It may not seem a method call, since in java you have to put parenthesis like this: dependencies2( /* method arguments */ ). Well, in Groovy (which Gradle builds on top), the parenthesis are optional if you have at least one argument (if there’s no argument you MUST use them).

Now, things get confusing again: there are no arguments for the dependencies2 method call (or so it seems). And again, that certainly doesn’t look like a method call! How can a method call have a “definition code block”?!

Well, let’s rewrite that section of the code without using Groovy magic/syntactic sugar so it’s a bit more clear.

Closure configurationClosure = { testCompile 'junit:junit:4.11' }
dependencies2(configurationClosure)

Now you can clearly see that we have a method call. What about the testCompile? Well, that’s a method call too. Just add the paranthesis and everything becomes clear again: testCompile('junit:junit:4.11').

Now, to understand how it’s possible to call the testCompile method even though it’s in another class let’s review the first part:

class DependencySpec {
    def testCompile(String libraryIdentifier) {
        println "Adding the $libraryIdentifier library..."
    }
}

First, you define a new Groovy class that has the code you need, testCompile in our case. Then you define a new dependencies2 method that receives a closure as an argument.

def dependencies2(Closure configurationClosure) {
    def dependencySpec = new DependencySpec()
    configurationClosure.delegate = dependencySpec
    configurationClosure.resolveStrategy = Closure.DELEGATE_FIRST
    configurationClosure()
}

Now you need to understand one cool thing about closures: you can “delegate” method calls that are not defined in them to an object. In our case this object is of type: DependencySpec. So this means that when you call a method in the configuration closure it will be “forwarded” to a DependencySpec.

To achieve this you have to set the closure’s delegate to our object AND set the resolveStrategy to Closure.DELEGATE_FIRST so Groovy/Gradle knows that it should first look for any undefined thingy in our own object.

The Groovy closures practically hold the (Gradle) Universe together. They are the key to understanding Gradle and getting to a productive level with it.

You can read more about Groovy closures to get a better understanding.

Artifactory, Gradle and publishing

2014-04-27T00:00:00+00:00

In this post I’ll show you how to setup Artifactory from scratch and how to publish a jar from gradle.

Downloading and running

Go to JFrog’s Artifactory download page and get the zip archive. Extract it somewhere and then start bin/artifactory.sh (or bin/artifactory.bat in case you’re using Windows).

You should now be able to access Artifactory at: http://localhost:8081/artifactory. The default credentials are: admin/password.

Creating a java project with gradle

Gradle is a build tool for java projects. It’s more powerful than maven and ant. We’ll use it to create a very simple java project. But first you need to download the latest version and add it to your PATH.

After you got gradle, run these commands from the command line:

mkdir gradle-artifactory-publishing
cd gradle-artifactory-publishing
gradle init --type java-library
gradlew build

Now you should have a fully functional java project.

Using Artifactory

After running gradle init --type java-library you get to use the central maven repository. Let’s change the build to use our own Artifactory.

The default (in case you don’t use any custom maven server) is:

repositories {
    mavenCentral()
}

We need to change this to:

repositories {
    maven { url 'http://localhost:8081/artifactory/repo' }
}

In case you’re wondering where does that repo at the end of the URL come from: it’s the default virtual repository.

Quote from their documentation:

Artifactory defines a default global virtual repository which effectively aggregates all other repositories at the following URL: <host>:<port>/artifactory/repo.

By configuring Maven with this URL, any request for an artifact will go through Artifactory which will search through all of the local and remote repositories defined in the system.

Publishing artifacts

Most of the times you need to publish a library to your Artifactory server. Let’s see how we can achieve this using gradle.

Apply the new maven publishing plugin: apply plugin: 'maven-publish'.

Next configure what you want to publish and where:

group = 'io.igorpopov'
version = '1.0'

publishing {
    publications {
        mavenJava(MavenPublication) {
            from components.java
        }
    }
    repositories {
        maven {
            credentials {
              username 'admin'
              password 'password'
            }
            url "http://localhost:8081/artifactory/libs-release-local"
        }
    }
}

Here’s the output you should get:

 ➜  ./gradlew publish
:generatePomFileForMavenJavaPublication
:compileJava
:processResources UP-TO-DATE
:classes
:jar
:publishMavenJavaPublicationToMavenRepository
Uploading: io/igorpopov/gradle-artifactory-publishing/1.0/gradle-artifactory-publishing-1.0.jar to repository remote at http://localhost:8081/artifactory/libs-release-local
Transferring 1K from remote
Uploaded 1K
:publish

BUILD SUCCESSFUL

Total time: 5.472 secs

Let’s review the most important parts of the publication. You need to have the three maven standard identifiers for a library:

the groupId (group in gradle)
the artifactId (name in gradle)
the version (same in gradle)

The next most important is the publishing gradle closure that defines exactly what we want to publish:

publishing {
    publications {
        mavenJava(MavenPublication) {
            from components.java
        }
    }
}

The mavenJava(MavenPublication) can be changed to reflect the name of your library. You could for example use: mylibrary(MavenPublication).

Next, you need to specify what files you want to publish (the from part). You should probably check the gradle documentation for publishing to maven for full details and examples.

You also need to tell gradle where you want to publish your artifact. For this we need to review what type of repositories Artifactory provides us: local, remote and virtual.

Local repositories are physical, locally-managed repositories into which you can deploy artifacts.

Remote repositories serve as a caching proxy for other repositories. Artifactory is deployed with a number of pre-configured, remote repositories which are in common use, but you can add new repositories based on your needs.

Virtual repositories aggregate several repositories under a common URL. The repository is virtual in that you can resolve and retrieve artifacts from it but you cannot deploy artifacts to it.

This means that you cannot use the default virtual repository (http://localhost:8081/artifactory/repo) to deploy artifacts (or any other virtual repository for that matter).

For this reason you must use one of the local repositories:

For full details you can check Artifactory’s documentation on repositories.

Here’s how to configure gradle to use the snapshots repository when you have SNAPSHOT versions:

group = 'io.igorpopov'
version = '1.0-SNAPSHOT'

publishing {
    publications { ... }
    repositories {
        maven {
            credentials { ... }

            if (project.version.endsWith('-SNAPSHOT'))
                url "http://localhost:8081/artifactory/libs-snapshot-local"
            else
                url "http://localhost:8081/artifactory/libs-release-local"
        }
    }
}

Debugging

In case something goes wrong and you want to follow more closely what is happening you can use these simple tricks:

Gradle Info

Use ./gradlew build --info to get the download URLs for each jar dependency.

// the important part of the logs
:compileJava
Download http://localhost:8081/artifactory/repo/org/slf4j/slf4j-api/1.7.5/slf4j-api-1.7.5.pom
Download http://localhost:8081/artifactory/repo/org/slf4j/slf4j-parent/1.7.5/slf4j-parent-1.7.5.pom
Resource missing. [HTTP HEAD: http://localhost:8081/artifactory/repo/org/slf4j/slf4j-parent/1.7.5/slf4j-parent-1.7.5.jar]

The Resource missing you get above might be an issue and it can be further investigated. These kind of issues are pretty hidden and you need to use the --info flag to find them. Left unfixed, these issues can lead over time to a greatly increased build time.

Artifactory trace

Take the URL that gives “resource missing” from the previous step, paste it in your browser and append: ?trace.

http://localhost:8081/artifactory/repo/org/slf4j/slf4j-parent/1.7.5/slf4j-parent-1.7.5.jar?trace

This will show a page with Artifactory’s full log of what happens when it tries to get that dependency: what repositories it tries first, does it find the dependency in one of the local repositories or does it fetch it from some remote repositories? This can be very useful when debugging why some dependency is not found or when you have performance issues.

You can check Artifactory’s documentation on this topic.

This should be enough to get you up and running with Gradle, Artifactory and publishing new artifacts.

Considerations

This blog post just shows the basics how to get started with Gradle, Artifactory and publishing. When taken into production use you obviously need to change the default users and to install Artifactory as a service (not just start it from the command line like I did in this blog post). You also need to define the security permissions and inclusion and exclusions rules for artifact repositories.

You should check Artifactory’s documentation to know exactly what to configure and where to be careful regarding the security.

Resources

You can find the full example project on GitHub and the documentation I used to learn these things.

WPF - From Zero to Hero - Part II

2014-03-08T00:00:00+00:00

In the previous post I just looked at some examples and started banging code. I learned quite a lot of stuff. Now I’ll learn how to use the MVVM pattern. This pattern was first introduced by Martin Fowler and then adopted by Microsoft as part of the WPF framework.

This pattern is used to separate the business logic from the gui logic. So in this case you’ll have a data model, which deals only with the business logic, and a view model, which deals only with display logic, for example formatting and getting the data from the data model into the user interface.

INotifyPropertyChanged

The most important things are using data binding and implementing the INotifyPropertyChanged interface or using the ObservableCollection.

I saw that Telerik, in their examples, have extracted this in a separate class called ViewModelBase. This class is only available if you’re using Telerik which doesn’t apply in this case. I thought that I would extract my own, but I didn’t quite like the name. It’s not very consistent with what WPF offers. So, we have an ObservableCollection already available in WPF… what would be a proper name for just one object? It still needs to be “observable”… Maybe ObservableObject? Actually I was quite surprised it’s not already provided by WPF…

Here’s the code:

public class ObservableObject : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged = delegate { };
    public void RaiseOnPropertyChanged(string propertyName)
    {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }
}

The ViewModel

The next thing is the ViewModel which needs to extend the ObservableObject:

namespace DiagnoseTry2_WithMvc
{
    public class ViewModel : ObservableObject
    {
        private string message;
        public string Message
        {
            get { return message; }
            set
            {
                message = value;
                RaiseOnPropertyChanged("Message");
            }
        }
        // other code
    }
}

Here’s how we connect the ViewModel to the view:

<Window 
        ...
        xmlns:src="clr-namespace:DiagnoseTry2_WithMvc"
        >

    <Window.DataContext>
        <src:ViewModel/>
    </Window.DataContext>
</Window>

When someone updates the Message property, the subscribers (in this case the View: MainWindow.xaml) will be notified using the RaiseOnPropertyChanged() method. You may wonder who sets those subscribers, since we didn’t do it anywhere… Well, in fact we did it using data binding on this line:

<TextBlock Text="{Binding Message}"/>

I won’t go into details on how the Items are implemented since they are very similar to the normal Message. The only differences are:

Items is an ObservableCollection
Item should be an ObservableObject
the binding is done like this:

<ListBox ItemsSource="{Binding Items}" />

The next step is to actually show something in the GUI. For this we just add some items in the constructor. I know this is not the normal way, but I prefer using simpler methods while I’m learning till I get all the moving parts.

public ViewModel()
{
    Items = new ObservableCollection<Item>();
    Items.Add(new Item() { Name = "first item name", Description = "first item description" });
    Items.Add(new Item() { Name = "second item name", Description = "second item description" });
    Message = "There are " + items.Count + " items";
}

Resources

Boolean Logic

2014-02-17T00:00:00+00:00

While learning WPF I encountered this example on Microsoft’s website. You can either scroll down or download the C# version of the code.

It’s about this code:

// MainWindow.xaml.cs
private void ShowOnlyBargainsFilter(object sender, FilterEventArgs e)
{
    AuctionItem product = e.Item as AuctionItem;
    if (product != null)
    {
        // Filter out products with price 25 or above
        if (product.CurrentPrice < 25)
        {
            e.Accepted = true;
        }
        else
        {
            e.Accepted = false;
        }
    }
}

The entire inner if statement can be reduced to:

e.Accepted = product.CurrentPrice < 25;

This reads very well in plain english (unlike the original version which is also longer):
“accepted means that the product’s current price is smaller than 25”.

Actually, the whole method can be rewritten as:

// MainWindow.xaml.cs
private void ShowOnlyBargainsFilter(object sender, FilterEventArgs e)
{
    AuctionItem product = e.Item as AuctionItem;
    if (product != null) e.Accepted = product.CurrentPrice < 25;
}

This is only 5 lines of code, unlike the original version which is 16 lines of code, 11 lines of code waste! The final is just one third! Imagine if this would be happening in a real project!

I really hate when people don’t understand boolean logic and write billions of lines of code that others have to read and maintain!

Regarding the example above: I would go even further. If we look at the method name we see that it shows bargains. This concept can be expressed more clearly in the code by creating a function isBargain in AuctionItem.
This is called the tell, don’t ask! principle.

Here’s how I would do it:

// MainWindow.xaml.cs
private void ShowOnlyBargainsFilter(object sender, FilterEventArgs e)
{
    AuctionItem product = e.Item as AuctionItem;
    if (product != null) e.Accepted = product.IsBargain();
}

// AuctionItem.cs
public bool IsBargain()
{
    return CurrentPrice < 25;
}

This type of logic should be in the domain model, not in the user interface as it was in the original code.

Dealing with boolean expressions

Here are some of the bad examples I encountered and how you can correct them. The examples are in java, but it shouldn’t matter.

Don’t compare a boolean with true! It is already true!

// bad way
if (something == true) doThis();

// good way
if (something) doThis();

// even better: rename the boolean so it reads like English
if (isSomething) doThis();

// good examples: isBargain, isValid, isFile, exists, shouldReceiveBonus

Same goes for false:

// bad way
if (something == false) doThat();

// good way
if (!something) doThat();

Other programmers have an urge to check the boolean when returning from a function.

// bad way
if (condition)
    return true;
else
    return false;

// good way
return condition;

Some other programmers use the ternary operator:

// bad way
boolean active = userDisabled? false : true;

// good way
boolean active = !userDisabled;

And finally: don’t EVER use booleans as parameters to a function. This violates the Single Responsibility Principle. If you need a boolean parameter you are doing 2 things: one for true and the other for false. If you didn’t know about the Single Responsibility Principle, maybe you should check the full stack which is called the SOLID principles.

Here are some examples:

// bad way
setVisible(true);
setVisible(false);

// good way
show();
hide();

// other good examples: enable/disable, switchOn/switchOff

Tips and Tricks

How can you avoid writing code as in the original example? Well, here are some tips:

The moral of the story

The C# code I showed in the beginning of the article is an example, a demo… no wonder why new programmers (and not only) write shitty code! When they start learning a new technology they only see piles of crap all over the Internet.

So, one moral is for software professionals to be more careful what type of code they use as examples (unlike Microsoft in this case).

What type of code YOU want to promote? Don’t forget that it always backfires and you end up working with people that will write the same kind of code.

WPF - From Zero to Hero - Part I

2014-02-15T00:00:00+00:00

I’d like to learn WPF to create a tiny application (something like a TODO list application). This is my first time ever touching Microsoft technologies. That’s why I will document all the steps I take while learning.

Let’s begin… The first thing I need is Visual Studio. After a quick search on google I found Microsoft Visual Studio Express for Windows Desktop.

Here’s the GUI I want to end up with:

Pretty simple, huh?

I created a new Visual C# WPF Application project and began playing a bit with the Designer. Obviously, since this was my first attempt it didn’t look very good. Besides, I want to add each item (line with image, small description and recommendations) dynamically. This means I have to create some kind of component or a template which I can refer to from code.

After a bit of googling and looking at sample projects I was a bit disappointed with what I found… The most relevant information I have found is in this stackoverflow answer which provides some very good links for data binding and data templating.

Nice looking interface

While the information I found is very good, I still don’t know how to make good looking items. That’s why I began googling for some professional “WPF components” and I found Telerik (a company that seems to specialize in creating various GUI components). After looking a bit on their site I found a demo to download.

Playing with their demos, I noticed they have some examples for a custom ListBox and they also have code samples. The ListBox I found looks somewhat similar to what I want to do:

After checking the source code I saw that they obviously use their own components, but I also noticed that some parts could be used in a standalone project (without Telerik).

But, of course, I had to actually try and see if the components are as independent as I thought they were. That’s why I replaced the empty Grid I got when I created the WPF Application with the one from Telerik examples (section 3. in the image above).

After doing so, I noticed that there were some issues (code underlined with blue wiggles) which are related to some resources I haven’t copied. This and the fact that the window rendering from the upper half of Visual Studio is quite empty and I couldn’t figure out the layout easily, made me remember a useful technique for debugging layouts. The basic idea is to add a bright and noticeable background color to the component you’re debugging so that you can better notice overflows and floating issues.

This is what I got after replacing all those wiggly underlines with the debug background colors:

This kinda looks similar to one of the lines from the Telerik demo (it’s just a bit stretched on height as you can notice from the huge green rectangle): circle on left side, then a title and a small description, and then another image:

Now, at least, I know I got the layout right and it works outside of Telerik.

Code

Here’s the part that creates the (future) item template:

<StackPanel Orientation="Vertical" Background="Green" Margin="10">
    <TextBlock Text="{Binding Name}" FontSize="18" Background="Yellow"/>
    <TextBlock Text="{Binding Description}" FontSize="12" Background="Orange"/>
</StackPanel>

This code also contains the data binding part which seems to use it’s own little language.

I found that these how-to articles and in particular this one about how to make data available for binding in XAML were quite useful in understanding how everything fits together.

The next step is to create the data template for one item.

<Window.Resources>
    <DataTemplate x:Key="itemTemplate" DataType="src:Item">
        <StackPanel Orientation="Vertical" Background="Green" Margin="10">
            <TextBlock Text="{Binding Name}" FontSize="18" Background="Yellow"/>
            <TextBlock Text="{Binding Description}" FontSize="12" Background="Orange"/>
        </StackPanel>
    </DataTemplate>
</Window.Resources>

The basic idea is to put the DataTemplate in the resources part of the application. I saw in some examples that people put these in a separate file, but I’ll do it in the same file for simplicity (and this is just a learning project anyway).

<DataTemplate x:Key="itemTemplate" DataType="src:Item">

The x:key part is used to give an identifier for the DataTemplate so you can later reference it and the DataType sets the object types that can be represented using this template.

This is where I stumbled I bit since there were different examples on the Internet: src:Something or local:Something or even c:Something. I couldn’t understand how and where are those defined.

I figured it out in the end after a bit of swearing. It looks like you should define it using XML namespaces (the xmlns part) like this: xmlns:src="clr-namespace:DiagnoseTry1". Only after you do this you can reference classes inside that namespace using this syntax: src:Item.

Here are all the puzzle pieces:

<!-- MainWindow.xaml -->
<Window x:Class="DiagnoseTry1.MainWindow"
      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
      xmlns:src="clr-namespace:DiagnoseTry1"
      Title="MainWindow" Height="350" Width="525">
<!-- other code -->
</Window>

// Item.cs
namespace DiagnoseTry1
{
    public class Item
    {
      // more code
    }
}

That’s why the DataType="src:Item" part works:

<DataTemplate x:Key="itemTemplate" DataType="src:Item">

Oh, by the way, in case you’re wondering: CLR is the Common Language Runtime, some kind of a virtual machine used to run .NET programs and it’s similar to the JVM (Java Virtual Machine).

So, probably I can extract a good practice here: to use the same XML namespace as CLR namespace. That means in my case I would need to use xmlns:DiagnoseTry1="clr-namespace:DiagnoseTry1" (besides coming up with better names for namespaces; at least for this project it doesn’t matter this much since I’m just learning).

And now here’s the part that uses the DataTemplate: ItemTemplate="{StaticResource itemTemplate}":

<ListBox x:Name="ItemListBox" Width="400" Margin="10"
         ItemsSource="{Binding items}"
         ItemTemplate="{StaticResource itemTemplate}">
</ListBox>

Now follows the part where I couldn’t find more walls where to bang my head. The binding to a list of items is simply done in XAML, just: ItemsSource="{Binding items}". It’s just that the binding doesn’t work without a DataContext. What follows is a hack due to not having enough knowledge to do it the right way in this post.

public partial class MainWindow : Window
{
    public List<Item> items { get; set; }

    public MainWindow()
    {
        InitializeComponent();
        items = GetItems();
        DataContext = this;
    }
}

Normally the DataContext should be set in XAML code, but this doesn’t work in MainWindow.xaml (it causes a StackOverflow exception):

<Window.DataContext>
    <src:MainWindow/>
</Window.DataContext>

If I set the DataContext from the C# code then it works:

DataContext = this;

After reading the explanation from the above mentioned StackOverflow post I understood that I have to use the MVVM pattern. So, the next part will focus on the MVVM pattern and how to use it in WPF.

Result for the first part

I know that this is pretty laughable, but this is what I got working for this first part:

Tips

Use CTRL + E, D to format the XAML and C# code.

Resources

Fluent Assertions

2014-02-09T00:00:00+00:00

One of the tricks I learned regarding writing unit tests is that sometimes it’s better to write your own assertion classes. Say you need to test the conversion of measurements.

Code we want to test

In this example we’re interested just to see how the tests end up looking so we’re not going to write any implementation code; we’ll just use a library for the actual conversion (jscience).

private double convert(double value, String fromUnit, String toUnit) {
    return Unit.valueOf(fromUnit)
            .getConverterTo(Unit.valueOf(toUnit))
            .convert(value);
}

Normal way

This is how we would normally write the tests. Just use the standard junit asserts.

public static final double DELTA = .01;

@Test
public void normalAsserts() throws Exception {
    double actualKilometres = convert(1000, "m", "km");
    assertEquals(1, actualKilometres, DELTA);

    double actualPounds = convert(1, "t", "lb");
    assertEquals(2204.62, actualPounds, DELTA);

    double actualGallons = convert(10, "L", "gal");
    assertEquals(2.64, actualGallons, DELTA);
}

Improved way

The normal way is ok in most cases, but we want to increase their readability and maintainability. One method of doing this is to make the tests describe as close as possible to English the behaviour we want to test.

@Test
public void improvedAsserts() throws Exception {
    assertThat(1000, "m").equals(1, "km");
    assertThat(1, "t").equals(2204.62, "lb");
    assertThat(10, "L").equals(2.64, "gal");
}

Let’s take a closer look at one of the asserts:

assertThat(1000, "m").equals(1, "km");

It reads almost as English (if you ignore the punctuation): “Assert that 1000 metres equals 1 kilometre”. Another thing to notice here is that the value and the unit are grouped together as a single concept which is not so clear in the first example. Of course, the unit and the value might be better in a separate class called Measurement or something like that.

How to do it?

The basic idea is to create a method assertThat that returns a new ConversionAssert and contains a method that does the actual verification.

private ConversionAssert assertThat(double value, String fromUnit) {
    return new ConversionAssert(value, fromUnit);
}

private class ConversionAssert {
    private final double value;
    private final String fromUnit;

    public ConversionAssert(double value, String fromUnit) {
        this.value = value;
        this.fromUnit = fromUnit;
    }

    public void equals(double expected, String toUnit) {
        double actual = convert(value, fromUnit, toUnit);
        String message = String.format("conversion from %f %s to %s", value, fromUnit, toUnit);
        assertEquals(message, expected, actual, DELTA);
    }
}

Resources

Pipe Viewer - the Linux flow meter

2013-12-25T00:00:00+00:00

Pipe viewer is just a flow meter for Linux command line programs.

It allows you to see the progress of a long running command. For example if you extract a big archive using tar you are left in the dark regarding how much was already extracted, how much is left and when it will finish. Pipe viewer adds a progress bar much like wget when it shows the download progress.

A simple example

igor@vm:~/temp$ pv archive.tar.gz | tar -xz
35MB 0:00:03 [10.3MB/s] [==========>                          ] 32% ETA 0:00:06

Explanation

Pipe viewer works very much like cat. Indeed, if you’ll replace pv with cat you’ll get exactly the same result, but without the progress indication. Here is the previous example, but this time using cat:

igor@vm:~/temp$ cat archive.tar.gz | tar -xz

Normally, in *nix systems all the command line programs are designed to read from standard-in and write to standard-out (stdin and stdout). This allows for a very cool trick: you can “pipe” (using the | operator) the output of a program into another program. This allows most of the *nix commands to focus on just one thing. This is the case with Pipe Viewer too: it just shows progress information, but the actual decompression (from the previous example) is done by a separate command: tar.

Perhaps it’s easier if you think about data flow: you have a long pipe (a real-world pipe), through one end you feed data and through the other end you get the processed data. You can consider each *nix program from the (software) pipe as a filter you put on the real-world pipe.

The simplest (software) “pipe” is cat which copies standard-in to standard-out and doesn’t do any transformations on the input data.

Other examples

Restoring a MySQL database dump

pv mysql-dump.sql | mysql -u root -p db-name

Copy big files locally

pv big-file.txt > /path/to/new/location

Copy big files from local to remote computer
This will create the archive first then pipe it to Pipe Viewer and send it to the remote computer using netcat (-l number means listen on port number - used on the server to listen for connections, -q number - after EOF on stdin, wait the specified number of seconds and then quit. If seconds is negative, wait forever).

# local (ip: 192.168.33.10)
tar -cf – /path/to/dir | pv | nc -l 12321 -q 5

# remote
nc 192.168.33.10 12321 | pv | tar -xf -

You’ll want to use this instead of scp (secure copy) when copying files on the internal network and you’re concerned only with getting a file as fast as possible on the new computer (using just the network, without external storage).

Using named pipe viewers

igor@vm:~/temp$ pv -N archive sql-dump.tar.gz | tar -xz
  archive: 23.6MB 0:00:02 [15.3MB/s] [====>                     ] 21% ETA 0:00:07

Using more than one pipe viewer

igor@vm:~/temp$ pv -cN reading sql-dump.tar.gz | \
    > tar -xz --to-stdout | \
    > pv -cN writing > sql-dump.sql
  reading: 63.1MB 0:00:05 [10.1MB/s] [=============>            ] 57% ETA 0:00:03
  writing: 69.2MB 0:00:05 [11.8MB/s] [   <=>                                    ]

How to create big files fast

If you want to follow along with the examples described here you’ll need some big files. One way is to find some files you already have or to generate some on the fly. This is how you can generate a file having 10 GB:

fallocate -l 10G big-file.bin

Resources

http://www.catonmat.net/blog/unix-utilities-pipe-viewer/
http://davedash.com/2009/09/16/getting-started-with-pipe-viewer/
http://securfox.wordpress.com/2009/07/03/pv-pipe-viewer/
http://www.ibm.com/developerworks/aix/library/au-spunix_pipeviewer/

phpmyadmin on ubuntu

2013-12-08T00:00:00+00:00

Installing phpmyadmin on Ubuntu can be a bit difficult for someone that doesn’t know how to configure apache (like me till now). I just executed the following command:

sudo apt-get update
sudo apt-get install phpmyadmin

and expected that when I navigate to http://localhost/phpmyadmin it would simply work. Actually, what I got was page not found :(

Proper way to configure apache

After a bit of googling here’s what I found out:

with the above 2 commands I just installed phpmyadmin,
what this means is that I only have the phpmyadmin files on my server,
I need to configure apache to tell it about the new phpmyadmin site location.

Apache has multiple ways of accomplishing this:

use the conf.d directory,
use the apache2.conf,
use the httpd.conf,
use the sites-available directory and a2ensite,
use the sites-enabled directory.

Not knowing what is the proper way of doing this I began looking for “best practices”. It seems that the conf.d directory is used for global apache configuration, the apache2.conf and httpd.conf provide defaults and they shouldn’t be normally touched and the sites-enabled directory should contain only symbolic links to files from the sites-available directory.

Activating phpmyadmin in apache

Ok, so now that we’ve eliminated all the “wrong” ways to do it only one way remains: using the sites-available and the a2ensite command.

But first: phpmyadmin already comes with an apache configuration and we need to just use it. This configuration is available in:

/etc/phpmyadmin/apache.conf

Now we need to put it in:

/etc/apache2/sites-available

To do this we’ll create a symbolic link:

sudo ln -s /etc/phpmyadmin/apache.conf /etc/apache2/sites-available/phpmyadmin.conf

The next step is to activate this new site using:

sudo a2ensite phpmyadmin.conf

This command will actually create a link from the sites-available to the sites-enabled directory.

The final step is to restart apache with the following command:

sudo /etc/init.d/apache2 restart

Navigate to http://localhost/phpmyadmin and enjoy!

Quick commands

sudo ln -s /etc/phpmyadmin/apache.conf
           /etc/apache2/sites-available/phpmyadmin.conf
sudo a2ensite phpmyadmin.conf
sudo /etc/init.d/apache2 restart

Vagrant and puppet

If you need a phpmyadmin server just execute these commands:

git clone https://github.com/sensui/vagrant-phpmyadmin.git
vagrant up

In a few moments you’ll have a phpmyadmin server running on: http://192.168.33.10/phpmyadmin/.

Here’s the puppet script that accomplishes what this post describes:

Exec { path => [ '/bin', '/sbin', '/usr/bin', '/usr/sbin', ] }

exec { 'system-update':
  command => 'sudo apt-get update',
}

Exec['system-update'] -> Package <| |>

package { 'phpmyadmin':
  ensure => present,
}

# linux way: ln -s /etc/phpmyadmin/apache.conf /etc/apache2/sites-available/phpmyadmin.conf
file { '/etc/apache2/sites-available/phpmyadmin.conf':
  ensure => link,
  target => '/etc/phpmyadmin/apache.conf',
  require => Package['phpmyadmin'],
}

exec { 'enable-phpmyadmin':
  command => 'sudo a2ensite phpmyadmin.conf',
  require => File['/etc/apache2/sites-available/phpmyadmin.conf'],
}

exec { 'restart-apache':
  command => 'sudo /etc/init.d/apache2 restart',
  require => Exec['enable-phpmyadmin'],
}

Resources

I found these links very helpful in my research:

Augeas, the configuration editor

2013-12-07T00:00:00+00:00

I just found a new interesting tool that can be used to edit configuration files. It’s so good that you can change some options without parsing the file. You just need to give it the file name and tell it to change a specific option.

If you’re on ubuntu you need to install it using the following command:

sudo apt-get install augeas-tools augeas-lenses

Printing properties

I recently wanted to enable the display_errors in php.ini in an automated way. To make things easier we’re just going to display the contents of the file. This is done using:

augtool print /files/etc/php5/apache2/php.ini

Notice I used the /files prefix before putting the full path of the file I want to access. That’s how it’s done in augeas.

Now, to show the property we’re interested in we need to run the following command:

augtool print /files/etc/php5/apache2/php.ini/PHP/display_errors

Here’s the output returned:

/files/etc/php5/apache2/php.ini/PHP/display_errors = "On"

Debugging

I tried the above command without luck for a while before I realized that my php.ini file had a mistake from a previous manual editing I’ve done. In this case augeas didn’t show any errors. It just didn’t show anything. So you have to be careful with this type of things. To actually see what was wrong with the file you’re trying to parse run this command:

augtool print /augeas//error

This will at least show the line number where the problem is.

Changing properties

Now that we know how to show the value of a property let’s see how can we change it, shall we? Run the augtool as root and set the display_errors configuration as shown below:

$ sudo augtool
augtool> set /files/etc/php5/apache2/php.ini/PHP/display_errors "Off"
augtool> save
Saved 1 file(s)
augtool> exit

If you get an error or something doesn’t work remember to run augtool print /augeas//error.

Lenses

Till now you probably have the impression that this augtool works only with php configuration files… Well, it actually works with any configuration file and here’s why… Augeas actually reads the file you give it and saves it into a tree based on a lense. This lense is actually a file containing regular expressions that identify each option for a specific configuration file. So we can have lenses for pretty much anything: cron, grub, hosts, mysql, passwd, ssh, xml, json, ini. Here’s a list with all the lenses that augeas comes with by default.

Puppet

If you happen to use puppet, here’s how to do it:

augeas { 'display_errors':
  context => '/files/etc/php5/apache2/php.ini',
  changes => [
    'set PHP/display_errors On',
  ]
}

More information

You can read more about augeas on the official website (although I didn’t find it particularly informative) and on this page that actually contains really good information: Augeas puppet documentation.

Vagrant and puppet kata

2013-12-02T00:00:00+00:00

OK, so maybe you’re wondering what’s all this post about… Well, kata means a kind of exercise used to learn something new. Vagrant is a command line wrapper for VirtualBox which is a tool to manage virtual machines.

Software development is pretty hard in general… one of the reasons why it’s so hard is because each project has a lot of external dependencies: the operating system, specific versions of libraries, the network, the database etc. One of the consequences of these dependencies is the so called works on my machine type of issues that almost always happens.

So, there’s a lot of stuff that can go wrong… How can we solve this, at least on the development side? Well, this is where vagrant comes into play! You create a virtual machine for your application and then automatically install all the dependencies. Now you test and develop only on that virtual machine. This has the advantage that it pins down everything you need for the project and that everyone uses the same environment. When you fix an issue on your machine you can be sure as hell that it’s solved once and for all!!! Besides this, if you’re working on multiple projects with conflicting dependencies (for example 2 projects requiring different versions of the same library or framework) you’ll have them both nicely separated and totally independent.

Requirements

Download and install: git, VirtualBox, vagrant and librarian-puppet. You should have at least basic knowledge of the command line (bash/zsh), although I still explain some of the commands and tricks I use.

In this kata, I’ll create a virtual machine with all the required software to run a basic php website (and I’ll also play with some of the puppet’s features).

OK, enough talk… let’s get to work!

The Vagrantfile

Create a git repository called vagrant-puppet-librarian-kata. Now cd into it (there’s a cool trick for this: type cd then press ALT+. and the previous command line argument will autocomplete so you don’t need to type it twice). Create a directory called provisioning so everything stays nicely grouped together. Create a Vagrantfile with the following contents:

Vagrant.configure('2') do |config|
  config.vm.box = 'precise32'
  config.vm.box_url = 'http://files.vagrantup.com/precise32.box'

  config.vm.define :node do |node|
    node.vm.hostname = 'node'
    node.vm.network :private_network, ip: '192.168.33.10'
    node.vm.synced_folder '../', '/var/www/vagrant'
    node.vm.provision :puppet do |puppet|
      puppet.module_path = [
        'modules/third-party',
        'modules/main',
      ]
      puppet.manifests_path = 'manifests'
      puppet.manifest_file = 'node.pp'
      puppet.facter = {
        'fqdn' => 'node.igorpopov.me'
      }
    end
  end
end

The Vagrantfile is just a ruby script with some DSL (Domain Specific Language) on top of it. This means that anything written in ruby will also work. Vagrant.configure('2') selects what version of the vagrant API you want to use. The next 2 lines (with config.vm.box*) describe what base operating system image we should use. We can choose from the VagrantBoxes website.

The next line defines a new node called :node and configures it in a ruby block. One particularly interesting feature is that we can set an ip address to this virtual machine. This means that when you start it you could use its ip address in your browser (if you have a web server installed).

Another interesting feature is that we can specify some folders to be synchronized between the host and the guest machine. For example you can set the project directory to be mapped to some directory on the virtual machine and in this case you can edit the project files on your machine using any editors you like and then have those files automatically syncronized on the guest machine.

The provisioning

The next lines configure the provisioning of the virtual machine. This is just a complicated word for automatic installation of software. For this kata, I’m using puppet. Puppet requires a manifest file that describes what we want installed on the machine. In our case, this file is manifests/node.pp. By the way, the puppet script is, just like the Vagrantfile, a ruby script (with a DSL on top).

Third party modules

Normally, in a programming language, you have libraries/jars/gems/dlls etc. that you want to use in your project. You also have them in puppet, but they are called modules. You can find them on the Puppet Forge. Let’s see how we can specify what third-party modules we need for our project…

Create a Puppetfile with the following contents:

forge 'http://forge.puppetlabs.com'

mod 'puppetlabs/apache'
mod 'example42/php'

We will use librarian-puppet to manage all the third party modules. Historically, adding third party puppet modules was done using git submodules which aren’t the best solution. First, because they are pretty complicated to use and second, because they just sit there in your repository. The most desirable solution would be to just add them as dependencies somewhere, but not include the actual source code in your repository. Librarian-puppet will do this for you. All you have to do is give it a Puppetfile that tells it what modules you need and librarian-puppet will go and download them for you.

Run the following command to change the directory where librarian-puppet puts the third-party modules (by default it’s modules):

librarian-puppet config --local path modules/third-party

This will save the configuration in the .librarian directory that you should add to source control. Then, to actually get the third party modules you declared in the Puppetfile you need to run:

librarian-puppet install --verbose

The --verbose flag is needed so that librarian-puppet actually tells it’s progress (by default you’ll only see that librarian-puppet hangs for 15 seconds without showing anything). This command will put all the downloaded modules in the modules/third-party directory (the one you’ve configured above).

Now, we need to create the required directories and we’ll use a very cool trick for this, called shell expansion. OK, so, this is the directory structure we need:

.
`-- provision
    |-- manifests
    `-- modules
        |-- main
        `-- third-party

Normally, we’d just do:

mkdir provision
mkdir provision/manifests
mkdir provision/modules
mkdir provision/modules/main
mkdir provision/modules/third-party

But there are a few tricks we could use. The mkdir command accepts a command line switch: -p that creates all the directories till the last one. So the above list of commands becomes:

mkdir -p provision/manifests
mkdir -p provision/modules/main
mkdir -p provision/modules/third-party

And there’s one more trick we can use: shell expansion! If we want to create multiple directories on the same level in the hierarchy we can use curly brackets and the shell will automatically expand them. The above example becomes:

mkdir -p provision/manifests
mkdir -p provision/modules/{main,third-party}

Next we need to create the provision/manifests/node.pp file:

Exec { path => [ '/bin', '/sbin', '/usr/bin', '/usr/sbin' ] }

exec { 'system-update':
  command => 'sudo apt-get update'
}

Exec['system-update'] -> Package <| |>

package {
  [ 'tree', 'git', 'vim', 'augeas-tools' ]:
  ensure => present,
}

user { 'igor': 
  ensure => present,
}

class { 'apache':
  mpm_module => 'prefork',
}

apache::vhost { $fqdn:
  priority => 14,
  port => 80,
  docroot => '/var/www/vagrant/labs',
}

include apache::mod::php
include php

Command paths

The first Exec statement tells puppet where to look on the disk when running commands. If we don’t do it here, we’ll need to prefix each command with it’s path and that’s not so nice…

Exec { path => ['/bin', '/sbin', '/usr/bin', '/usr/sbin'] }

Puppet resources

Before we advance, you should know about “puppet resources”. Among the most important ones are exec, package and service. All the resources have the following format:

resource-type { 'custom-resource-name':
  key1 => 'value1',
  key2 => 'value2',
}

Updating the system

The exec resource is used to tell puppet to execute a shell command on the virtual machine.

exec { 'system-update':
  command => 'sudo apt-get update'
}

The next thing tells puppet that before installing any package it should first update the list of packages available:

Exec['system-update'] -> Package <| |>

Messing around

Now we tell puppet that we want a list of packages installed:

package {
  [ 'tree', 'git', 'vim', 'augeas-tools' ]:
  ensure => present,
}

Let’s also create a new user, just for fun :)

user { 'igor': 
  ensure => present,
}

See? It was pretty simple, huh?

Configuring apache and php

Now, for the apache and php installation it’s a bit more complex. If we want both apache and php we need to activate the prefork option of the mpm_module. At least that’s how it was documented on the module’s main page. Next, we need to define a vhost. This will be used so apache knows what files it should use when we navigate to it. One thing I had difficulties with is that you should set a priority less than 15 if you want to use the port 80 or else your files won’t be taken into use. Now we also need to specify where are those files located. Remember that we configured a synced_folder in the Vagrantfile? This is where we’ll use it. As the docroot for the current vhost.

class { 'apache':
  mpm_module => 'prefork',
}

apache::vhost { $fqdn:
  priority => 14,
  port => 80,
  docroot => '/var/www/vagrant/labs',
}

Next, we need to activate the php module in apache and also include the php puppet module in the current script:

include apache::mod::php
include php

Starting the virtual machine

To start it, just run this command from the directory where the Vagrantfile is located: vagrant up. After vagrant starts the virtual machine it will provision it using the node.pp script I have described.

Check if apache and php are installed

Ok, now add a index.php file with the following content:

<?php
phpinfo();
?>

To check if everything is alright (in case you didn’t have errors from vagrant and/or puppet) you can use ping and curl in this way:

ping 192.168.33.10
curl 192.168.33.10

Resources

I have pushed the complete example (which may be a bit different) on github.

Motivation

I have done this kata more than 20 times (over the course of about 2 weeks), each time recording myself and reviewing my mistakes. In the beginning I made lots of mistakes and I researched a lot on the Internet even the trivial stuff.

Each time I have progressed bit by bit and now I can do this kata in about 17 minutes almost perfectly using only vim and the command line. I still make small typos which I fix pretty quickly. The first time I did it in about 40 minutes and I made lots of mistakes and did lots of research on the Internet.

This post will serve me as a reminder in case I forget some steps and why they are done… and maybe, just maybe, it will also help someone else.

I will also post somewhere the final video with me doing the kata.

Well, if you’re still reading, this concludes the explanations. If you have questions you can comment and ask clarifications.

Igor Popov

Asynchronous Programming in C#

WTF is asynchronous programming?

Synchronous vs Asynchronous

Multithreading

Concurrency vs Parallelism

When to use synchronous/asynchronous?

What is CPU bound?

What is I/O bound?

More details about CPU bound and I/O bound

Examples and comparison

The bad use of async I/O

The good use of async I/O

The good use of async CPU

How do I made an async method? And how do I use async/await?

.NET types with async methods

Recommendations from Lucian Wischik

Tips summarized

Source Code

Resources

Asynchronous programming in C# with WPF

Way of working

Starting out: the unresponsive app

Introducing the Task Parallel Library

Handling exceptions in tasks

async and await

Awaiting on multiple tasks

Source Code

Resources

Executing the right project in Visual Studio

The trick

C# Reflection API

The view model

The main program

Explanation

StringFormat in XAML

Simple StringFormat with binding escape

MultiBinding

TextBlock with Run text

Using StackPanel to group

Using Converter

Most common formatting specifiers

Resources

Visual Studio Productivity Tips & Tricks

Code snippets

1. svm - static void main

2. cw - Console.WriteLine

3. mbox - MessageBox.Show

4. prop & propfull - C# Properties

5. propdp & propa - Dependency Properties & Attached Properties

Keyboard shortcuts

The most potent shortcuts

Navigation shortcuts

Code handling

Personal favorite: quick fix

Personal favorite: expand/contract selection

Extensions

Mutation testing and the quest for quality

The Gilded Rose Kata

Code coverage

Partial test coverage

Full test coverage?!

Is the code actually tested?

How to break the production code?

Mutation testing concepts

Manual mutation testing

Automated mutation testing

Mutation testing - not a silver bullet

The Pyramid of Software Quality

Mutation testing and performance

Coverage and quality targets

Mutation testing tools

More on improving the code

Rocking with Jira’s Script Runner

How to develop your scripts

Code completion with IntelliJ IDEA

How to test your scripts

Creating a test project

The build script

Jira’s ComponentAccessor

The bad use of `async` I/O

The good use of `async` I/O

The good use of `async` CPU

1. `svm` - `static void main`

2. `cw` - `Console.WriteLine`

3. `mbox` - `MessageBox.Show`

4. `prop` & `propfull` - C# Properties

5. `propdp` & `propa` - Dependency Properties & Attached Properties

Jira’s `ComponentAccessor`

Now, why would you need that `ComponentAccessor`?

Updating issues with `ModifiedValue`

How can I do `this/that/whatever`?