Why isn't it ending?

Question

Your task: To write a program that should obviously terminate, but it never (to the extent of a computer crash) does. Make it look like it should perform a simple task: adding numbers, printing something,... But it just gets caught in an infinite loop.

Try to make your program very clear and simple, while it actually will get stuck in an unforeseen loop. Voters: judge the answers on how "underhanded" they are!

This is a popularity contest: Be creative!

Answer 1

Javascript

var x=prompt('Enter a value under 100');
while (x != 100) {
  x=x+1;
}
console.log('End!');

prompt() returns a string and the loop appends the character '1', it will never be equal to 100.

Answer 2

C

Just a basic example program that illustrates the three different kinds of while-loops in C.

int main() {

    int x = 0;

    // Multi-statement while loops are of the form "while (condition) do { ... }" and
    // are used to execute multiple statements per loop; this is the most common form
    while (x < 10) do {
        x++;
    }

    // x is now 10

    // Null-statement while loops are of the form "while (condition) ;" and are used
    // when the expression's side effect (here, decrementing x) is all that is needed
    while (x-- > 0)
        ; // null statement

    // x is now -1

    // Single-statement while loops are of the form "while (condition) statement;"
    // and are used as a shorthand form when only a single statement is needed
    while (x > -10)
        x--;

    // x is now -10

    return 0;
}

While loops don't have a "do" before the opening curly brace. This actually creates a do-while loop inside of the (x < 10) loop that's terminated by the following "null statement" while loop. Since x is incremented inside of the loop and then decremented in the do-while loop's condition, the inner loop never terminates, and so neither does the outer loop. The "single-statement" loop at the end is never reached.

If you're still confused, look here (externally hosted because codegolf.SE doesn't like code blocks in spoilers).

Answer 3

JavaScript

var a = true;
(function() {
  while(!a){}
  alert("infinite");
  var a = true;
})();

Variable hoisting: JavaScript will actually grab my second definition of var a = true;, declare it at the top of the function as var a;, and modify my assignment to a = true; meaning a will be undefined at the time it enters the while loop.

Answer 4

C#

class Program
{
    // Expected output:
    // 20l
    // 402
    // 804
    // l608
    // 32l6
    // game over man

    static void Main()
    {
        var x = 20l;
        while (x != 6432)
        {
            Console.WriteLine(x);
            x *= 2;
        }
        Console.WriteLine("game over man");
    }
}

The number literal in the first line of the function is not a '201', but a '20' with a lowercase 'L' (long datatype) suffix. The number will overflow pretty quickly without ever hitting 6432, but the program will keep going unless overflow checking was switched on in the build options.
Sensibly, Visual Studio 2013 (and probably other versions too) gives you a warning for this code, recommending that you use 'L' instead of 'l'.

Answer 5

C

How about precision ?

int main(void)
{
    double x = 0;
    while(x != 10) x += 0.1;
    return 0;
}

Imagine you have to store a range of integer numbers <0;3> in computer memory. There are only 4 integer numbers in this range (0,1,2,3). It's enough to use 2 bits to store that in memory. Now imagine you have to store a range of floating point numbers <0;3>. The problem is there is an infinite number of floating point numbers in this range. How to store infinite number of numbers ? It is impossible. We can only store finite number of numbers. This is why some numbers like 0.1 are actually different. In case of 0.1 it is 0.100000000000000006. It is highly recommended to not use == or != in conditions as far as you use floating point numbers.

Answer 6

HTML / JavaScript

Imagine you have an input box in your page:

<input onfocus="if (this.value === '') alert('Input is empty!');">

And now you want to type something in it... Try in Chrome: http://jsfiddle.net/jZp4X/.

Standard browser dialog box called with alert function is modal, so when it's displayed it takes the focus out of the text box, but when it is dismissed the text box receives the focus back.

Answer 7

C++

#include <iostream>
#include <cstddef>

int main() {
    size_t sum = 0;
    for (size_t i = 10; i >= 0; --i) {
         sum += i;
    }
    std::cout << sum << std::endl;
    return 0;
}

The condition i >=0 is always true because size_t is unsigned.

Answer 8

bash

(There was a request for no loops or recursion)

#!/bin/bash

# Demo arrays

foo=("Can I have an array?")

echo $foo

echo ${foo[0]}

foo[2] = `yes`

echo $foo

echo ${foo[2]}

Instead of assigning the string 'yes' to foo[2], this calls the system command yes, which fills up foo[2] with a never ending amount of "yes\n".

Answer 9

C

Letter "x" was lost in a file. A program was written to find it:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
  FILE* fp = fopen("desert_file", "r");
  char letter;
  char missing_letter = argv[1][0];

  int found = 0;
  printf("Searching file for missing letter %c...\n", missing_letter);
  while( (letter = fgetc(fp)) != EOF ) {
    if (letter == missing_letter) found = 1;
  }
  printf("Whole file searched.\n");
  fclose(fp);
  if (found) {
    printf("Hurray, letter lost in the file is finally found!\n");
  } else {
    printf("Haven't found missing letter...\n");
  }
}

It was compiled and to ran and it finally shout:

Hurray, letter lost in the file is finally found!

