I am working on a small animation. After having inserted this block in it, I noticed that the first second or two when I run it, I get a blank screen as if something is destabilizing the execution. I was curious to know why this particular block would do that? This is the problem block and I have included the whole code in another section below that.

1.  // loop to draw the twelve lines on the sand that mark the hours
2.   int lineNumber =0;
3.   while (lineNumber<13) {
4.     int spaceBetween =(lineNumber-1)*10;
5.     int hourCounter=lineNumber+1;
6.     float hourLineY = (seaLevelLow+2)+spaceBetween;
7.     float inverseHourLineY = height-spaceBetween-3;
8.     stroke(232, 221, 7);
9.     strokeWeight(1);
10.     line (40, hourLineY, width-40, hourLineY);
11.     fill(209,199,6);
12.     text(hourCounter, 20, inverseHourLineY);
13.     text(hourCounter+12, width-30, hourLineY-5);
14.     lineNumber++; }
    

1. // declare global variables for internal clock time functions
2. int hr; // will return the hour according to internal clock
3. int mnt; // will return the minutes according to internal clock
4. int sec; //returns the seconds according to internal clock
5. int dy; //returns the day of the month according to internal clock
6. int mth; //returns the month according to internal clock
7. int yr; //returns the four digit year according to internal clock
8. float milliseconds; //returns the number of milliseconds since start of app according to internal clock
9. // declare global variables for sky lines and sun and moon animation
10. float centerX;
11. float centerY;
12. float horizonLineY;
13. float arcSpaceX;
14. float arcSpaceY;
15. float arcSpaceAngleX;
16. float arcSpaceAngleY;
17. float x;
18. float y;
19. int sunSize=90;
20. float angle;
21. float sizeArcX;
22. float sizeArcY;
23. float sunSpeed;
24. float seaLevelLow;
25. float seaLevelY;
26. float hourLineY;
27. // declare global variables for Spring fish animation
28. float FishYLocation;
29. float maleFishXLocation=1500;
30. float femaleFishXLocation=1200;
31. float fishSpeed=2;
32. float maleFishAcceleration=2;
33. float fishReproductionSpeed=3;
34. float babyX;
35. float babyY;
36. int time1 = 8000;
37. // prepare the size and framerate of the application
38. void setup() {
39.   size(1400, 800);
40.   frameRate (30);
41.   // initialize content of the global variables for internal clock time
42.   int hr= hour(); // hour will range from 0 to 23
43.   int mnt=minute(); // minutes will range from 0 to 59
44.   int sec=second(); // seconds will range from 0 to 59
45.   int dy=day(); // days will range from 1 to 31
46.   int mth=month(); // mth will range from 1 to 12
47.   int yr=year(); // yr will range from this year on
48.   float milliseconds =millis(); // milliseconds will start when app starts
49.     // initialize content of the global variables for rotation of sun
50.   // and static purple lines that function as a 5 sec. time reference
51.   centerX=width/2;
52.   centerY=height/2;
53.   horizonLineY=height-height*3/5;
54.   seaLevelLow=height-120;
55.   angle=0.0;
56.   sizeArcX=width/2;
57.   sizeArcY=height/2.1;
58. }
59. void draw() {
60.   background(120, 70, 230);
61.   // initialize content of the local variables 
62.   sunSpeed=second();
63.   angle=180+3*sunSpeed;
64.   // loop to draw purple lines in the sky spaced apart in a regular fashion
65.   // where the space between each line represents a span of 5 seconds.
66.   float arcSpaceIteration=0; 
67.   while (arcSpaceIteration<181) {
68.     arcSpaceAngleX=180+arcSpaceIteration;
69.     arcSpaceAngleY=180+arcSpaceIteration;
70.     arcSpaceX=centerX+sizeArcX*cos(radians(arcSpaceAngleX));
71.     arcSpaceY=centerY+sizeArcY*sin(radians(arcSpaceAngleY));
72.     stroke(135, 0, 230);
73.     strokeCap(ROUND);
74.     strokeWeight(4);
75.     line (centerX, centerY, arcSpaceX, arcSpaceY);
76.     arcSpaceIteration+=15;
77.   }
78.   // Draw a sand color surface over the purple lines which
79.   // will be revealed every hour as the tide receeds
80.   fill(242, 238, 149);
81.   noStroke();
82.   rectMode(CORNERS);
83.   rect (0, horizonLineY, width, height);
84.   // loop to draw the twelve lines on the sand that mark the hours
85.   int lineNumber =0;
86.   while (lineNumber<13) {
87.     int spaceBetween =(lineNumber-1)*10;
88.     int hourCounter=lineNumber+1;
89.     float hourLineY = (seaLevelLow+2)+spaceBetween;
90.     float inverseHourLineY = height-spaceBetween-3;
91.     stroke(232, 221, 7);
92.     strokeWeight(1);
93.     line (40, hourLineY, width-40, hourLineY);
94.     fill(209,199,6);
95.     text(hourCounter, 20, inverseHourLineY);
96.     text(hourCounter+12, width-30, hourLineY-5);
97.     lineNumber++;
98.   }
99.   // Alternate the color of the ellipse so that it is either the sun or the moon    
100.   float sunMoon=minute()%2;
101.   if (sunMoon%2 ==0) {
102.     fill(255, 225, 5);
103.   }
104.   else {
105.     fill (225, 225, 255);
106.   }
107.   // draw and move sun incrementally every second over an arc of 180 degrees in the sky
108.   noStroke();
109.   float x=centerX+sizeArcX*cos(radians(angle));
110.   float y=centerY+sizeArcY*sin(radians(angle));
111.   ellipse(x, y, sunSize, sunSize);
112.   // create water-based horizon line in a layer in front of the animation of the sun
113.   // and make this water recede every hour for first 12 hours and then rise back up
114.   // for second 12 hours of a day
115.   int hr= hour(); // hour will range from 0 to 23
116.   if (hr<13) { 
117.     fill (149, 230, 240, 160);
118.     noStroke();
119.     seaLevelY=height-hr*10;
120.     rectMode(CORNERS);
121.     rect (0, horizonLineY, width, seaLevelY);
122.   }
123.   else {
124.     fill (149, 230, 240, 160);
125.     seaLevelY=seaLevelLow+(hr-12)*10;
126.     rect (0, horizonLineY, width, seaLevelY);
127.   }
128.   /* Spawning like fish marks the passage of calendrical time with allegories drawn
129.    from nature: the fish animation represents the spring season */
130.   // Initialize local variables for fish animation
131.   int fishMotion =millis ();
132.   float FishYLocation=height/2;
133.   stroke(1);
134.   //  Condition for seduction preceding spawning
135.   if (femaleFishXLocation<maleFishXLocation) {
136.     //Female fish appearing followed by a male fish
137.     if (fishMotion < time1) {
138.       maleFishXLocation-=fishSpeed;
139.       femaleFishXLocation-=fishSpeed;
140.     }
141.     //   Male fish showing interest in female fish  
142.     else {
143.       maleFishAcceleration*=1.007;
144.       maleFishXLocation-=maleFishAcceleration;
145.       femaleFishXLocation-=fishSpeed;
146.     }
147.     fill(255, 40, 10);
148.     drawFish (femaleFishXLocation, FishYLocation);
149.     fill(245, 245, 0);
150.     drawFish (maleFishXLocation, FishYLocation);
151.   }
152.   // Fish spawning babies as they swim off the screen together = Happy ending!
153.   else {
154.     femaleFishXLocation-=fishSpeed;
155.     fill(255, 40, 10);
156.     drawFish (femaleFishXLocation, FishYLocation);
157.     fill(245, 245, 0);
158.     drawFish (femaleFishXLocation-1, FishYLocation);
159.     //  Baby fish following behind
160.     fill(255, 180, 0);
161.     scale(0.5);
162.     translate (300, 100);
163.     drawFish (2*femaleFishXLocation, 2*FishYLocation);
164.     for (int f = 0; f < 24; f++)
165.       //  draw 25 other baby fish that follow
166.       for (int babyX = 0; babyX <7; babyX++) {
167.         drawFish (2 * femaleFishXLocation + 150 * babyX, 2 * FishYLocation);
168.         drawFish (2 * femaleFishXLocation + 200 * babyX, 2 * FishYLocation+50*babyX);
169.         drawFish (2 * femaleFishXLocation + 275 * babyX, 2 * FishYLocation-40*babyX);
170.         drawFish (2 * femaleFishXLocation + 325 * babyX, 2 * FishYLocation-40*babyX);
171.       }
172.   }
173. }
174. // CREATE THE SPRING FISH FUNCTION
175. void drawFish (float fishX, float fishY) {
176.   strokeWeight (3);
177.   beginShape();
178.   vertex(fishX, fishY+50);
179.   vertex(fishX+45, fishY+20);
180.   vertex(fishX+100, fishY+40);
181.   vertex(fishX+150, fishY);
182.   vertex(fishX+120, fishY+90);
183.   vertex(fishX+95, fishY+70);
184.   vertex(fishX+60, fishY+80);
185.   endShape(CLOSE);
186.   arc (fishX+34, fishY+42, 10, 15, 0, PI);
187. }
188. // CREATE THE STARFISH FUNCTION
189. void starFish (float starFishX, float starFishY) {
190.   fill (216, 20, 125);
191.   strokeJoin(ROUND);
192.   strokeWeight (4);
193.   beginShape();
194.   vertex(starFishX, starFishY+24);
195.   vertex(starFishX+20, starFishY+32);
196.   vertex(starFishX+27, starFishY);
197.   vertex(starFishX+34, starFishY+32);
198.   vertex(starFishX+54, starFishY+24);
199.   vertex(starFishX+42, starFishY+54);
200.   vertex(starFishX+50, starFishY+96);
201.   vertex(starFishX+27, starFishY+72);
202.   vertex(starFishX+4, starFishY+96);
203.   vertex(starFishX+12, starFishY+54);
204.   endShape(CLOSE);
205.   arc (starFishX+26, starFishY+58, 10, 15, 0, PI);
206.   strokeWeight (3);
207.   ellipse (starFishX+18, starFishY+44, 7, 7);
208.   arc (starFishX+18, starFishY+41, 10, 10, PI, TWO_PI);
209.   ellipse (starFishX+32, starFishY+44, 7, 7);
210.   arc (starFishX+32, starFishY+41, 10, 10, PI, TWO_PI);
211. }