Assuming you have the data set you want to plot already, and the map you want to plot it to, you can start by creating an intensity map: a grid of floating point values that is proportional in bounds to the final map (if the maps are small enough, 1:1 is probably fine). Initialize the entire array to 0.
Then you walk through each point you want to plot, map it into the coordinate space of the intensity map (which should be a simple scale operation, normally), and then plot a "blip" in the intensity map centered at that position.
A basic "blip" might just consist of increasing the intensity at the blip point plus some radius by a small amount. More complex implementations could read the existing intensity, and use a bigger falloff radius the more intense the blip point already is. You can experiment with the blip plotter to find an implementation you like the look of.
Once you have an intensity map you can use the intensity at each individual point as a 1D look-up into a color gradient, which will allow you to achieve the desired visual impact (this is how you can get the multi-colored results that are most commonly seen). You should do this color lookup as you transfer the intensity map to your final plot (rescaling, obviously, as necessary to account for size differences in the intensity map versus the final image).
This should be enough for a basic implementation, but there is room for optimization. For example, the intensity map will not be normalized, so you may need to renormalize it (probably slow) or keep track of the maximum intensity as you plot each blip, so that you can perform the renormalization of an individual intensity at the same time you are doing the recolorization. Additionally, it's possible that the distribution of your values is such that it is not memory-efficient to be storing the entire coordinate space of the map, and you may want to use an alternative solution that doesn't involve preallocating a large chunk of memory that will be mostly-empty.
If you have enough data beforehand to query the minimum and maximum intensities you expect to see in the data set you can avoid having to renormalize at all -- basically if you have some map between (X,Y,Z) to the number of "hits" of the plotted data that occurred at that point -- that's something you can build in to the system that collects the data which will help you optimize the mapping portion.
Since the intensity map is just, essentially, a grayscale image a really easy way to prototype this kind of system to use a bitmap for the intensity map and your drawing API of choice (for example,
System.Drawing in C#) to plot partially-transparent circles to produce an intensity map. It doesn't look the best, but its functional.