For many years letters have been rescued this way until the new guy came and optimized the code. He was familiar with datatypes and knew that it's better to use unsigned than signed for non-negative values as it has wider range and gives some protection against overflows. So he changed int into unsigned int. He also knew ascii well enough to know that they always have non-negative value. So he also changed char into unsigned char. He compiled the code and went home proud of the good job he did. The program looked like this:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
  FILE* fp = fopen("desert_file", "r");
  unsigned char letter;
  unsigned char missing_letter = argv[1][0];

  unsigned int found = 0;
  printf("Searching file for missing letter %c...\n", missing_letter);
  while( (letter = fgetc(fp)) != EOF ) {
    if (letter == missing_letter) found = 1;
  }
  printf("Whole file searched.\n");
  fclose(fp);
  if (found) {
    printf("Hurray, letter lost in the file is finally found!\n");
  } else {
    printf("Haven't found missing letter...\n");
  }
}

He came back to a havoc on the next day. Letter "a" was missing and even though it was supposed to be in the "desert_file" containing "abc" the program was searching for it forever printing out only:

Searching file for missing letter a...

They sacked the guy and rolled back to previous version remembering that one should never optimize datatypes in working code.

But what is the lesson they should have learnt here?

First of all, if you take a look at the ascii table you'll notice that there is no EOF. That's because EOF is not a character but a special value returned from fgetc(), which can either return character extended to int or -1 denoting end of file.
As long as we are using signed char everything works well - char equal to 50 is extended by fgetc() into int equal to 50 as well. Then we transform it back to char and still have 50. Same happens for -1 or any other output coming from fgetc().
But look what happens when we use unsigned char. We start with a char in fgetc() extend it to int and then want to have an unsigned char. The only problem is that we can't preserve -1 in unsigned char. Program is storing it as 255 which no longer equal to EOF.

Caveat
If you take a look at section 3.1.2.5 Types in copy of ANSI C documentation you'll find out that whether char is signed or not depends solely on implementation. So the guy probably shouldn't be sacked as he found a very tricky bug lurking in the code. It could come out when changing the compiler or moving to different architecture. I wonder who would be fired if the bug came out in such a case ;)

PS. Program was built around the bug mentioned in PC Assembly Language by Paul A. Carter

Answer 10

Regex

With appropriate input, the following regex can cause most backtracking regex engine to go into backtracking hell:

^\w+(\s*\w+)*$

Simple input such as "Programming Puzzles and Code Golf Stack Exchange - Mozilla Firefox" or "AVerySimpleInputWhichContainsAnInsignificantSentence." (both strings quoted for clarity) is enough to keep most backtracking regex engines running for a long time.

Since (\s*\w+)* allows for the expansion \w+\w+\w+...\w+, which means the regex engine will basically try out all possible ways to split up a string of word characters. This is the source of the backtracking hell.
It can easily be fixed by changing \s* to \s+, then (\s+\w+)* can only be expanded to \s+\w+\s+\w+...\s+\w+.

Answer 11

JavaScript

function thiswillLoop(){
var mynumber = 40;
while(mynumber == 40){
mynumber = 050;
}
return "test";
}
thiswillLoop();

050 is an octal constant in Javascript, and it happens to have the decimal value of 40.

Answer 12

Haskell

head $ reverse $ (repeat '!') ++ "olleH"

Well, think of it! It would be the same as head $ "Hello" ++ (repeat '!'), i.e should just return 'H'.

In haskell lists are recursive structures, with first element being the topmost. To append to a list, you have to unroll all those elements, place your appendix, and put the lifted elements back. That wouldn't work on an infinite list. Similarly, reversing an infinite list won't magically give you your "Hello" back. It will just hang forever.

Answer 13

Java under Windows

public class DoesntStop
{
    public static void main(String[]a) throws InterruptedException, IOException
    {
        ProcessBuilder p = new ProcessBuilder("cmd.exe","/c","dir");
        p.directory(new File("C:\\windows\\winsxs"));
        Process P = p.start();
        P.waitFor();
    }
}

Program relies on a jammed standard output stream from the commandline to get stuck. The WinSXS directory under windows has multiple thousands of files with long names so it is almost guaranteed to clog stdout, and the waitFor can't return so the program is deadlocked

Answer 14

To compare apples and oranges... in C

I'm impressed that there is no piece of code here using a goto... (You know: Goto is evil!)

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
    char *oranges = "2";
    long int apples;

next_harvest:

    apples = random() % 3;

    printf("%ld apples comp. %s oranges ...\n", apples, oranges);

    if( apples != (long int)oranges )
    {
        sleep(1);
        goto next_harvest;
    }

    return 0;
}

The sleep is just for being able to read it. Press ^C if you don't have an endless amount of time to wait for something that never happens ;-)

Answer 15

C, with certain optimizing compilers

This program increments an integer variable until it overflows.

#include <stdio.h>
#include <stdint.h>
int main()
{
    int32_t x = 0;
    while(x + 1 > x)
        x++;
    printf("Got overflow!\n");
    return 0;
}

Signed integer overflow is undefined behaviour. Usually in practice it wraps, when optimizations are turned off. With optimizations on, compilers can and do decide that x + 1 > x is always true.

