My new Pluralsight course Personal Productivity & Performance Tools for Windows Developers “get more done in less time” has just been released.

It covers a range of developer-focused and general productivity tools that you can mix and match to suit your way of working.

“We’re constantly under pressure to be more productive. Learn how to use these tools to improve your productivity, streamline your workflows, and get more done in less time. ”

The course consists of:

• Reduce Typing with AutoHotkey
• LINQPad – A C# / VB.NET Scratchpad
• Starting Programs and Websites with SlickRun
• Take Control of your Clipboard with ClipX
• Remember What you Did with TimeSnapper
• Making the Internet Work for You with IFTTT
• Free Image Editing with Paint.NET

You can find this course along with my other courses on the Pluralsight author page.

SHARE:

The technique below is one technique, others exist, but the design goals of this approach are:

1. The ViewModel cannot know or reference the View
2. The ViewModel should should not care how the View displays or interacts with the user (it could be a dialog box, a flyout, etc.)
3. The ViewModel must be Portable Class Library compatible and View agnostic, e.g. not need to know about dialog buttons, etc.
4. Choices the user makes in the View dialog should result in Commands being executed on the ViewModel
5. The ViewModel must not specify the content of the message text, button labels, etc. – the View should be responsible for the text/content of the message

One way to think about these design goals is that the ViewModel is asking for some semantic message/dialog to be displayed in the View.

Defining a Message to be used with the MVVM Light Messenger

The way the ViewModel “tells” the View to create a dialog is by sending a message using the MVVM Light Messenger.

First we define a custom message:

using System.Windows.Input;
using GalaSoft.MvvmLight.Messaging;

namespace Project.Portable.ViewModel.Messages
{
    public class ShowDialogMessage : MessageBase
    {
        public ICommand Yes { get; set; }
        public ICommand No { get; set; }
        public ICommand Cancel { get; set; }
    }
}

This message allows us to define the commands that the view will call, based on the choice that the user makes in the dialog.

More...

SHARE:

The idea of "the power of three" is a universal concept; it can be seen anywhere from religion (The Holy Trinity, Triquetra, etc.) to childhood learning ("ABC", "123") to entertainment (The Three Musketeers, The Three Stooges, etc.) to project management (the scope-cost-schedule triangle).

One simple way to exploit the power of three is to define outcomes/wins/achievements. These "three wins" can be at any level:

• Three wins for the project
• Three wins for the year
• Three wins for the month
• Three wins for the week
• Three wins for today
  

The three chosen things should not be simple tasks to be ticked off, they should be things that feel like a "win" and give a real sense of progress and satisfaction.

The "wins" should be realistic and achievable.

Getting Results the Agile Way by J. D. Meier makes extensive use of the power of three with its "Monday Vision, Daily Outcomes, Friday Reflection" and three types of "Hot Spot".

The power of three can also be applied to individual items of work/features being developed, for example a feature can be evaluated by: user value, business value, technical value. In agile team retrospectives the power of three can be used to decide: what went well, what didn't go well, what will be improved upon in the next iteration.

(the above is an excerpt from my book Keeping Software Soft)

My 3 Wins for 2014

These are my 3 (professional) wins for 2014 (in no particular order):

• Retain my Microsoft MVP Award
• Produce 15 total Pluralsight courses
• Publish a minimum of 52 blog posts

While these aren’t my only wins for the year, they are things that I feel if I accomplish them, when I see in 2015 I can look back and be content.

It’s also important to be flexible with plans, if professional or personal events happen that mean I really can’t accomplish these then that’s ok: no plan survives contact with the enemy.

Make some time to think about and write down your 3 wins for 2014 and feel free to share them in the comments.

SHARE:

I recently self published my first book: Keeping Software Soft.

To do this I used Leanpub to “Publish early, publish often”. The idea behind this is that you can write a book in increments and publish in-progress versions as you add new content. For example, you could publish a new version of your eBook every time you add a new chapter.

You write your book manuscript using Markdown which is a plain text formatting style allowing the specification of headers, lists, etc.

When you publish a new version, Leanpub takes this Markdown and produces 3 eBook formats: PDF, EPUB, and MOBI.

Readers of you book can download any or all of these DRM free formats.

Once your book is complete, you can upload these formats to other distribution channels such as Amazon Kindle and NOOK& iBookstore via a service such as Lulu.

Check out my book Keeping Software Soft on either the Leanpub storefront or the Amazon Kindle store. (iBookstore and NOOK distribution are currently pending via Lulu)

SHARE:

I started 2013 by quitting my job, and during the remainder of the year I learned a lot, made the odd mistake, and accomplished a few things.

This is the obligatory end-of-year post, I hope it will inspire or be otherwise useful.

Accomplishments

• Published my first ever book: Keeping Software Soft
• Accepted as a Pluralsight author and produced 7 courses
• Awarded as a Microsoft MVP
• Wrote Windows Store and Windows Phone apps
• Won an Xbox One for publishing apps from a Microsoft Australia DPE competition
• Authored 88 blog posts for Don’t Code Tired

