Newcomer’s Guide to West Coast Swing Competition Points

When I was a new dancer, I found the WCS points and scoring system to be pretty opaque and hard to understand:

Yep, all these numbers make total sense!

Yep, all those numbers totally make sense

Lately I’ve been thinking about scoring in the WCS community a lot. I’ve had some friends, both new and experienced in the community express confusion at the scoring systems in conversation with me. And I’ve also recently started working on an open-source project to create a free code implementation of the WSDC Relative Placement Scoring System.

As a result, I’ve come to appreciate the way that the judging and points system shapes our community, and think that it is a pretty good solution to the insanely difficult problem of turning subjective opinions of dancing into skill levels and numeric contest results that make sense from event to event.

So, without further ado, here is everything you need to know about scoring in West Coast Swing!

What Are Points?

The World Swing Dance Council (WSDC) uses points as a guideline for event directors to place competitiors according to their skill level. Each skill level defined by the WSDC has certain point requirements for its participants. The full details are explained in their Points Registry Document, but I will summarize the highlights here:

Skill Level Description
Newcomer Beginner, must have earned no points. You may skip ahead to Novice if you prefer.
Novice Competitors must compete in Novice until they earn 16 Novice points. At 30 points, you must begin competing in Intermediate.
Intermediate May move to Advanced with 30 Intermediate points.
Must move to Advanced with 45 Intermediate points.
Advanced May move to All Star with 45 Advanced points in the last 36 months.
Must move to All Star with 60 points in the last 36 months.
All Star Must have either 45 Advanced points in the last 36 months, or 3 All Star points in the last 36 months.
Champion/Invitational/Pro Determined by the event director.

In addition, the WSDC defines two additional competition categories which are defined by age. Juniors is for competitiors under 18 years old, while Masters is for competitiors over 50.

How Do I Know How Many Points I Have?

You can search for your own point total (or any of your friends/role models!) by name in the World Swing Dance Council Points Registry.

It can be pretty neat to look at someone’s points after they have competed for a while, it tells part of the story of their career and experiences in the WCS world!

How Many Points Do I Get For Competing?

WSDC points are awarded based on both your placement in the competition, as well as the number of competitors in your skill level/role. Larger events award more points for the same placement, since there are more competitors. The WSDC defines six tiers of competition:

Tier # of Competitors 1st Place 2nd Place 3rd Place 4th Place 5th Place Additional Placements
Tier 1 5-10 3 2 1 0 0 0
Tier 2 11-19 6 4 3 2 1 0
Tier 3 20-39 10 8 6 4 2 1pt (up to 12th Place)
Tier 4 40-79 15 12 10 8 6 1pt (up to 15th Place)
Tier 5 80-129 20 16 14 12 10 2pt (up to 12th Place)
Tier 6 130+ 25 22 18 15 12 2pt (up to 12th Place)

Note that the same skill level competition may be in two different tiers for leaders and follows. For instance, if a competition has 39 leaders, and 40 follows, it will award points according to the tier 3 rules for leaders, but follows will get points according to the tier 4 rules, even though they compete and are judged as a couple in finals.

How Do I Get To Finals?

This differs a bit from event to event, and is influenced to some extent by the head judge’s preferences. But the general rule for prelims and semi-finals is that the judges are asked to award each competitor individually (not couple!) a Yes, No, or Maybe/Alternate vote. The number of “Yes” votes each judge can award is usually equal to the number of competitiors which will be in the next round of the competition. For example, if the judges are judging prelims, and semi-finals will have 30 couples, each judge may award 30 “Yes” votes, and then select 3 alternates.

The competitiors with the most Yes/Alternate votes progress to the next round.

I Made Finals! Now What?

Congratulations! When looking at the final results, it can be pretty confusing your first time when one judge places you first, and another places you 10th. How do they figure out which place you actually get? This is where the Relative Placement Scoring System comes in!

The Relative Placement Scoring System is described by the WSDC in a very detailed document you can read here.