Answer 16

C++

int main()
{
  int x = 1;
  //why doesn't this code terminate??/
  x = 0;
  while(x) {} //no-op/
  return 0;
}

The weird commenting style is the trick. Hint: trigraphs.

Answer 17

Java

I particular love this side effect of the autoboxing optimization:

class BoxingFun {
  public static void main( String[] args) {
    Integer max;
    Integer i;

    max = 100;
    for( i = 1; i != max; i++ ) {
      System.out.println("Not endless");  
    }
    max = 200;
    for( i = 1; i != max; i++ ) {
      System.out.println("Endless");  
    }
  }
}

Because of autoboxing, Integer objects behave almost like plain ints here, with one exception: The i != max in the for loops compares the references (identity) of the Integer objects, not their value (equality). For values up to 100 this surprisingly "works" nevertheless because of an optimization in the JVM: Java preallocates Integer objects for the "most common values" and reuses them when autoboxing. So for values up to 100 we have identity <==> equality.

Answer 18

Ruby/C

#include <stdio.h>
#ifdef llama
def int(*args)
end
def main(arg)
  yield
end
void = nil
#endif
#define do {
#define end }
int main(void) {
  int x = 10;
  while(x-=1) do
    printf("%i\n",x);
  end
    return 0;
}

This works correctly in C, counting down from 9 to 1 in STDOUT. When run in Ruby, it does not terminate, because

0 is not a false value in Ruby.

Answer 19

JavaScript

// This multiplies the elements in the inner lists and sums the results.
function sum_of_products(var items)
{
        var total = 0;
        for(var i = 0; i < items.length; i++) {
                var subitems = items[i];
                var subtotal = 1;
                for(var i = 0; i < subitems.length; i++) {
                        subtotal *= subitems[i];
                }       
                total += subtotal;
        }
        return total;
}

// Should return 1*2 + 3*4*5 + 6*7*8*9 + 10*11 = 3196
sum_of_products([[1, 2], [3, 4, 5], [6, 7, 8, 9], [10, 11]]);

Both loops use the same loop variable, so depending on the input, the inner loop can keep the outer loop from ever finishing.

Answer 20

Python

a = True
m = 0
while a:
    m = m + 1
    print(m)
    if m == 10:
        exit

it should be exit() and not exit. As I understand it, exit() is the command to exit the python interpreter. In this case the call is to the representation of the function and not to the function see: exit-discussion. Alternatively break would be a better choice.

Answer 21

C

This should print a code table for all ASCII characters, from 0 to 255. A char is large enough to iterate over them.

#include <stdio.h>

int main(){
    char i;
    for(i = 0; i < 256; i++){
        printf("%3d 0x%2x: %c\n", i, i, i);
    }
    return 0;
}

All chars are less than 256. 255++ gives 0 due to overflow, so the condition i < 256 always hold. Some compilers warn about it, some don't.

Answer 22

C++

How about the classical C++-programmer's trap?

int main()
{
   bool keepGoing = false;

   do {
       std::cout << "Hello, world!\n";
   } while( keepGoing = true );

   return 0;
}

Answer 23

Java:

public class LoopBugThing{
   public static void main(String[] args)
   {
      int i = 0;
      while(i < 10)
      {
         //do stuff here
         i = i++;
      }
      System.out.println("Done!");
   }
}

The "i = i++" is a pretty common beginner mistake and can be surprisingly hard to find

Answer 24

Javascript

var а = 0;
a = 1;
while(а<10){
    a++;
}

The variables used in 1st and 3rd line are different from the ones used in 2nd and 3rd line.
One uses a (U+0061) while the other uses а (U+0430)

Answer 25

Haskell

Some code to time the computation of a given value of the Ackermann function. For very low values it usually terminates. On my machine very low values means something like 3 5 or smaller with compiled code and -O. In ghci low values means something like 3 3.

The ' symbol seems to mess up syntax highlighting, not sure why. In some places they are needed so can't remove all of them.

Edit- changed language.

{-# LANGUAGE NamedFieldPuns #-}
import Control.Concurrent.STM
import Control.Concurrent
import Data.Time.Clock.POSIX

data D = D { time :: !POSIXTime
           , m :: !Integer
           , n :: !Integer
           , res :: !(Maybe Integer)
           } deriving Show

startvalue = D 0 3 8 Nothing

-- increment time in D. I belive lensen make code like
-- this prettier, but opted out.
inctime t t' (d@D{time}) = d {time = time + t' - t }

-- Counting time
countTime :: TVar D -> POSIXTime -> IO ()
countTime var t = do
    t' <- getPOSIXTime
    atomically $ modifyTVar' var (inctime t t')
    countTime var t'

-- Ackermann function
ack m n
    | m == 0    = n + 1
    | n == 0    = ack (m - 1) 1
    | otherwise = ack (m - 1) (ack m (n - 1))

-- Ackerman function lifted to the D data type and strict
ack' (d@D{m, n}) = let a = ack m n
                   in seq a (d { res = Just a })