Failures

Even though it was very much a secondary goal, my 50 Apps By Christmas goal was not achieved. I finished the year with a total of 21 apps in-store. I decided to continue the challenge into 2014: 100 Apps By Christmas 2014. This is still a stretch goal as I have other plans for 2014, but it’s good to have these secondary stretch goals. I don’t feel bad for not having achieved this as I’m happy with the year overall.

Learnings

So here’s a few things I learned this year:

• If you’re not enjoying something 80% of the time then change it
• Don’t be afraid of what you haven’t failed at yet (“I have been through some terrible things in my life, some of which actually happened.” - Mark Twain)
• Think deeply about what your core belief is – for example I believe software should be easy to change
• Once you know what you believe in, compare that against your current situation/job/management/team/project – if your beliefs differ then change your situation: “change your employer or change your employer”
• Basic design/UX knowledge is quickly becoming an essential skill for developers to have – not that we have to be expert designers, but a little extra knowledge here goes a long way
• There’s always more about a language/platform to learn
• Try to be kind and positive online (Twitter, comments, etc.) even if you don’t always succeed
• Be flexible with plans
• Teaching other people is cool
• Believe in yourself and believe you can always get better
• Don’t be afraid that you don’t know everything – in our industry this is impossible
• Be proud of your accomplishments, however small
• There are always possibilities

Giving Thanks

In addition to all the early supporters of my book, commenters on this blog, and kind people of Twitter, I’d like to personally thank the following:

• The Perth .NET user group: especially Mike Minutillo for planting the subconscious seeds of becoming a Pluralsight author
• Gentry Riggen for being super supportive and always having kind words
• Scott Hanselman for teaching me things and always promoting kindness and respect
• The Windows Developer Show for always being entertaining and super positive
• Nick Hodge for support and opportunities (even though I couldn’t always take advantage of them)
• All my Twitter followers

So to end 2013, in the wise words of Bill and Ted:

SHARE:

By default, pressing CTRL-C while a console application is running will cause it to terminate.

If we want to prevent this we can set Console.TreatControlCAsInput Property to true. This will prevent CTRL-C from terminating the application. To terminate now, the user needs to close the console window or hit CTRL-BREAK instead of the more usual and well-known CTRL-C.

class Program
{
    private static void Main(string[] args)
    {
        Console.TreatControlCAsInput = true;
        while (true)
        {
        }
    }
}

There is also the Console.CancelKeyPress event. This event is fired whenever CTRL-C or CTRL-BREAK is pressed. It allows us to decide whether or not to terminate the application.

More...

SHARE:

Using the Console.SetIn Method allows us to specify an alternative source (TextReader stream).

For example suppose we have the following “names.txt” text file:

Sarah
Amrit
Gentry
Jack

We can create a new stream that reads from this file whenever we perform a Console.ReadLine(). Now when we call ReadLine, a line is read from the text file rather than the keyboard.

We can use the Console.OpenStandardInput() method to reset input back to the keyboard.

The code below creates the following output:

More...

SHARE:

So I’ve been running this series: 50 Apps by Christmas.

Currently I’ve got 29 new apps to create before Christmas 2013 (next week).

As I’m not going to hit this (my book has been a higher priority) I’ve decided to roll it up into a new self-challenge: 100 Apps By Christmas 2014, I’m going to call it “A Year Of Apps”.

This means I’ve effectively got to develop 71 new apps in about 53 weeks!!

One way I’m going to do this is to (by default) dual target apps for both Windows Phone and Windows Store – I count them as separate apps. By leveraging Portable Class Libraries for view models and shared code and by creating my “starter template” in Visual Studio 2013 I hope to decrease app dev times. I also intend to do some work around automating app icon design, about pages, etc. to further reduce “boilerplate” work. Hopefully I’ll be able to evolve these and release them as open source tools :)

SHARE:

If we have a longer running process taking place in a console application, it’s useful to be able to provide some feedback to the user so they know that the application hasn’t crashed. In a GUI application we’d use something like an animated progress bar or spinner. In a console application we can make use of the SetCursorPosition() method to keep the cursor in the same place while we output characters, to create a spinning animation.

While the code below could certainly be improved, it illustrates the point:

More...

SHARE:

In addition to doing some fun/weird/useful/annoying things in Console applications, we can also set foreground and background colours.

To set colours we use the Console.BackgroundColor and Console.ForegroundColor properties.

When we set these properties we supply a ConsoleColor. To reset the colours back to the defaults we can call the ResetColor() method.

using System;

namespace ConsoleColorDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Default initial color");

            Console.BackgroundColor = ConsoleColor.White;
            Console.ForegroundColor = ConsoleColor.Black;
            Console.WriteLine("Black on white");
            Console.WriteLine("Still black on white");

            Console.ResetColor();

            Console.WriteLine("Now back to defaults");

            Console.ReadLine();

        }
    }
}

The above code produces the following output:

More...

SHARE: