Programming Hints

Microsoft_vc_redist

2025-01-17T13:25:09-08:00

Not really a post about programming but an annoying thing from my own Windows machine.

I was getting an error about a missing Microsoft Visual C++ Runtime. It happened every time I launched a game and was also preventing me from installing different versions of the runtime. Said version appeared in the installed programs list but the installer wasn’t there and it couldn’t be uninstalled or repaired either.

Here’s the error message:

The feature you are trying to use is on a network resource that is unavaible.

The fix is to find and download the correct version from Visualstudio.com. You’ll need to create a free account to get access. The link is also on this knowledge base page

Once on my.visualstudio.com the version column in the search results unfortunately doesn’t match the version listed in the installer. In my case the installer was complaining about version 14.24.28127 being missing and this was visual C++ 2019 16.4 x86. Infurating that the version in the search results isn’t the actual version.

Writing

2022-03-12T10:14:46-08:00

Today’s article is all about the importance of writing and its usefulness in advancing your career. Clear writing in a work context is even more important now for those who are working remotely.

It might be time for me to start making updates to this blog again - out of self-interest if for no other reason. I have been collecting topics and ideas to write about, I’ve just lacked motivation to put hands to keyboard.

If You Need a Laugh

2020-05-13T04:00:00+00:00

This is an accurate and humorous take on most technology blogs. Except for this fine website.

We're Back

2018-03-27T19:22:00+00:00

My hosting provider decided to migrate my account to a new machine. Something got mucked up in the migration causing this blog to no longer work properly. I guess the lesson here is to always test your deployments, even if it’s someone else making the deployment on your behalf.

Software Developer Interviews Suck

2017-02-27T00:18:00+00:00

Interviewing for a software engineering role is more onerous than interviewing for any other profession. Interviewing for most non-software professional jobs typically consists of a phone screen and one to two interviews on site, where you talk about what you did in previous jobs. At no point during are you asked to demonstrate any skills, you’re trusted as an adult that you’re telling the truth about your experience and qualifications.

Interviewing for a software job typically involves 1 phone screen with HR or the recruiter, 1 technical phone screen and possibly a programming task to complete in 1-4 hours of your own time. If successful at all of the above then you can go onsite for a whole day of interviews - yes, you will need to use annual leave at your current job. During some of the onsite interview rounds you solve esoteric coding problems on the whiteboard. In the other rounds you will be expected to design scalable software systems in 45 minutes that are similar to ones that the company has literally spent hundreds or thousands of developer hours iterating on the design.

This video expresses my frustration with the interview process as a software developer.

User Data

2016-05-17T05:47:00+00:00

Here’s a talk that I watched recently and found deeply troubling and thought provoking: Haunted by Data - Maciej Ceglowski (text/image version). The speaker raises the ethical dilemmas with user data collection, retention, governance and overuse that is prevalent throughout the computing industry. The challenge is to end our addiction to collecting and storing user data.

Here’s another post on the related topic of the web being “subsidized” by advertising. It’s related because internet advertising relies on the user data harvested when we do anything online. Also worth reading and thinking about.

Scala's Expressive Power

2016-02-20T05:57:00+00:00

I saw the following puzzle the other day. Given a set of rings, can you place the numbers 1 through 9 inside each closed area so that the sum of the numbers in each circle is the same?

The 1 was already placed for you.

Because I’m trying to learn Scala, I thought writing a program to solve this would be good practice for me. I assume that the numbers in each closed area are stored in an Array with elements in the array corresponding to the closed areas from left to right.

def isValid(values: IndexedSeq[Int]) = {
val target = values.take(2).sum
values.slice(1, 4).sum == target &&
values.slice(3, 6).sum == target &&
values.slice(5, 8).sum == target &&
values.slice(7, 9).sum == target
}

This was dead easy to write. It’s just encoding the solved condition from the question. Next was the tricky part – going through all permutations of 2 to 9 with 1 in a fixed place until we arrived at an answer. I remember writing code to generate all permutations once as an interview question and it isn’t easy. You have to write a complicated recursive function to generate the permutations.

Thankfully a few minutes spent in the ScalaDoc allowed me to use some of the powerful functions provided by Scala out of the box. Here’s code to solve the problem in a handful of lines.

val available = 2 to 9
for (perm <- available.permutations) {
val values = (perm.take(3) :+ 1) ++: perm.drop(3)
if (isValid(values)) {
println("Winner:")
println(values.mkString(", "))
}
}

Yes, there’s a function to give you all permutations of a sequence. The :+ and ++: are operators that join an element to a sequence and join two sequences respectively.

If you want the answer you’ll have to download Scala and run the above program. Or you can try solving it yourself in the language of your choice.

Best Firefox Addons

2015-10-10T03:46:00+00:00

Long time, no post. I’ve had plenty of ideas for topics to write about, but for one reason or another I’ve always put off actually sitting down and writing the post. Call it procrastination, call it finding better things to do with my spare time - whatever the excuse I’ve made them all.

Seeing as I’m paying for the domain name and hosting, I might as well post occasionally. Will this be a one off or will I get into a regular cadence of updates? Only time will tell.

The actual topic of the post is my favourite Firefox add-ons. I was prompted to list them here because I recently reset my Firefox install and it took me a while to find the best add-on.

Here is my must-have list:

Tree Style Tab - this is the best add-on ever. It arranges your tabs down the left hand side of the browser and nests them like the old tree view in windows explorer. This is surprisingly impossible to find with Firefox’s add-ons search even if you type the exact name.
ublock origin - ad blocking. The web is so much more pleasant to read without popup ads everywhere and blinking gifs on the side of your article. I previously used Adblock Edge but support for that has been discontinued.
LastPass - I can’t do without my password manager. If LastPass isn’t right for you then find one that is, but in 2015 you should be using one of these.
Add Dictionaries - unless you’re happy with the default en-US of course.

2022 Update

Firebug (a great website debuging tool in the early 2010s) was on the original list in 2015 but it looks like it no longer exists. The inbuilt Firefox developer tools are really good these days.

This is my only post that ever got a non-spam comment on the old Wordpress programming-hints. A poster called Daniel wrote:

Oh, you forgot “I don’t care about cookies” addon which removes EU cookie warnings. Must have.

I’m not sure I agree though. I usually don’t click accept and instead find the option that downloads the least cookies when presented with the cookie annoying popups.

Arduino - Loading Strings from Flash Memory

2014-12-22T06:42:00+00:00

I got out my Arduino board for the first time in a while for a Christmas themed project. More on that in another post. This post is about loading strings from the Arduino’s flash memory, aka program memory, aka PROGMEM.

There is an example in the PROGMEM link above, but it’s kinda ugly. Here’s the main points from their example code:

// set up strings
prog_char string_0[] PROGMEM = "String 0"; // "String 0" etc are strings to store - change to suit.
prog_char string_1[] PROGMEM = "String 1";
// Then set up a table to refer to your strings.
PROGMEM const char *string_table[] = // change "string_table" name to suit
{
string_0,
string_1
};
// loading string
strcpy_P(buffer, (char*)pgm_read_word(&(string_table[i]))); // Necessary casts and dereferencing, just copy.

I don’t like the fact that they create global variables called string_N then load them in an array of a different type and reference the variables by array index later. It all seems rather unnecessary.

It seemed like there should be a more straight-forward way of doing things and after reading the header file and playing around for a few minutes, here’s what I came up with:

// create strings in flash memory
const prog_char STRING_WISH[] PROGMEM = "Have";
const prog_char STRING_YOU[] PROGMEM = " a";
const prog_char STRING_MERRY[] PROGMEM = "Merry";
const prog_char STRING_XMAS[] PROGMEM = "Xmas!";
// example reading strings
char firstLine[6];
char secondLine[6];
char thirdLine[6];
char fourthLine[6];
strcpy_P(firstLine, STRING_WISH);
strcpy_P(secondLine, STRING_YOU);
strcpy_P(thirdLine, STRING_MERRY);
strcpy_P(fourthLine, STRING_XMAS);

Unfortunately global variables are still required. At least I’ve given them sensible names (STRING_WISH was initially the word ‘wish’ but I later decided ‘have’ sounded better). Loading the strings from program memory into RAM doesn’t require any manipulation of the arguments. No need to remember “magic” array indices or for type casting or unnecessary calls to pgm_read_word.

A more organic approach to Object-Oriented design

2014-11-23T10:43:00+00:00

Today’s article I’d like to share with you is: Semantic Compression.

The title doesn’t say much about the content of the article to someone who hasn’t read it, so I’ll give a brief overview.

The author demonstrates his approach to object-oriented design through a very detailed programming example. Instead of starting with a design based on real world entities, he argues that you should start by adding the features you need in procedural style code. Every time you start repeating yourself, you’ll be able to see what the repetition has in common. It’s only when you have two or more concrete examples of repetition hat you can then make design choices about re-use through classes and functions.

By programming in this manner you avoid designing too much flexibility too soon. You create just the abstractions you need instead of over-engineering your code based on a design that doesn’t match the goals of your program. Having worked on a recent project in a similar manner, I can say that I’m in agreement with the author. This approach to programming seems to be quite effective.

Python Config Files with Lists and Dictionaries

2014-11-16T01:25:00+00:00

A common problem with configuration files is that they only allow simple values like strings, integers, doubles. It’s not uncommon to want to include more complex values such as a list or dictionary in your config.

The most elegant approach I’ve seen for doing this in python is to make use of the json library to parse the values. First I’ll load an example config file using python’s SafeConfigParser. Typically your config would be in a separate file, however for the purposes of this blog post I’ll use a multi-line string.

>>> from configparser import SafeConfigParser
>>> import json
>>> config_text = """
[examples]
list_example=[1,2,3,4]
dict_example={"foo":1, "bar":2}
"""
>>> parser = SafeConfigParser()
>>> parser.read_string(config_text)
>>> parser.items("examples")
[('list_sample', '[1,2,3,4]'), ('map_example', '{"foo":1, "bar":2}')]

The list of tuples returned by ConfigParser.items(section) can be tricky to work with, unless you were planning to iterate through all values in the config file. I find it easier to convert the list into a dictionary, which is simple in python:

config = dict(parser.items("examples"))

Now that we have a dictionary which maps keys in the config file to their values, you can use json.loads(str) to convert values from strings to a list or dictionary. The operations after calling json.loads in the next part of my interpreter session are to demonstrate that these objects are actually a real python list and dictionary.

>>> config
{'list_example': '[1,2,3,4]', 'dict_example': '{"foo":1, "bar":2}'}
>>> list_example = json.loads(config['list_example'])
>>> list_example
[1, 2, 3, 4]
>>> list_example[2]
3
>>> list_example[:3]
[1, 2, 3]
>>> 5 in list_example
False
>>> dict_example = json.loads(config['dict_example'])
>>> dict_example
{'bar': 2, 'foo': 1}
>>> dict_example['foo']
1
>>> 'bar' in dict_example
True

Postgres Full Text Search Tutorial

2014-10-21T00:39:00+00:00

Today’s linked article gives a very in depth introduction to doing full text search in Postgres. The author demonstrates everything with numerous code examples. Their assertion is that for smaller projects, postgres provides all the features you need and you won’t require a more specialized search system.

February 2022 updated: I replaced the original link with the Wayback Machine due to the original website no longer existing.

NUnit & Parameterized Tests

2014-10-15T03:16:00+00:00

What is NUnit and why use it?

NUnit is a .NET port of the popular JUnit test library for Java. It has several advantages that Microsoft’s test framework doesn’t.

If you run MS Tests or NUnit tests in visual studio then all your tests appear as a flat list in the test explorer. You only get the method names. If you use the NUnit runner you get the full namespace/class/method hierarchy as seen in the screenshot below.

An extension is required to run NUnit tests in Visual Studio. Go to Tools → Extensions and Updates, then search for “NUnit Test Adapter” and install it.

The final difference to MS Tests is that you can write your tests in the same assembly as your production code. Microsoft enforces separating tests into a different library. Naturally, you can always put your NUnit tests in a separate test dll if you prefer that separation.

Parameterized Tests

One useful feature in NUnit is the ability to easily add parameters to a test case. This lets you write a single test and call it with a several sets of input data. Probably the best way to demonstrate this is with a (contrived) example.

Say you have a Calculator class that you’re wanting to test. The usual way of testing the Add function would be to write a number of test cases which call Add with different values:

[Test]
public void TestAddOneAndOne()
{
Assert.AreEqual(2, calculator.Add(1, 1));
}
// ... more [Test] methods follow for different arguments.

Parameterized tests with the TestCase attribute allow you to write all the different argument combinations concisely:

[TestCase(1, 1, 2)]
[TestCase(2, 3, 5)]
[TestCase(-10, 24, 14)]
public void TestAdd(int arg1, int arg2, int expectedResult)
{
Assert.AreEqual(expectedResult, calculator.Add(arg1, arg2));
}

Each TestCase runs this method once, passing in the arguments specified. See the previous NUnit runner screenshot for how these test cases appear when run. See the TestCase documentation for more information.

Parameterized tests in JUnit

When I started writing this post, I was originally planning to say that parameterized tests are something NUnit has that JUnit doesn’t, but a quick search showed that JUnit also has parameterized tests. The real difference between the NUnit and JUnit implementation is that the syntax is quite messy in JUnit. I’ve never seen any parameterized tests in any JUnit code I’ve worked on. In contrast, the NUnit syntax is clean and much easier to remember and I have made use of it in a few projects now.

Development Process

2014-10-10T19:11:00+00:00

I highly recommend having a read through this talk: Move Fast and Break Nothing. There are some great ideas in it on continuous development, testing, communication and learning/teaching on the job. Well worth the time to read through and think about whether you can apply some of the points in it to your work.

A note about this blog: I’m going to try and get into a more regular cadence of posts. If you see the gap in the history from May to August it’s because I was in the process of moving overseas. I’m well and truly settled into my new home now so I have no excuse for sporadic updates [Ed (2022): this didn’t happen].

Tailing Logs with less

2014-09-22T05:46:00+00:00

less is already an incredibly useful command in linux (GNU/linux for the purists). It’s a better version of more, for paging through files. One not so well known switch for less is the following:

less +F [file]

The +F option tails the end of the log. Updating when the log changes is buffered, so depending on how noisy your log file is there may be some delay in seeing updates.

At any time when less is in tailing mode you can hit CTRL+C to return to regular less. The status bar reminds you of this with a message like interrupt to abort. This feature is incredibly powerful, for example if something at the bottom of the log catches your eye and you want to stop tailing for a moment so you can check the logs around it.

In regular-mode less, pressing shift+F will put you into tailing mode. This is true even if you started less without the +F option.

Setting the time zone in C#.NET

2014-04-03T21:31:00+00:00

DateTimes in .NET are always in one of two timezones - UTC or local time. This advice will make your life easier:

Always store DateTimes in UTC.

Unfortunately sometimes we need to deal with timezones stored in a timezone other than UTC. Maybe we’ve inherited a system or we’re integrating with another system which doesn’t save as UTC. If your web server and database server are both in the same timezone and the DateTime is stored in the server’s local timezone then everything is still OK. You can easily convert back to UTC or if the users are in the same timezone you don’t need to do any conversion.

What happens when the DateTime stored in the database isn’t in UTC or the server’s local timezone? If you know the timezone then you can convert the DateTime to UTC using code similar to the following. Once you’ve converted to UTC then you can work with it as usual.

 /// <summary>
/// Convert a DateTime in a specified timezone to UTC.
/// </summary>
/// <param name="timeZoneId">
/// For valid IDs see: http://msdn.microsoft.com/en-us/library/cc749073.aspx
///</param>
private DateTime GetUtcDateTimeForTimezone(DateTime dateTime, string timeZoneId)
{
TimeZoneInfo tzi = TimeZoneInfo.FindSystemTimeZoneById(timeZoneId);
DateTimeOffset dto = new DateTimeOffset(dateTime, tzi.GetUtcOffset(dateTime));
return new DateTime(dto.ToUniversalTime().DateTime.Ticks, DateTimeKind.Utc);
}