-- fork a counting time thread, run the computation
-- and finally print the result.
main = do
    d <- atomically (newTVar startvalue)
    forkIO (getPOSIXTime >>= countTime d)
    atomically $ modifyTVar' d ack'
    (atomically $ readTVar d) >>= print

This causes a livelock. The counting thread repeatedly causes the Ackermann computation to roll back since they touch the same TVar.

Answer 26

C++

A bit of random ?

class Randomizer
{
   private:
   int max;

   public:
   Randomizer(int m)
   {
      max = m;
      srand(time(NULL));
   }

   int rand()
   {
      return (rand() % max);
   }
};

int main()
{
  Randomizer r(42);
  for (int i = 0; i < 100; i++)
  {
     i += r.rand();
  }
  return (0);
}

Doesn't call the function rand but instead call recursively the Randomizer::rand function.

Answer 27

Java -- No loops or recursion

I just started learning regular expressions and wrote my first program to test if my string matches a regular expression.

Unfortunately, the program does not produce any result. It holds up the terminal. Please help in finding the problem. I have not made any use of loops, there is no recursion involved. I am completely baffled.

import java.util.regex.*;

public class LearnRegex {
     public static void main(String[] args) {
         Pattern p = Pattern.compile("(x.|x.y?)+");
         String s = new String(new char[343]).replace("\0", "x");
         if (p.matcher(s).matches())
             System.out.println("Match successful!");
     }
}

What have I done wrong? Why doesn't my program end? Please help!

Ideone link here.

This is a stupid example of catastrophic backtracking. The complexity is O(2^n/2). While the program might not run indefinitely, it'd probably outlive both living and non-living objects around and not-so-around.

Answer 28

C

You should only need one of the two loops, but which one you need depends on your compiler.

main()
{
        int i, a[10];

        i = 0;
        while (i <= 10) {
            i++;
            a[i] = 10 - i;
            printf("i = %d\n", i);
        }

        /* Now do it in reverse */

        i = 10;
        while (i >= 0) {
            i--;
            a[i] = 10 - i;
            printf("i = %d\n", i);
        }

}

A simple bounds overrun that resets i to a non-terminating value. Compilers can differ on whether they allocate i above or below a on the stack, so I've included overruns in both directions.

Answer 29

C / C++

C++ just allows the easy inline variable declarations used here, but it's just as easy to make this mistake in plain old C...

#include <stdio.h>

int main(void)
{
    int numbers[] = {2, 4, 8};

    /* Cube each item in the numbers array */
    for(int i = 0; i < 3; i++) {
      for(int j = 0; j < 3; i++) {
        numbers[j] *= numbers[j];
      }
    }

    /* Print them out */
    for(int i = 0; i < 3; i++) {
      printf("%d\n", numbers[i]);
    }

    return 0;
}

In the inner loop, 'j' is compared but never incremented. (The 'i++' should actually be 'j++'). This is not so much a sneaky trick but more of an actual error I've made in the past ;) Something to watch out for.

Answer 30

C#

The following is a simple class performing an arithmetic operation (summation) on a large input array using a background thread. A sample program is included.

However, even though it is quite straightforward, it never terminates. Note that there is no sleight of hand (character lookalikes, hidden/missing semicolons, trigraphs ;-), etc.)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;

class Program
{
    static void Main()
    {
        var summer = new BackgroundSummer(Enumerable.Range(1, 1234567));
        Console.WriteLine(summer.WaitAndGetResult());
    }
}

public class BackgroundSummer
{
    private IEnumerable<int> numbers;
    private long sum;
    private bool finished;

    public BackgroundSummer(IEnumerable<int> numbers)
    {
        this.numbers = numbers;
        new Thread(ComputingThread).Start();
    }

    public long WaitAndGetResult()
    {
        while (!finished) { /* wait until result available */ }
        return sum;
    }

    private void ComputingThread()
    {
        foreach(var num in numbers)
        {
            sum += num;
        }
        finished = true;
    }
}

This is an example of a real-world nasty bug which might appear in your code as well. Per the .NET memory model and C# specification, a loop such as the one in WaitAndGetResult might never terminate unless you specify the variable as volatile, because it is modified by another thread. See this StackOverflow question for details. The bug is dependent on the .NET implementation, so it might or might not affect you. But usually, running a release build on an x64 processor seems to display the problem. (I tried it with “csc.exe /o+ /debug- infinite.cs”.)

Answer 31

Javascript

This once bit me years ago:

function outerloop(){
  for(i=0;i<10;i++){
    innerloop();
  }
}
function innerloop(){
  for(i=0;i<5;i++){
    console.log(i)
  }
}
outerloop();

The trick here is that when one uses for( i=0 ..., the variable i is created in the global scope (even if they're in separate functions), so it gets overwritten every time by the inner loop. This is an easy pitfall for those coming from C++ or PHP. The fix is to use var to declare the variable in local scope (for (var i...)

Answer 32

PowerShell

$i = 1

do {
    $i++
} until( $i > 10 )

The > is not the greater-than operator (which is -gt); it is the redirection operator. Since nothing is returned, PowerShell evaluates the expression as false and continues.

Answer 33

It is a GUI program that will show an empty frame titled Hello, world! and hide the frame in 1 second.

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JFrame;
import javax.swing.SwingUtilities;
import javax.swing.Timer;

public class Main {
    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                // Create a frame titled "Hello, world!".
                final JFrame frame = new JFrame("Hello, world!");
                frame.setVisible(true);

                // After 1 second...
                Timer timer = new Timer(1000, new ActionListener() {
                    @Override
                    public void actionPerformed(ActionEvent e) {
                        // Hide the frame.
                        frame.setVisible(false);
                    }
                });
                timer.setRepeats(false);
                timer.start();
            }
        });
    }
}

