A vector at right angles to (x, y) is (-y, x).  You can use that knowledge and a bit of trickery with translate to draw a railway line.

1. void setup() {
2.   size(200, 200);
3. }
4. 
   
5. void draw() {
6.   // Set an origin for the track
7.   PVector origin = new PVector(30, 30);
8.  
9.   // Vector of the train line
10.   PVector l = new PVector(100, 50);
11.  
12.   // Vector at right angle to train line
13.   PVector rl = new PVector(l.y, -l.x);
14.   rl.normalize();
15.   // Track width
    
16.   rl.mult(10);
17.  
18.   // Calculate end of trainline
19.   PVector end = PVector.add(origin, l);
20.  
21.   // Draw the track
22.   line(origin.x, origin.y, end.x, end.y);
23.   origin.sub(rl);
24.   end.sub(rl);
25.   line(origin.x, origin.y, end.x, end.y);
26.  
27.   // Draw the sleepers
28.   pushMatrix();
    
29.   float numSleepers = 20;
30.   translate(origin.x, origin.y);
31.   line(0, 0, rl.x, rl.y);
32.   for (int i = 0; i < numSleepers; i++) {
33.     translate(l.x * (1 / numSleepers), l.y * (1 / numSleepers));
34.     line(0, 0, rl.x, rl.y);
35.   }
36.   popMatrix();
    
37. }

I came up with this:

1. int x1, y1;
2. int x2, y2;
3. boolean bFirst = true;
4. final float DIST = 20;
5. final float FACTOR = 0.6;
6. 
   
7. void setup()
8. {
9.   size(500, 500);
10.   smooth();
11. }
12.  
13. void draw()
14. {
15.   background(255);
16.   if (bFirst)
17.   {
18.     stroke(0);
19.     line(x1, y1, x2, y2);
20.    
21.     float lineLength = dist(x1, y1, x2, y2);
22.     float pointNb = lineLength / DIST;
23.    
24.     // First find out where to put the lines 
25.     fill(#FF5555, 64);
26.     noStroke();
27.     float dx = (x2 - x1) / pointNb;
28.     float dy = (y2 - y1) / pointNb;
29.     for (int i = 0; i < pointNb; i++)
30.     {
31.       ellipse(x1 + dx * i, y1 + dy * i, 8, 8);
32.     }
33.    
34.     stroke(0);
35.     for (int i = 1; i < pointNb; i++)
36.     {
37.       float px = x1 + dx * i;
38.       float py = y1 + dy * i;
39.       line(px + dy * FACTOR, py - dx * FACTOR, px - dy * FACTOR, py + dx * FACTOR);
    
40.     }
41.   }
42. }
43.  
44. void mousePressed()
45. {
46.   if (bFirst)
47.   {
48.     x1 = mouseX;
49.     y1 = mouseY;
50.   }
51.   else
52.   {
53.     x2 = mouseX;
54.     y2 = mouseY;
55.   }
56.   bFirst = !bFirst;
57. }

[EDIT] Ah, a bit too late...

Thanks for both responses.   PhiLho, your solution was perfect and I have been able to modify it to suit my project.  i really appreciate you guys taking the time to help me out.  I will be sure to post the final project on openprocessing so I can share what I have learned.  

final makes a var to a const that you can't change later.

So, 'final' it's more of a label in this case and if I left it as a 'float' it wouldn't make a difference.  Is that right?

The difference is that if you try to do DIST = 5; in a function, Processing will throw a compilation error...
So, it is a bit more than a label, it is a safeguard. But indeed, it is optional: it is here more for information (that, and the all caps name convention) than for playing a crucial role in the code... (but it is important in a library, for example, and it can be optimized better by the compiler).