In short, an odd number of judges rank every couple in the finals from first place to last. Having an odd number of judges is important, because placements are awarded based on having a majority of judges scoring you at or above a particular placement. Then, once all of the judges’ scores are tallied, the final placements are awarded in rounds.

  • First, each competitor’s 1st place scores are added up, and if any couple has a majority, they are awarded first place.
  • If no couple had a majority of judges who placed them 1st, then we look at every couple’s 1st and 2nd placements. If a couple has a majority, then they are awarded first.
  • This repeats for 1st through 3rd, 1st through 4th, and so on until all placements are awarded.
  • In the event of a tie in a particular round, there are several ways of resolving the tie:
  • If a couple has a larger majority of judges who placed them at or better than the current round, they win. For example, if there are 7 judges, 4 are needed for a majority. If one couple has 5 placements in the current round, and another has only 4, the first couple recieves the best available final placement, and the second couple is placed just behind them.
  • If a couple have an identical majority, (4 and 4, for example) then the numerical values of their placements are compared. Let’s consider two couples who both have four judges who awarded them 1st-2nd place. If one couple has three first places and a second (1+1+1+2=5), while the other couple had two second places and two first places(1+1+2+2=6), the first couple would win because the sum of their 1st and 2nd places was lower.
  • There are several more methods of breaking ties, but the two listed above resolve the vast majority of ties in any given round. If you’re interested to know more, you can read the document linked above for all of the gory details!

Once you have your final placement, then you may be awarded points, according to the tier of your event.

The Head Judge Gave Me a Good Placement, But I Didn’t Finish Well. What Happened?

In the WSDC Relative Placement Scoring System, the head judge’s scores are only used when another judge’s scores cannot be used. For example if a judge accidentally awards two couples first place, or if they feel ill during judging and are unable to finish, their scores may be discarded and replaced with those of the head judge.

The title “head judge” makes it sound like their scores would carry more weight than the other judges, but in reality, the head judge’s scores are usually not used in determining the final placements at all.

Many events will only publish the placements from judges whose scores were used in the final determination, while others include the head judge’s scores, to allow competitiors to see all of the judges’ opinions on their performance.

Sometimes I See Competitiors Competing in Skill Levels They Don’t Have Points For. What Gives?

The WSDC allows competitiors to petition to dance one level above or below their official level. This is generally left to the discretion of the head judge at the event, but there are many reasons for competitiors to seek to dance in another skill level.

  • An instructor who has never competed in WCS before may not wish to compete against their own students in Novice, which could be demoralizing for the students.
  • An Advanced dancer who has taken a long (several years) break from dancing due to life changes or injury, and wishes to compete at an Intermediate level to get back into the groove of competition.
  • A competitior who competes well at WCS events which are not recognized by the WSDC and don’t award points may feel confident dancing “up” a level in an official WSDC competition based on their past performance.


That’s a pretty good rundown of the rules of competition in the WCS world. Let me know in the comments if you have any other questions about WCS points and judging that I haven’t answered, and I’ll add them to this article!

Versioning NPM Packages in TFS

So I recently needed to build an NPM package with TFS, and wanted the version number to be updated automatically on build. But after searching, I couldn’t find a good example of how to do it, and TFS seemed to have no tools built in to help.

So I finally I just wrote a simple Powershell script to handle it, and wanted to reproduce it here for the benefit of others who have the same issue:

$a = Get-Content 'package.json' -raw | ConvertFrom-Json
$a.version=$a.version.Substring(0, $a.version.LastIndexOf(\".\")) + \".\" + $env:BUILD_BUILDID
$a | ConvertTo-Json  | set-content 'package.json'

Or, if you use GitVersion like we do, after running the GitVersion build step, you will have new environment variables with version numbers in different formats available, which can be used like so:

$a = Get-Content 'package.json' -raw | ConvertFrom-Json
$a.version = $env:GITVERSION_NuGetVersion
$a | ConvertTo-Json  | set-content 'package.json'

Hope this helps anyone trying to build and publish NPM packages as part of a TFS build!

Firefly: Out of Order

Recently, I was attempting to consolidate my media collection onto my home PLEX server (which I really like!) In the process, I attempted to copy over all episodes of Firefly from the series’ Blu-Ray release, and upon doing so, found that they were in a completely incorrect order.

I assumed the mistake was on my end at first, but after doing some research, it seems that the reason for this is that FOX did not originally air the series in the correct order. For example, the 2-hour Pilot episode meant to introduce all of the characters was the 11th episode they aired (which probably has something to do with how such a wonderful show got cancelled, but don’t worry it’s fine I’m not bitter or anything I just think we need some time apart, FOX, I’ll be staying with my parents this weekend, you watch the kids.)

Later, the series was released on disc in the intended order, but this meant that the database used by PLEX to determine the names and order of episodes, TVDB, had to make a decision: which order was right? In this case it seems that they decided to go with FOX’s order, but that isn’t the order I wanted my collection to play in.

So to help out anyone else who encounters this strange discrepancy, below is a table of the episodes, listed in the order they appeared on the Blu-Ray release of the series, with their originally aired order (to which PLEX defaults) noted. Simply add the series to your PLEX server and then create a playlist with the episodes in the right order if you want to watch the whole series all the way through!

Blu-Ray Episode # Title Originally Aired #
1 Serenity (Parts 1 & 2) 11
2 The Train Job 1
3 Bushwhacked 2
4 Shindig 6
5 Safe 7
6 Our Mrs. Reynolds 3
7 Jaynestown 4
8 Out of Gas 5
9 Ariel 8
10 War Stories 9
11 Trash 13
12 The Message 14
13 Heart of Gold 12
14 Objects in Space 10

Commonly Misused Programming Terms

One big challenge I often see new programmers struggle with early in their careers is that they often don’t know the correct vocabulary to describe the things they deal with in code.  As a result, often times a lot gets lost in communication when they misuse words while talking to senior programmers, because they are effectively describing something different from what they mean.

A few years into my career, I noticed that I was using certain words interchangeably when describing things without really understanding the difference between them. So I started trying to research each term I felt I didn’t fully understand and get into the habit of using it correctly as much as possible.

As I began to learn the difference between various terms, I realized something: the senior programmers on my team always used terminology correctly, while junior programmers did not. Furthermore, the junior programmers were often inadvertently describing things that were either nonsensical or simply wrong by accidentally using the wrong words to describe the code constructs they saw. While it is often possible for people to infer your intention from the context of what you’re describing, it is worth making an effort to use the most correct terminology possible so that you can avoid the possibility miscommunication with your fellow programmers.

This blog will be a quick overview of a few terms which I commonly hear misused or misunderstood by junior programmers, in the hopes of helping people communicate themselves more effectively to their coworkers! The terms will mostly be ones relevant to modern Object-Oriented Programming, and I’ll include code examples in C#, but I think that you will find that there is a lot of cross-over between various languages.

Field versus Property:

The following code example defines one Field and two Properties:


Fields are local values defined on a class which, when on the left-hand side of an assignment statement, do not execute any logic, as they have no concept of a getter or setter. Properties, on the other hand, execute some logic during assignment statements that you can either leave with default values by using auto-properties, as in the property named AutoProperty, or can have custom logic defined for their getters and setters, as in the example named CustomProperty.

One important difference to note: since interfaces can only include methods, interfaces cannot expose Fields. They can, however, expose the getters and setters of Properties.

Class versus Object:


The two small code snippets in this screenshot demonstrate the difference between a Class and an Object. Classes are definitions of a data structure which expose a constructor we can invoke in order to create instances of that data structure. An Object is a single instance of a Class. To put it another way: Objects have a point in your code where they are created, then exist until they are eventually cleaned up by the garbage collector when they are no longer referenced. Classes exist at all times after compilation, and are used to create Object instances.

Interface versus Implementation versus Inheritance


Here we see examples of Inheritance, an Interface, and the Interface’s Implementation. An Interface is simply a definition of a collection of methods made publicly available by any class that Implements the Interface. Our Interface declares a single public method named Subtract which takes two integer arguments. But you will notice that IInterface does not define any method body for this method. The method body must instead be defined by any class that chooses to Implement that interface.

If we look at our class named Implementation, we can see that it Inherits from our class named ParentClass, and Implements our Interface named IInterface. The method body of the Subtract method defined in IInterface is actually declared within our Implementation class. If we did not declare public methods that matched all the methods defined in the Interface that our class Implements, this would result in a compiler error.

Notice also that Implementation does does not define a method body for Add. That is instead done in our class named ParentClass. Parent class both definesand implements the Add method. As a result, our Implementation class will Inherit this method definition from its ancestor class. If we were to invoke the Add method on an instance of Implementation, the code which would execute at runtime would actually be the code declared inside the method body of ParentClass.

Note also that in C# (and any language which does not support multiple Inheritance) – a class can only Inherit from a single class. Conversely, a single class can Implement as many Interfaces as you wish.

Operator versus Operand


Operators are symbols (or collections of symbols) in code which perform some operation on the values immediately adjacent to them. The values which are operated on in this way are called Operands. C# has Operators which take one, two, or three Operands. They are called Unary Operators, Binary Operators, and Ternary Operators, respectively.

In the screenshot above, I have highlighted each Operator in green, and each Operand in red. (Note: the equals sign ‘=’ is the assignment Operator, but I did not highlight it since it won’t be discussed directly here.)

Beginning at the top, we have the binary Addition Operator ‘+’ which accepts two numerical Operands and returns their sum.

Next we have the unary Logical Not Operator ‘!’ which accepts a single boolean Operand and returns the inverse of its value.

And last we have the Ternary Operator ‘?:’ – to which we are passing the result of a Logical Equality Operator whose Operands are the variable ‘a’ and the integer constant ‘5’. Depending whether this value is true or false, determines whether the Ternary Operator returns its second or third operand respectively. If ‘a’ is equal to 5 when this statement executes, then 0 will be returned, otherwise 1 will be returned.

Line versus Statement versus Expression


An Expression is a sequence of Operands and Operators which evaluates to a single value. In the example above, ‘5 + 4’ and all of the other arithmetic operations we perform are Expressions.

Lines refer to a single line of code, which may contain one or more Statements and Expressions.

Statements refer to many actions your program might execute. As you step through your code using a debugger, you will sometimes find that individual Lines of Code may be hit multiple times by the debugger. This is because the C# Debugger breaks on individual Statements, rather than individual Lines.

In our example above, the first two lines each contain a single Statement: an integer variable declaration statement, and an assignment statement which stores the result of the Expression 5 + 4 into that variable.

The third line, however, contains 3 variable declaration Statements, 3 assignment Statements, and 3 arithmetic expressions.

Functions versus Methods

For this example I will use Javascript, since C# does not have a way to define Functions which are not also Methods:


Functions are definitions of a collection of Statements which may be executed at runtime.

Methods are specific examples of Functions whose context for execution is an instance of an object. This means that those methods will have access to a particular object’s private data, which may not otherwise be accessible. Most languages including Javascript and C# use the ‘this’ keyword to as a reference to the object instance to which a Method belongs at runtime.

In our example above, Add would commonly be described as a Function, while Subtract could be considered a Method, since it depends on being executed within the context of a particular object, whose properties it will access with the ‘this’ keyword.

Parameters versus Arguments


Parameters and Arguments are closely related and often confused (in fact I only just recently learned the difference thanks to this StackOverflow post)

Parameters are the names in a method declaration which refer to values which can be passed to a method at runtime when it is invoked.

Arguments are the values passed in to fulfill a method’s Parameter values when it is actually invoked. I have indicated the Arguments in the screenshot above in red, while the Parameters are indicated with green.


Hopefully, this blog will have helped you learn to better distinguish between some common programming terms, as well as identify the specific code artifacts to which they refer.

If you found this useful, let me know in the comments and I may do another blog about programming terminology. Let me know what terms you feel the least comfortable with or see other programmers confuse most often and I’ll discuss them in a future blog post!

Fix for Logitech G930 Shutting Off Every 15 minutes

Not too long ago I shopped around for a wireless headset which had surround surround support, and eventually settled on the Logitech G930 Headset.

While the hardware is excellent, and the sound is quite good, sadly the software designed to support the surround sound, macro keys, and showing the battery status is the Logitech’s Gaming Software suite, aka LGS. I have never used this software with any of their other products, so I can’t comment on its overall quality, but its support for the G930 headset is really quite awful.

Google’s search results are littered with people complaining about various issues with the headset’s drivers and the gaming software, some of which are quite severe. Logitech also doesn’t seem very interested in solving any of the driver/software problems for this headset, as some of the simpler issues have been open on their support forums for 5+ years without a patch being released.

It’s really a shame because the hardware itself is quite good, and it is the only headset I’ve managed to find which is: wireless, supports surround sound, and also has macro keys on the headset (useful for push-to-talk and skipping songs while I’m in the other room.)

One particularly annoying problem many people seem to have is that, while the headset works just fine out of the box, as soon as they install the Logitech Gaming Software, it begins to turn itself off every 15 minutes! This happened to me as well, and it turns out that it is just a default power-saving setting in the XML config used by LGS to determine how it should manage the headset. Since it’s a config file you’d think that you could just change the headset’s settings in LGS – no such luck. LGS provides no way in the UI to update this setting, requiring you to find and modify the XML file manually, or just get used to it shutting off every 15 minutes.

With the default install location, the file is located at the following path: C:\Program Files\Logitech Gaming Software\Resources\G930\Manifest\Device_Manifest.xml

You can simply change the value in the <battery> node’s turnOffInterval attribute to “0” to disable this battery saving feature entirely.

This is well and good, but I always forget the path when I reinstall the software on a new machine, and don’t feel that this is very intuitive for people who aren’t comfortable editing XML config files manually.

So tonight I wrote a simple Windows application to help users modify the battery configuration settings which are not normally editable through LGS and uploaded it to Github.

If you are experiencing this issue with your G930, I hope either this blog or my application helps. And if you are a programmer who wants to make an improvement and submit a pull request, feel free to do so!

Announcing Decide Among Friends!

Hey, guys!

I wanted to invite everyone to try out a new website I’ve been working on:

My coworkers always had a hard time figuring out a fair way to decide on a lunch location for 6+ people each day.  So I thought to myself someone should make a tool to help with this!

So then I did.

For opinion-based decisions between many people, I consider it to be superior to other voting websites such as because it allows you to demonstrate a varying level of preference between every option by dragging the sliders between -5 and +5.

It’s been really successful among my fellow lunchgoers in the office, and I hope that other people out there find it useful as well!

SOLID By Example

So I’ve recently been discussing SOLID principles with some engineers who are unfamiliar with them, and have realized that a good set of practical examples would be really useful for programmers who haven’t had professional experience with SOLID come to understand it. I won’t claim to be an expert at SOLID, so this is mostly an exercise for myself and a resource geared towards those who are less familiar with the SOLID principles and how to put them into practice when architecting applications in a modern object-oriented language.

To this end, I will take a very simple WPF application which uses a REST client to pull data from an online REST API. Then I will apply SOLID principles in a refactor to make its structure more testable, extensible, reusable, and maintainable. The example repository can be found on Github and is written in C#, but the basic principles apply to all object-oriented languages.

In the coming weeks I will create 5 more blog posts, each centering around one of the SOLID principles:

  • Single Responsibility Principle
  • Open Closed Principle
  • Liskov Substitution Principle
  • Interface Segregation Principle
  • Dependency Inversion Principle

I hope that newer developers will be able to learn from this, and that those of you who are already familiar with SOLID principles will find it to be a useful example!

Back to top