The frame is hidden, but it is not disposed, so the virtual machine would not terminate. Reference: http://docs.oracle.com/javase/7/docs/api/java/awt/doc-files/AWTThreadIssues.html#Autoshutdown

Answer 34

C

int main(void) {
  float x = 0;
  while(x != 1) x+=0.1;
}

lots of nooses for a C developer....

Answer 35

C

This was tested on a 64 bit machine with gcc using the compiler flag -fomit-frame-pointer.

int main() {
    long x = (long)main;
    asm("sub %0,%%rsp"::"i"(sizeof(x)));
}

This makes the return address the address of main. Which makes an infinite loop. The assembly line is needed to not run out of stack.

Answer 36

Java

Spawns a thread that will sleep for 1 second. The program should effectively sleep for a second while waiting for that thread to quit, and then end.

import java.lang.*;

class A {
    static boolean done;
    public static void main(String args[]) {
        done = false;
        new Thread() {
            public void run() {
            try {
                Thread.sleep(1000); // dummy work load
            } catch (Exception e) {
                done = true;
            }
            done = true;
            }
        }.start();
        while (!done);
        System.out.println("bye");
    }
}

Why it doesn't end

Answer 37

JavaScript

while(true)
    if(NaN == NaN)
        break;
    else
        console.log("Batman");

A funny property of the global NaN (Not a Number) object in JavaScript is that it is not equal to itsself. To test if a number is NaN one must use isNaN(). It's also amusing that typeof(NaN) returns "number".

Answer 38

C

This prints numbers from 0 to 9. Or at least it should...

#include <stdio.h>

int main() {
    int i;
    char line[12]; // "Iteration: x"

    for(i = 0; i < 10; i++) {
        sprintf(line, "Iteration: %d", i);
        puts(line);
    }

    return 0;
}

This is a classic off-by-one error triggering a stack overflow. The string is indeed 12 characters long, but the programmer forgot about the NULL terminator inserted by sprintf! On GCC, local variables are pushed to the stack in declaration order. Other compilers may order the variables differently. Since the stack grows backwards, this means i is after line in memory. The null byte overwrites the least significant byte of i. At the end of the block, i is always 0. i is incremented and it loops forever with i = 1.

Answer 39

C

int main(void)
{
        float count = 0;
        while(count < 33554432L)
        {
                count++;
        }
        return 0;
}

Floating-point numbers have limited precision. Under IEEE 754 floating-point math, a single-precision float only has 24 bits of precision: the largest integer that can be represented exactly is 16,777,216. 16777216 + 1 = 16777216.

Answer 40

C#

Perhaps too obvious, but

class Program
{
    static void Main()
    {
        int x = 0;
        while (x * x != 1000)
            x++;
        System.Console.WriteLine("Square root of 1000 is " + x);
    }
}

The square root of 1000 is not an integer, so it will never find it. It's just going to loop forever, assuming overflows aren't checked (the default is unchecked). So like I said, perhaps too obvious. But when I first saw it, I was pretty sure it was going to terminate - 1000 looks as though it should have an integer square root - to me, anyway.

Answer 41

Postscript

hello.ps:

/hello
{
    (Hello, world\n) print
    quit
}
dup 2 3 index cvx put def

hello

This prints "Hello, world" forever. To try it with ghostscript:

gs -sDEVICE=nullpage hello.ps

dup 2 3 index cvx put replaces the procedure's call to quit with a recursive call to procedure hello. Since postscript does tail call optimization, this runs forever without overflowing the stack.

Answer 42

TeX (Plain): Typesetting The Song That Never Ends

Compile with pdftex. It is not obfuscated (besides, well, being written in TeX) and actually does end, as pdftex stops after somewhat about 2.6 million pages...

\font\bigrm=cmr12 at 14pt
\centerline{\bigrm The Song That Never Ends}
\bigskip
\def\songthatneverend{
\noindent This is the song that never ends.\hfil\break
Yes, it goes on and on my friends.\hfil\break
Some people started singing it not knowing what it was,\hfil\break
and they'll continue singing it forever just because\smallskip

\expandafter\songthatneverend}
\songthatneverend
\bye

Answer 43

Ruby

if p
  //misses
  raise 'Unreachable'
end

while p //nonsense, Kernel#p always returns nil, which is falsey, so this will immediately terminate.
  puts 'Looping'
end

puts 'Done looping'

Answer 44

Batch

This loops forever outputting Hello.

@echo off
for /l %%a in (0,0,1) do echo Hello.

The for loop tries to count from 0 to 0 incrementing by 1 - (0,0,1). So it never reaches zero.