As the comment in the above code mentions, a list of all available time zones can be found here.

Error Logging with log4net

2014-03-21T11:44:00+00:00

When handling errors you want to do one of the following:

Crash the program.
Ignore the error.
Try to fix the error and continue.

The correct approach depends on a number of factors. What is your application? Do you have enough information available to try and recover or infer what the user wanted to do? Is the error going to impact other operations later on? No matter which approach you choose for handling the error, you ought to use logging!

At my current job there are two fairly complicated systems I’m responsible for maintaining. The older of the two has no logging. When something goes wrong it is hard to find out what happened and sometimes it has been downright impossible! I should note that I didn’t write this system although I have become familiar with the code.

The newer system, which I wrote, has excellent logging thanks to log4net. A quick scan of the log file allows me to pinpoint the cause of errors. It also enables me to display a generic error message to users (it’s a web application) and keep the stack traces and unfriendly developer jargon away from them.

Now that I’ve explained the need for logging and the benefits to using it, let’s look at how I you can do the same with log4net.

Firstly you import the log4net dependency with NuGet. Once imported, copy and paste the following line into the top of any classes which you want to add logging to. N.B. I’ve split it into two for readability here.

private static readonly log4net.ILog log = log4net.LogManager.GetLogger(
System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

This line is exactly the same in each file. The magic is using reflection to get the name of the current class. In the original log4j you have to copy, paste then remember to update the type name in each file.

Once you have a log variable defined, writing log output is as simple as calling one of the logging methods. log4net supports 4 levels of logging: Error, Warn, Info, Debug. For each level there are several overloads. There is also a *Format version which allows for formatted parameters similar to String.Format. Here is an example of error logging from an MVC application. I’m overriding the default error handler so any uncaught exceptions in my application are logged with log4net.

 /// <summary>
/// Override of the default MVC HandleErrorAttribute which writes the exception message to log4net.
/// </summary>
public class MyHandleErrorAttribute : HandleErrorAttribute
{
private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
public override void OnException(ExceptionContext filterContext)
{
log.Error("An uncaught exception has occurred", filterContext.Exception);
if (filterContext.HttpContext.User.Identity.IsAuthenticated)
{
log.ErrorFormat("The currently logged in user is '{0}'", filterContext.HttpContext.User.Identity.Name);
}
base.OnException(filterContext);
}
}

Choosing where to write your logs is achieved by adding a few lines to your (App|Web).config file. You can define any number of appenders and log4net has support for many different places to output your logs. In the example below I’m writing the log output to a file which changes daily and to the debug stream - great when developing because it appears in my IDE.

 <configSections>
<section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" requirePermission="false" />
</configSections>
<log4net>
<appender name="Debug" type="log4net.Appender.DebugAppender">
<layout type="log4net.Layout.PatternLayout">
<conversionPattern value="%date %level %thread %logger - %message%newline" />
</layout>
</appender>
<appender name="RollingFile" type="log4net.Appender.RollingFileAppender">
<file value="LogFiles\file.log" />
<appendToFile value="true" />
<layout type="log4net.Layout.PatternLayout">
<conversionPattern value="%date %level %thread %logger - %message%newline" />
</layout>
</appender>
<root>
<level value="DEBUG" />
<appender-ref ref="RollingFile" />
<appender-ref ref="Debug" />
</root>
</log4net>

Changing the level of logging is as simple as changing the value of the level tag from DEBUG to WARN. At the moment I’m using DEBUG for development and testing and using INFO or WARN in the production environment. The advantage of having this in a config file is that you can change the logging output and level while the application is running.

Obviously this post is only an introduction. Great documentation and more examples can be found at the official log4net website.

Hello World

2014-03-07T06:32:00+00:00

To introduce my blog, I present to you the simplest hello world program of all.

print("hello, world")