Or if you want to cause the prompt to crash.

@echo off
for /l %%a in (0,1,1) do call %%%%a
:1
echo END

--

h:\uprof>end.bat
******  B A T C H   R E C U R S I O N  exceeds STACK limits ******
Recursion Count=477, Stack Usage=90 percent
******       B A T C H   PROCESSING IS   A B O R T E D      ******

Answer 45

Javascript

Here's a typical beginner's programming exercise.

Continually repeat a sequence of 1..n1, until you've output a total of n2 numbers. For example, looping through 1..3 where the total quantity is 10 would produce this:

1 2 3 1 2 3 1 2 3 1

Below is a solution that uses a currying function. It's simple, elegant, and will hang your browser :-)

function output(msg) {
    $('<span></span>').text(msg).appendTo($('#output'));
}

function loopThroughSequence(max) {
    i = 0;
    return function() {
        if(i >= max) {
            i = 0;
        }
        return ++i;
    }
}

var getNextInSequence = loopThroughSequence(3);
for(var i = 0; i < 10; ++i) {
    output(' ' + getNextInSequence());
}

Note that loopThroughSequence forgets to declare i in scope. (It needed to preceed 'i' with the 'var' keyword.) Instead, it uses the i value declared below it in the for loop, and continually resets it back to zero.

Answer 46

C++

#include<fstream.h>
int main()
{ 
 char ch[80];
 ifstream fin("evil.txt");
 while(fin)
 {
  fin.get(ch,50); //read by lines
  cout<<ch;
 } //nothing wrong, right? wrong.
 return 0;
}

evil.txt contains following data :

hello.
I am awesome.

fin.get() leaves a '\n' in input stream. The rest is Elementary, my dear.

Answer 47

How about this...

#include<stdio.h>

void main(){
while((10*5/3)!=(10/3*5))
printf("In a loop\n");
}

Mathematically (10/3)*5==(10*5)/3;

Answer 48

Whitespace

(actual working code follows)

Readable version:

FSSSSSTTFFSFSSSSSTTFF

Where F is linefeed, S is space and T is tab

Answer 49

Haskell

This is just a simple program to illustrate return statements. Since the return statement ends the function, it doesn't run anything after it.

sayHello :: IO String
sayHello = do
    return "Hello!"
    sayHello

main = do
    hello <- sayHello
    putStrLn hello

Return statements don't end functions, unlike in other languages.

Answer 50

c#

    public void MemoryEfficientCountTo256()
    {
        for (byte i = 0; i <= 255; i++)
        {
            Console.WriteLine(i);
        }
    }

This is from a stackoverflow question. A byte can never be 256, so adding one takes it back to 0

Answer 51

C

int main(void) {
  int x;
  while(x<=10) x+=1;
}

from my experience this thing loops indefinitely only after 4 years of stable production at 3AM on a Saturday and once it loops for first time no system reboot can make it go away and within 15 minutes it happens to all high availability servers, dumping the entire production stack offline for a day.

Answer 52

Java

public class Main {
    public static void main(String[] args) {
        try{
        double i=1.0/0.0;
            while(i==i+1){  //weired condition should never be true
                System.out.println("This should never be printed");
            }
        }catch (ArithmeticException e){
            System.out.println("Caught divide by 0 exception");

        }
    }
}

Answer 53

Ruby

This is a super efficient piece of code that simulates a dice.

def almost_dice
  rand(7) # will output a number between 0 and 6. 
end

#I want a dice that outputs a number between 1 and 6, so I have no other choice, right?
def proper_dice
  d = almost_dice
  while d = 0
    d = almost_dice #Eventually, I'll get d != 0
  end
  return d
end

puts proper_dice

In ruby what could look like a test : d = 0 is actually an assignment. Since the assignement always succeed, then the test always returns true, hence the infinite loop

Answer 54

C#

Let's take a page from this answer: https://codegolf.stackexchange.com/a/24376/16729 but do the computation on a background thread in the class constructor!

class BackgroundSummer
{
  static int sum;
  static BackgroundSummer() 
  {
    // Let's compute the sum on another thread!
    var thread = new System.Threading.Thread(ComputeSum);
    thread.Start();
    thread.Join();
  }

  static void ComputeSum() 
  { /* omitted: compute the sum here */ }

  static void Main() 
  { }
}

An explanation of why this runs forever is here: http://ericlippert.com/2013/01/31/the-no-lock-deadlock/

Answer 55

Scala

var break = false
for(i <- Stream.from(0) if !break) {
  break = i >= 10
}
println("Well done!")

Infinite streams will continue to be evaluated even if break is true.

Or the second one.

var g = 6
def counter: Int = {
  g -= 2
  g
}
def test() = {
  val t = ListBuffer('s','t','a','r','t',' ','e','m','p','t','y')
  var i = t mkString // returns "start empty"
  var l = ListBuffer[Int]()
  while(i != "42") i = (l += counter) mkString // returns "42 after two iterations"
  s"$i should equal 42"
}
println(test())

mkString captures the second argument as a separator, here s"$i should equal 42". So the value of $i is never "42" but goes indefinitely.

Answer 56

wxpython

"Hello World" example that fails to exit.

import sys
import time
import wx
from wx.lib.pubsub import setupkwargs
from wx.lib.pubsub import pub

class LoggerWindow(wx.Frame):
    def __init__(self):
        wx.Frame.__init__(self, None, title="Logger")
        self._log = wx.TextCtrl(self, style=wx.TE_MULTILINE)
        pub.subscribe(self.OnLogMessage, "LOG_MESSAGE")

    def OnLogMessage(self, msg):
        self._log.AppendText(msg)


class GUI(wx.Frame):
    def __init__(self):         
        wx.Frame.__init__(self, None, title="Demo GUI - Hello World")  
        self._logger = LoggerWindow()
        pub.sendMessage("LOG_MESSAGE", msg="GUI Starting")

        # Set up the Hello World message
        self._display = wx.TextCtrl(self, -1, size=(400,20), style=wx.TE_MULTILINE)
        self._display.AppendText("Hello World!")

        # Show it for a while
        self.Show()
        time.sleep(10)

        # Done
        self.Destroy()


App = wx.App()
Gui = GUI()
App.MainLoop()

The log window, while not showing, keeps existing, so the "GUI" window disappears but the app keeps running. I had intended for this to be another example of "not using a loop", but obviously I am using a loop!

Answer 57

Python

def sum(first, add=[]):
    add.append(first)
    sum = 0
    for el in add:
        sum+= el
    print sum
    return add

if __name__ == '__main__':
    #init
    add = sum(1)
    for el in add:
        sum(el)

this will loop forever due to the fact that expressions in default arguments are calculated when the function is defined, not when it’s called. So the list will grow until the user terminate the script.

Answer 58

Java

public class Looper {
    public static final int END = Integer.MAX_VALUE;
    public static final int START = END - 100;

    public static void main(String[] args) {
        int count = 0;
        for (int i = START; i <= END; i++)
            count++;
        System.out.println(count);
    }
}

This program was blatantly copied from Bloch and Gafter's Java Puzzlers.

The expression i <= Integer.MAX_VALUE is a tautology, at least if i is an int. By definition, no integer can be greater than Integer.MAX_VALUE.

Answer 59

Tcl

set i 1
while $i<=10 {
    puts $i
    incr i
}

I forgot to brace my expression, so $i will only be substituted once, when while is called

Answer 60

JAVASCRIPT

found this while doing my project

function weirdCode(){
  var myarray= ["test",123,false];
  var myarray2 = myarray;
  myarray2[2] = !myarray2[2];
  while(myarray.toString() == myarray2.toString()){
    console.log("shouldn't myarray[2] == false? but it is "+myarray[2]+". but i only edit myarray2, which is "+myarray2[2]);
  }
  console.log("this will never called");
}
weirdCode();

at line "var myarray2 = myarray;" it should be "var myarray2 = myarray.slice()", cause it will be referring the var to myarray, like sharing a var

Answer 61

JAVASCRIPT

 var x = 1; while(x != 0) x -= 0.1;

x = 1;
x - 0.1 = 0.9;
x - 0.1 = 0.8;
x - 0.1 = 0.7000000000000001
WHAT!!!!!

Now more about it

Answer 62

Java, equal but not?

import java.util.HashMap;
import java.util.Map;

public class Endless {
    static class A {
        public A(int a) {
            b = a;
        }

        int b;
        @Override
        public boolean equals(Object obj) {
            return obj != null && (obj instanceof A) && ((A)obj).b == b;
        }
    }

    public static void main(String args[]) {
        Map<A,String> map = new HashMap<A, String>();
        A a = new A(1);
        A sameA = new A(1);

        System.out.println("a is sameA?" + a.equals( sameA ));

        map.put(a, "look ma, no hands!");

        while (!map.containsKey(sameA)){
            //we never get here, do we?
        }
        System.out.println("Done!");
    }
}

Answer 63

How about a fork bomb?

:(){ :|: &};:

Answer 64

C

This one works..

#include<stdio.h>

void main(){
double a=10;
float b=10;
while(a/3!=b/3)
printf("Infinite loop");
}

Answer 65

In Ruby:

x = "a"

while ! x.equal?("aaaaaaaa")
   x += "a"
end

In Ruby, the .equal? method checks for object equality, not value equlity. "aaaaaaaa" is a unique object, and thus has a different object ID than x. Because of this the statement will never be true.

Another one:

a = b = "a"

while a == b
    b << "a"
end

Here a and b gets the reference to the same object. The << method actually changes the value at the location where the object is referencing, and does not create a new object as most other methods does. Since both a and b references the same location, the values will always be the same.

Answer 66

Powershell

I feel like counting from one to a hundred. Don't you?

$i = 1;
for($i -lt 100;$i++){$i}

...Wait a minute, that's way more than a hundred printing out...

...

...

This should be fairly simple to figure out, and I found it amusing, at least.

Answer 67

C

#include <stdio.h>

int count_bits(unsigned int field)
    {
    unsigned int a = 1;
    int count = 0;

    while (1)
        {
        switch (a)
            {
            case 1 << 31: /* MAX_UINT32 */
                {
                break;
                }
            default:
                {
                if (field & a) count++;
                a <<= 1;
                }
            }
        };
    return count;
    }

int main(int argc, char *argv[])
    {
    printf("%d\n", count_bits(0xdeadbeef));
    return 0;
    }

In C and C++ case is a jump target. The break breaks the switch, but not the while. Substituting break; with return count; will work.

Answer 68

Java, with OpenCV

(just a snippet)

VideoCapture camera = new VideoCapture(0);
Mat frame = new Mat();
while(frame.get(1, 1)[0]<200)camera.read(frame);

Java OpenCV stores pixel values from 0 to 1, not 0 to 255.

Answer 69

Lua

Totaly boring, but I thought it was still interesting:

-- Example of stack overflow using recursion
-- Function foo: this function will call itself forever: foo(foo(foo(foo(foo...
function foo() -- Our recursive function
    return foo() -- Our recursive call, this will cause the stack to overflow
end
pcall(foo) -- pcall will call foo in protected mode, catching stack overflows.
print("Stackoverflow! Avoid infinite recursion!") -- Use infinite recursion wisely

How does it work?

I dont have a clue. I think its optimized to something like:

call main
exit
label foo:
jmp foo
label main:
push foo
call pcall
push "Stackoverflow! Avoid infinite recursion!"
call print

Notes:

• This is not assembly or lua bytecode or anthing
• Exponential recursion will result in a stack overflow: foo(foo()). I think this is because this will call foo before it will jmp foo?
• Can someone please make a C function and try it out with that? I would love to know if it will result in a overflow or not. (I am guessing it will, but you never know...)

Answer 70

C++'s rules can be pesky some times

a.cpp:
#include "Shape.h" // includes class Shape, with virtual functions on it

int callback(int value, Shape* s)
{
    // aggregates areas
    return value + s->getArea();
}

// Some boring work... we don't even call this function
int aggrigateAreas(Shape* begin, Shape* end)
{
    int rval = 0;
    for (Shape* iter = begin; iter != end; iter++)
        rval = callback(rval, iter);
    return rval;
}


b.cpp:
#include "Shape.h"

int callback(Shape* s)
{
    // aggrigate perimieters
    return s->getPerimiter();
}

// doSomethingImportant will actually do something for us
int doSomethingImportant(Shape* s)
{
    return callback(s); // this was more complicated in real life
}

main.cpp
#include "Shape.h"
#include <iostream>
int doSomethingImportant(Shape* s);

int main() {
    Square s(1); // square with side length 1
    std::cout << doSomethingImportant(&s); // should print 4, right?
    return 0;
}

Sadly, C/C++ is rather unfriendly if you have two functions in different translation units with different names. They call it a ODR violation (One Definition Rule) and it's Undefined Behavior. As it so happens, if the linker is not being kind to you today, your call to callback in doSomethingImportant can end up calling the callback in a.cpp. This is bad enough, but they also don't have the same signatures. s may get some garbage value, such as something which causes the virtual function lookup of getArea() to return the address just before main, creating an infinite loop when called. It even gets a few broken opcodes just right to maladjust the stack back to its initials stack height, so you don't even get a sane stack overflow.

Is this against the rules of code golf? Maybe. I am trying to claim a win by getting very unlucky with a compiler's handling of undefined behavior. Technically that's outside of the spec of the language.

However, the scars I put into my cubicle walls that day, dug deep with my fingers as I screamed in agony remain. Dug over the course of that whole 12 hour work day, with the debugger taunting me as I went (You're {bleep}ing kidding me! Why did the debugger put me back in a.cpp again! I commented out all calls to that file wholesale! Maybe I should recompile the world again)... that has to qualify as "underhanded" somehow, right? Please?

I will not forget to open the anonymous namespace to store my callbacks

I will not forget to open the anonymous namespace to store my callbacks

I will not forget to open the anonymous namespace to store my callbacks

Answer 71

c++

A simple program, to show how operator overloading works:

EDIT: this is inspired by BF

#include <iostream>
class ops
{
public:
    int val=1;
    ops operator * (ops rhs){val++; return *this;}
    ops operator & (ops rhs){val-=3; return *this;}
};
int main() {
    ops a;
    while (a.val>0) 
    {
        a=a**&a; //call operator* twice and operator& once, net effect of subtracting 1
        std::cout<<a.val;
    }
    return 0;
}

This calls operator* once and operator& zero times. *&a is the same as a, because of pointers.

Answer 72

C#

   for (; ; )
    {
        try
        {
            string text = "SomeText";
            System.IO.File.WriteAllText(@"c:\Pathwith?.txt", text);

            break;
        }
        catch { }
    }

Answer 73

C++ - Lame

Yay I is pro C++ I learnt for loop real quik now lets make cool program that print 1 to 10 cuz I am awesome and totaly did not chose C++ just cuz C doesnt allow for loop.

#include <stdio.h> // 2 lazy 4 std::cout

int main()
{
    int i = 1;
    for (i < 10; i++;)
    {
        printf("%d\n", i);
    }
}

No why I is pro C++ why U dont work I learn for syntax well :(

upvote @fuandon instead, he gave me the idea. This is my second one anyway...