text:
Bit run rundown
Given an integer n > 0, output the length of the longest contiguous sequence of 0 or 1 in its binary representation.
Examples

6 is written 110 in binary; the longest sequence is 11, so we
should return 2
16 → 10000 → 4
893 → 1101111101 → 5
1337371 → 101000110100000011011 → 6
1 → 1 → 1
9965546 → 100110000000111111101010 → 7

OEIS A043276

Can we assume any bound of the size of the integer like 32 bit or 64 bit?

@xnor yes you can assume the int is 32 bits max

Python 2, 46 45 bytes
f=lambda n,k=1:`k`in bin(n^n/2)and-~f(n,k*10)

Try it online!
How it works
By XORing n and n/2 (dividing by 2 essentially chops off the last bit), we get a new integer m whose unset bits indicate matching adjacent bits in n.
For example, if n = 1337371, we have the following.
n    = 1337371 = 101000110100000011011₂
n/2  =  668685 =  10100011010000001101₂
m    = 1989654 = 111100101110000010110₂

This reduces the task to find the longest run of zeroes. Since the binary representation of a positive integer always begins with a 1, we'll try  to find the longest 10* string of digits that appears in the binary representation of m. This can be done recursively.
Initialize k as 1. Every time f is executed, we first test if the decimal representation of k appears in the binary representation of m. If it does, we multiply k by 10 and call f again. If it doesn't, the code to the right of and isn't executed and we return False.
To do this, we first compute bin(k)[3:]. In our example, bin(k) returns '0b111100101110000010110', and the 0b1 at the beginning is removed with [3:].
Now, the -~ before the recursive call increments False/0 once for every time f is called recursively. Once 10{j} (1 followed by j repetitions of 0) does not appear in the binary representation of k, the longest run of zeroes in k has length j - 1. Since j - 1 consecutive zeroes in k indicate j matching adjacent bits in n, the desired result is j, which is what we obtain by incrementing False/0 a total of j times.

This is really clever!

Wow, that's clever. Never could've thought of it.

Nice trick with the powers of 10, but don't they become longs with an L?

@xnor Eventually, but that's just a data type limitation. The C, JavaScript, and PHP answers also suffer from this.

This would be seriously unmaintainable if used in production. In short (ghehe) golf achieved, hole in one :)

Python 2, 46 bytes
f=lambda n,r=1:max(r,n and f(n/2,1+~-n/2%2*r))

Try it online
Extracts binary digits from n in reverse by repeatedly taking n/2 and n%2. Tracks the length of the current run r of equal digits by resetting it to 0 if the last two digits are unequal, then adding 1.
The expression ~-n/2%2 is an indicator of whether the last two digits are equal, i.e. n is 0 or 3 modulo 4. Checking the last two digits together turned out shorten than remembering the previous digit.

05AB1E, 6 bytes
b.¡€gM

Try it online!
Explanation
b       # convert to binary
 .¡     # split at difference
   €g   # map length on each
     M  # take max

HA! Finally! A use for .¡, I can stop forcing myself to try to use it.

@carusocomputing: Pretty sure I've used it in a couple of answers.

Mathematica, 38 bytes
Max[Length/@Split[#~IntegerDigits~2]]&

or
Max[Tr/@(1^Split[#~IntegerDigits~2])]&

Python, 53 bytes
import re;lambda g:max(map(len,re.findall('1+|0+',bin(g))))

Anonymous lambda function.

Jelly, 6 bytes
BŒgL€Ṁ

Try it online!
How it works
BŒgL€Ṁ  Main link. Argument: n

B       Binary; convert n to base 2.
 Œg     Group adjacent, identical elements.
   L€   Map length over the groups.
     Ṁ  Take the maximum.

Ruby, 41 40 bytes
->b{("%b%b"%[b,~b]).scan(/1+/).max.size}

Find longest sequence of '1' in b or its inverse.
Thanks to manatwork for saving 1 byte.

Not sure about other versions, but in 2.3.1 there is no need for the space between the %b's.

You are right, negative binary numbers start with "..". Thanks.

Ruby, 51 44 43 bytes
Function solution.
@manatwork is made of magic
->s{('%b'%s).scan(/0+|1+/).map(&:size).max}

Does this check for consecutive identical digits or just consecutive 0s?

Incorrect result for 893.

@orlp not anymore! :D

I would combine the 1st and 2nd solutions: ->s{s.to_s(2).scan(/0+|1+/).map(&:size).max}.

JavaScript (ES6), 54 bytes
f=(n,r=0,l=1,d=2)=>n?f(n>>1,d^n&1?1:++r,r>l?r:l,n&1):l

A recursive solution with a lot of bit manipulation. n stores the input, r stores the length of the current run, l stores the length of the longest run, and d stores the previous digit.
Test snippet

f=(n,r=0,l=1,d=2)=>n?f(n>>1,d^n&1?1:++r,r>l?r:l,n&1):l

for(var i of [0,1,2,3,4,5,6,7,8,9,16,893,1337371]) console.log(`f(${i}): ${f(i)}`)

Same idea, but using more bit operations and exploiting the default conversion of undefined to 0. Feel free to borrow: f=(x,b,n,m)=>x?f(x>>1,x&1,n=x&1^b||-~n,m>n?m:n):m

Perl, 43 bytes
#!perl -p
\@a[$a+=$_-1+($_>>=1)&1||-$a]while$_;$_=@a

Counting the shebang as one, input is taken from stdin.
Try it online!

Shebangs count as 0 bytes.

@CalculatorFeline consensus on meta is that #!perl counts as zero, not #!perl -p.

@CalculatorFeline: The -p costs 1, on the assumption that your Perl command line would have an argument anyway (e.g. -e or -M5.010), so you can slip a p in just after one of the hyphens. The #!perl is free (although unnecessary).

Good to know.  .

Python 2, 57 bytes
a=lambda n:n and max((n&-n|~n&-~n).bit_length()-1,a(n/2))

A recursive solution. There might be a shorter form for the bit magic.

Pip, 16 bytes
Seems like there's gotta be a shorter way to get the runs of same digit...
MX#*(TBa`1+|0+`)

Takes input as command-line argument. Try it online!
Explanation
     TBa          1st cmdline arg, To Binary
    (   `1+|0+`)  Find all matches of this regex
  #*              Map length operator to that list
MX                Get the maximum and autoprint it

Perl 6, 36 bytes
{(.base(2)~~m:g/1+|0+/)».chars.max}

Explanation:
{                                 }   # a lambda
  .base(2)                            # convert the argument to base 2
          ~~m:g/     /                # regex match, with global matching turned on
                1+|0+                 # match one or more 1, or one or more 0
 (                    )».chars        # replace each match by its length
                              .max    # take the maximum number

Try it online.

Haskell, 79 characters
maximum.map length.group.i

where
import Data.List
i 0=[]
i n=mod n 2:i(div n 2)

Or in ungolfed version:
import Data.List
pcg :: Int -> Int
pcg = maximum . map length . group . intToBin

intToBin :: Int -> [Int]
intToBin 0 = []
intToBin n = n `mod` 2 : intToBin (n `div` 2)

Explanation:
intToBin converts an int to a list of binary digits (lsb first). group groups contiguous sequences, such that [1, 1, 0, 0, 0, 1] becomes [[1, 1],[0, 0, 0],[1]]. maximum . map length calculates for each inner list its length and returns the length of the longest.
Edit: Thanks to @xnor and @Laikoni for saving bytes

group isn't in Prelude by default, you need to do import Data.List to use it.

Note that you can use guards in place of let: i n|(q,r)<-n`quotRem`2=r:i q. See our Haskell golf tips. quotRem can be divMod. I think you can use i 0=[] as the base case.

Using div and mod directly is even shorter: i n=mod n 2:i(div n 2).

Pyth, 7 bytes
heSr8.B

Do run length encode on the binary string, then sort it  so that the longest runs come last, then take the first element (the length) of the last element (the longest run) of the list.
In pseudocode:
'  S     ' sorted(
'   r8   '   run_length_encode(
'     .BQ'     bin(input()) ))  \
'he      '   [-1][0]

J, 21 bytes
[:>./#:#;.1~1,2~:/\#:

Try it online!
Explanation
[:>./#:#;.1~1,2~:/\#:  Input: integer n
                   #:  Binary digits of n
              2   \    For each continuous subarray of 2 digits
               ~:/       Reduce it using not-equals
            1,         Prepend a 1 to those results
     #:                Binary digits of n
        ;.1~           Cut the binary digits at each location with a 1
       #                 Get the length of each cut
[:>./                  Reduce those lengths using maximum and return

Octave, 31 bytes
@(n)max(runlength(+dec2bin(n)))

Try it online!
Explanation
This is a translation of my MATL answer. My initial plan was a different approach, namely @(n)max(diff(find(diff([0 +dec2bin(n) 0])))). But it turns out that Octave has a runlength function (which I just found out about). By default it outputs only the array of run-lengths, so the desired result is the max of that array. The output of dec2bin, which is a char array (string) containing '0' and '1', needs to be converted to a numeric array using +, because runlength expects numeric input.

MATLAB 71 bytes
m=1;a=diff(int8(dec2bin(a)));while(any(a==0)),m=m+1;a=diff(a);end;m

This converts integer variable 'a' to a binary int8 array then counts the number of times the result has to be differentiated until there is no zero in the result.
I am new here. Is this sort of input and one-liner allowed by the PCG rules?

Welcome to PPCG! By default, only functions or full programs (not code snippets) are accepted. In your case that means you need to input a with a=input('');. Also, some golfing advice: ~a instead of a==0. Do you really need int8)?

Bash / Unix utilities, 66 65 42 bytes
Thanks to @DigitalTrauma for significant improvements (23 bytes!).
dc<<<`dc -e2o?p|fold -1|uniq -c|sort -n`rp

Try it online!

@DigitalTrauma Thanks for the improvements, especially for including fold, which hasn't been in my usual arsenal.

Bash (+coreutils, +GNU grep), 33, 32 bytes
EDITS:

Minus 1 byte (removed quotes around grep expression)

Golfed
dc -e2o$1p|grep -Po 1+\|0+|wc -L

Explained
 #Convert to binary
 >dc -e2o893p
 1101111101

 #Place each continuous run of 1es or 0es on its own line
 >dc -e2o893p|grep -Po '1+|0+'
 11
 0
 11111
 0
 1

 #Output the length of the longest line
 >dc -e2o893p|grep -Po '1+|0+'|wc -L
 5

Try It Online!

AFAIK, grep forms neither part of bash nor coreutils, though is maintained and distributed by its own. Not sure about dc, but it used to be a standalone tool in the GNU world. The only one forming part of coreutils is wc.

@Moreaki, grep is POSIX, so any shell-based answer implies that it is already available. dc is not POSIX but is a standard part of almost every *Nix system around, so it is not normally mentioned as a separate dependency, too.

I reckon we're on two different trains of thoughts here: my point was not if grep was POSIX or not, my point was that the title of your submission to me indicated that one would need bash +coreutils to make your solution work, while this seems not the case. When I read it first, this information was confusing to me. If you try your solution on a macOS shipped bash shell, it won't work; and it does not matter if you installed coreutils or not; you'd need GNU grep to make it work.

@Moreaki, yep, I just imply the GNU system, when I say +coreutils, althrough that is not always the case. I've updated the title to be more precise.

Vyxal G, 4 bytes
bøef

Try it Online!
Abuses the G flag which returns the maximum value of the item on top of the stack.
b      # convert input to binary
  øef  # run_length_encoding and flatten 2D -> 1D
       # Implicitly take the largest value in the flattened array

J-uby, 41 38 bytes
~:digits&2|:slice_when+:!=|:*&:+@|:max

Attempt This Online!

Brachylog, 9 bytes
$b@b:lotl

Try it online!
Explanation
$b          List of binary digits of the input
  @b        Runs of consecutive identical digits in that list
    :lo     Order those runs by length
       tl   Output is the length of the last one

Javascript, 66 Bytes
x=>Math.max(...x.toString(2).split(/(0+|1+)/g).map(y=>y.length))

Thanks to manatwork for the code.
Explanation
x.toString(2)

Convert number to binary string.
split(/(0+|1+)/g)

Split every different character (0 or 1) (this regex captures empty spaces but they can be ignored)
map(y=>y.length)

For each element of the array get its length and put it in the returned array.
...

Convert array to list of arguments ([1,2,3] -> 1,2,3)
Math.max()

Get the largest number out of the arguments.

By crediting Value Ink's Ruby solution for the inspiration, this can be transformed into x=>x.toString(2).split(/(0+|1+)/g).map(y=>y.length).sort().pop(). Or the same length: x=>Math.max(...x.toString(2).split(/(0+|1+)/g).map(y=>y.length)).

I think you may have to add a predicate to the sort function sort((a,b)=>b-a). By default, the sort function places 10 in between 1 and 2.

Or you could use Math.max, as manatwork suggested.

Wtf, but they're numbers. JS please.

R, 45 34 bytes
max(rle(miscFuncs::bin(scan()))$l)

Fixed a silly misunderstanding thanks to @rturnbull and @plannapus.

Perhaps I'm missing something, but isn't the input supposed to be an integer, not a binary number? And we're looking for the maximum run of 0 or of 1, not just 0, right?

@plannapus I don't know honestly. Must have missed the spec completely. Fixed now.

C#, 106 bytes
n=>{int l=1,o=0,p=0;foreach(var c in System.Convert.ToString(n,2)){o=c!=p?1:o+1;l=o>l?o:l;p=c;}return l;};

Formatted version:
System.Func<int, int> f = n =>
{
    int l = 1, o = 0, p = 0;
    foreach (var c in System.Convert.ToString(n, 2))
    {
        o = c != p ? 1 : o + 1;

        l = o > l ? o : l;

        p = c;
    }

    return l;
};

And an alternative approach accessing the string by index at 118 bytes, with whitespace removed:
System.Func<int, int> f2 = n =>
{
    var s = System.Convert.ToString(n, 2);

    int l = 1, c = 1, i = 0;

    for (; i < s.Length - 1; )
    {
        c = s[i] == s[++i] ? c + 1 : 1;
        l = l < c ? c : l;
    }

    return l;
};

Wonder, 27 bytes
max.map#len.mstr`0+|1+`g.bn

Usage:
(max.map#len.mstr`0+|1+`g.bn)123

Converts to binary, matches each sequence of 0's and 1's, gets the length of each match, and gets the maximum.

Does this convert the input to binary?

oooooh I missed that part. Quick fix :P

Batch, 102 bytes
@set/a"n=%1/2,d=%1%%2,r=1+(%3+0)*!(0%2^d),l=%4-(%4-r>>5)
@if not %n%==0 %0 %n% %d% %r% %l%
@echo %l%

Port of @edc65's answer. %2..%4 will be empty on the first call, so I have to write the expressions in such a way that they will still work. The most general case is %3 which I had to write as (%3+0). %2 is easier, as it can only be 0 or 1, which are the same in octal, so 0%2 works here. %4 turned out to be even easier, as I only need to subtract from it. (%4-r>>5) is used to compare l with r as Batch's set/a doesn't have a comparison operator.

PowerShell, 78 74 73 bytes
([regex]::Matches([convert]::ToString("$args",2),'0+|1+')|% Le*|sort)[-1]

Try it online!
Ugh those .Net methods.
This just uses a regex to find (and match) contiguous sequences of ones and zeroes, then it takes the Length property (with a new pattern I found that uses a little known parameter set of ForEach-Object, to save 1 byte) of the resulting match objects, sorts them, and outputs the last one (the largest).

Dyalog APL, 22 bytes
Anonymous function train
⌈/∘(≢¨⊢⊂⍨1,2≠/⊢)2⊥⍣¯1⊢

⌈/∘(... The maximum of the results of the following anonymous function-train...
 ≢¨  the tally of each
 ⊢⊂⍨ partition of the argument, where the partitioning is determined by the ones in
 1, one prepended to
 2≠/ the pairwise unequal of
 ⊢ the argument
) applied to
2⊥⍣¯1 from-base-2 applied negative one times (i.e. to-base-2, once) to
⊢ the argument
TryAPL online!

Japt, 15 bytes
2o!q¢ c ml n gJ

Test it online! or Verify all test cases at once.
How it works
                 // Implicit: U = input integer, J = -1
2o               // Create the range [0...2), or [0,1].
  ! ¢            // Map each item Z in this range to U.s(2)
   q             //                                        .q(Z).
                 // This returns the runs of 1's and 0's in the binary
                 // representation of U, respectively.
      c          // Flatten into a single list.
        ml       // Map each item Z to Z.length.
           n gJ  // Sort the result and grab the item at index -1, or the last item.
                 // This returns the largest element in the list.
                 // Implicit: output result of last expression

Husk, 5 bytes
▲mLgḋ

Try it online!

K (ngn/k), 20 17 bytes
|//{y+x*y}\'~:\2\

Try it online!

2\ convert (implicit) input to base-2 representation
~:\ build a two-item list containing the above, and the above negated
{y+x*y}\' calculate "runs" of 1's, e.g. transform (0 1 1 1 0 1) into (0 1 2 3 0 1)
|// return the maximum element (present in either list)

Thunno 2 G, 3 bytes
ḃġḷ

Try it online!
Explanation
ḃġḷ  # Implicit input
ḃ    # Convert to binary
 ġ   # Group consecutive items
  ḷ  # Length of each group
     # Implicit output of maximum

Nekomata, 4 bytes
ƂĉŞ#

Attempt This Online!
ƂĉŞ#
Ƃ       Binary digits
 ĉ      Split into runs of equal digits
  Ş     Find the longest run
   #    Length

When there are multiple runs of maximum length, it will return the length multiple times. You can add the -1 flag to return it only once.

J, 27 bytes
>./>#&.>((1,2~:/\[)<;.1])#:

A slightly different (and unfortunately longer) approach to miles's answer.
Usage:
    >./>#&.>((1,2~:/\[)<;.1])#:893
5

Explanation
>./>#&.>((1,2~:/\[)<;.1])#:
                         #: Convert to base 2
        (               )   A fork
                       ]    Previous result
         (1,2~:/\[)         Find where each new sequence begins
                   <;.1     Cut the string of integers based on where each sequence begins and box them
    #&.>                    Count under open - open each box and count the items in it
>./>                        Open all the boxes and find the maximum value

I don't think this is valid--it isn't a function and so is a snippet.

@ConorO'Brien Okay, I'll look at it again later.

MATL, 6 bytes
BY'X>&

Try it online!
Explanation
B    % Implicitly input a number. Convert to array of binary digits
Y'   % Run length-encoding. Gives an array of values and an array of run-lengths.
     % Only the latter is needed
X>   % Maximum of array of run-lengths
&    % Next function will use its secondary default input/output specification
     % Implicitly display, only the top of the stack, as per the secondary
     % default specification

PHP, 82 bytes
<?=preg_match_all('!(.)\\1*!',decbin($argv[1]),$a);max(array_map('strlen',$a[0]));

Haskell, 74 72 bytes
x!0=[1]
x!n|m<-mod n 2,r<-m!div n 2=last(1:[1+r!!0|m==x]):r
maximum.(2!)

Try it online! Usage:
Prelude> maximum.(2!) $ 1337371
6

Not as nice and clean as the other Haskell answer, but some bytes shorter. The function (!) directly builds a list of lengths of 0 or 1 sequences by using a second parameter x to indicate whether a 0 or a 1 has been seen in the recursive call. If x matches the current bit, the head of the list is incremented (the sequence continues), otherwise a new 1 is appended (a new sequence with current length 1 starts). After building the list, maximum returns the maximum of the list, ie. the length of the longest sequence.

Getting rid of the x parameter by placing it as first element in the list seems not to save anything: (75 bytes)
f n|n<1=[2,1]|m<-mod n 2,x:r<-f$div n 2=m:last(1:[1+r!!0|m==x]):r
maximum.f

However maybe the maximum can be integrated in the function to save some more bytes ...

Retina, 50 bytes
Assumes ISO 8859-1 encoding.
Half the code is just converting to binary =/
.+
$*
+`(1+)\1
${1}0
01
1
M!`0+|1+
0
1
O`1+
1+¶

1

Try it online!
Explanation
.+
$*
+`(1+)\1
${1}0
01
1

This converts the input number to binary.
M!`0+|1+

Splits the binary into contiguous runs of 0 and 1, separated by linefeeds.
0
1

Replace all 0s with 1s.
O`1+

Sort the runs. Since all the runs are now sequences of 1s, it will order them by length, from shortest to longest.
1+¶

Replaces all sequences of 1's followed by a linefeed with nothing. This leaves only the last (longest) sequence behind.
1

Counts the number of 1s and outputs it.

C, 81 72 bytes
Implementing Dennis' idea, in C:
f(n){int m=0,l=0;for(n^=n<<1;n;n>>=1,l++)if(n&1)m=l>m?l:m,l=0;return m;}

Ungolfed:
f(n){
    int m=0, l=0;         // m: max found, l: current sequence length
    n^=n<<1;              // apply Dennis' XOR trick
    for (; n; n>>=1,l++)  // iterate each bits (shift right) until no more bits set, and inc current length
        if (n&1)          // if LSB bit set
            m=l>m?l:m,    // set m to max(m, current length)
            l=0;          // reset current length
    return m;
}

Codepad here.

67 bytes

MATLAB, 59 bytes
@(n)max(cellfun(@numel,regexp(dec2bin(n),'1+|0+','match')))

Uses a regexp to split into strings of 0's and 1's, then cellfun to get the number of elements in each match.

PHP, 61 68 bytes
<?=strlen(max(explode(0,strtr($s=decbin($argv[1]),10,"01")."0$s")));

takes input from command line argument.

convert input to binary
concat inverted binary + "0" + binary
split by 0 -> array of "11" "1111" etc.
get longest streak -> string of 1s
print string length

96 85 bytes for arbitrary length input: coubt the bits in a loop (PHP 7.1):
for($d=2;$a=&$argv[1];$n*=$d==$b=$a[-1]%2,$d=$b,$a=bcdiv($a,2))++$n<$m?:$m=$n;echo$m;

+3 bytes for older PHP:
for($d=2;$a=&$argv[1];$n*=$d==$b=bcmod($a,2),$d=$b,$a=bcdiv($a,2))++$n<$m?:$m=$n;echo$m;

or 96 81 bytes (PHP 5.6 or later with gmplib)
for($a=gmp_init($argv[1])*$d=2;$a>>=1;$n*=$d==$a%2,$d=$a%2)$m=max($m,++$n);echo$m;

manually counting the bits in a GMP number

Scala, 73 bytes
def f(a:Int,b:Int=1):Int=Math.max(b,if(a==0)0 else f(a/2,1+ ~(-a)/2%2*b))

A port of the Python 2 answer by xnor. The binary string lambda version is 2 bytes longer.

Japt, 28 bytes
¢q0 m@XlÃn gJ w¢q1 m@XlÃn gJ

Try it online!

Dyalog APL, 19 bytes
{≢⍉↑⊂⍨2≠/2,2⊥⍣¯1⊢⍵}

R, 38 bytes
max(rev(rle(intToBits(scan()))$l)[-1])

Usage:
> max(rev(rle(intToBits(scan()))$l)[-1])
1: 6
2:
Read 1 item
[1] 2
> max(rev(rle(intToBits(scan()))$l)[-1])
1: 893
2:
Read 1 item
[1] 5
> max(rev(rle(intToBits(scan()))$l)[-1])
1: 1337371
2:
Read 1 item
[1] 6
> max(rev(rle(intToBits(scan()))$l)[-1])
1: 9965546
2:
Read 1 item
[1] 7

Ended up being a bit peculiar because of the way intToBits works.
Here is an example of how it woks with 6:
> intToBits(6)
 [1] 00 01 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
[24] 00 00 00 00 00 00 00 00 00
> rle(intToBits(6))
Run Length Encoding
  lengths: int [1:3] 1 2 29
  values : raw [1:3] 00 01 00
> rle(intToBits(6))$l
[1]  1  2 29
> rev(rle(intToBits(6))$l)[-1]
[1] 2 1
> max(rev(rle(intToBits(6))$l)[-1])
[1] 2

From the help file for ?intToBits:

intToBits returns a raw vector of 32 times the length of an integer vector with entries 0 or 1. (Non-integral numeric values are truncated to integers.) [...] the unpacking is least-significant bit first.

Japt -h, 7 bytes
¤ò¦ mÊñ

Try it
¤ò¦ mÊñ     :Implicit input of integer
¤           :To binary string
 ò          :Partition on
  ¦         :  Inequality
    m       :Map
     Ê      :  Length
      ñ     :Sort
            :Implicit output of last element

Vyxal G, 23 bitsv2, 2.875 bytes
bĠ@

Try it Online!
Two can play at the G flag, binary-group-lengths game.
Quite literally ports Thunno 2, using newer features (@) than the existing vyxal answer.

x86-64 machine code, 24 bytes
Standard System V ABI, signature int rfbrr(int n) (n in edi and output in eax).
31 c0 57 5e d1 ee 31 fe f3 0f bc d6 39 c2 0f 4f c2 d1 ee 75 f3 ff c0 c3

Try it online!
Explanation
Uses @Dennis's n ^ (n >> 1) trick to reduce the problem to getting the longest string of zeros in the number plus one, then finds this by shifting through the number while it is nonzero and running tzcnt over it to count the number of trailing zeros.
rfbrr:
    ; clear eax
    xor eax, eax

    ; get m in esi with (rdi->rsi >> 1) ^ (rdi)
    push rdi
    pop rsi ; n in esi
    shr esi, 1 ; n >> 1 in esi
    xor esi, edi ; m in esi

    ; search for longest run of zeros and return that + 1
    ; m is at least 1 so we dont need to do a loop check at the start
__rfbrr_lp:
    ; trailing zero count into edx
    tzcnt edx, esi

    ; max of eax and edx into eax
    cmp edx, eax
    cmovg eax, edx

    ; shift m right by 1
    shr esi, 1

    ; if m is still nonzero, loop.
    jnz __rfbrr_lp

    ; return eax+1
    inc eax
    ret

Vyxal GG, 20 bitsv2, 2.5 bytes
bøe

GG everyone!
Try it Online!
bøe
b    # Convert number to binary.
 øe  # Perform run length encoding on the binary number.

# G flag takes the maximum value of the list (which is the longest run).
# Another G flag (because the run length encoding also has the digit that is part of the longest run) takes the maximum value of that list (guaranteed to be the run length).

Created with the help of Luminespire.

JavaScript (Node.js), 44 bytes
f=(x,i=0)=>x&1?f(~x):x&&(t=f(x/2,++i))>i?t:i

Try it online!
JavaScript (Node.js), 50 bytes
f=x=>x&1?f(~x):x&&Math.max(f(x/2),Math.log2(x&-x))

Try it online!
Equally treat 0 and 1

Vyxal 3 G, 3 bytes
bġl

Try it Online!

Uiua, 12 bytes
/↥⊕⧻⊛\+°\≠.⋯

Try it in the pad!


text:
Make me some sushi
It's lunch time, I am hungry and I came to your Sushi Bar. You are the Sushi Chef and you have to produce a full program or function to make me some sushi!
 Credits: Wikipedia
Disclaimer: The image is for illustration purposes only and do not necessarily represent the exact product.
Although you have limited ingredients (due to a truck drivers strike) it will be fine for me.
The ingredients you have (in plenty amount) are:

Nori seaweed (made with: \/_¯|)
Raw Tuna (T)
Raw Salmon (S)
Raw Avocado (A)
Sushi Rice (o)

With these ingredients you are able to make some nice makis for your clients.
Your minimum order is $1 for 2 makis, you only make makis in couples and only accept integer numbers as payment. You accept orders up to $50 per person (total input) because you are alone and you must satisfy all your clients.
You will need to get the client's orders from standard input in any reasonable format, for example: [1,T],[2,S],[3,A] which means that you have to output:

Two Tuna Makis
Four Salmon Makis
Six Avocado Makis

One maki is exactly made like this:
   _____
  /ooooo\
 |ooTTToo|
 |\ooooo/|
 | ¯¯¯¯¯ |
  \_____/

And since you are a fine Sushi Chef, you always arrange the makis with the pieces of any given type in a square shape or at most in a rectangular shape (as close as possible to a square) with no gaps. The overall shape is also square or rectangular, as close as possible to a square given the above restriction, with no gaps.
Example input/outputs:
Input: [1,T],[2,S],[3,A]

Valid Output:
  _____    _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\  /ooooo\
|ooTTToo||ooTTToo||ooAAAoo||ooAAAoo|
|\ooooo/||\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/  \_____/
  _____    _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\  /ooooo\
|ooSSSoo||ooSSSoo||ooAAAoo||ooAAAoo|
|\ooooo/||\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/  \_____/
  _____    _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\  /ooooo\
|ooSSSoo||ooSSSoo||ooAAAoo||ooAAAoo|
|\ooooo/||\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/  \_____/

Valid Output:
  _____    _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\  /ooooo\
|ooAAAoo||ooAAAoo||ooSSSoo||ooSSSoo|
|\ooooo/||\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/  \_____/
  _____    _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\  /ooooo\
|ooAAAoo||ooAAAoo||ooSSSoo||ooSSSoo|
|\ooooo/||\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/  \_____/
  _____    _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\  /ooooo\
|ooAAAoo||ooAAAoo||ooTTToo||ooTTToo|
|\ooooo/||\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/  \_____/

Not Valid Output:
  _____    _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\  /ooooo\
|ooTTToo||ooAAAoo||ooSSSoo||ooAAAoo|
|\ooooo/||\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/  \_____/
  _____    _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\  /ooooo\
|ooSSSoo||ooAAAoo||ooTTToo||ooAAAoo|
|\ooooo/||\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/  \_____/
  _____    _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\  /ooooo\
|ooSSSoo||ooSSSoo||ooAAAoo||ooAAAoo|
|\ooooo/||\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/  \_____/

Not Valid Output:
  _____    _____    _____    _____    _____    _____    _____    _____    _____    _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\
|ooTTToo||ooTTToo||ooSSSoo||ooSSSoo||ooSSSoo||ooSSSoo||ooAAAoo||ooAAAoo||ooAAAoo||ooAAAoo||ooAAAoo||ooAAAoo|
|\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/  \_____/  \_____/  \_____/  \_____/  \_____/  \_____/  \_____/  \_____/  \_____/

Not Valid Output:
  _____    _____    _____    _____    _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\
|ooTTToo||ooTTToo||ooSSSoo||ooSSSoo||ooSSSoo||ooSSSoo||ooAAAoo|
|\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/  \_____/  \_____/  \_____/  \_____/
  _____    _____    _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\
|ooAAAoo||ooAAAoo||ooAAAoo||ooAAAoo||ooAAAoo|
|\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/  \_____/  \_____/

Input: [1,S]

Valid Output:
  _____    _____
 /ooooo\  /ooooo\
|ooSSSoo||ooSSSoo|
|\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/

Valid Output:
  _____
 /ooooo\
|ooSSSoo|
|\ooooo/|
| ¯¯¯¯¯ |
 \_____/
  _____
 /ooooo\
|ooSSSoo|
|\ooooo/|
| ¯¯¯¯¯ |
 \_____/

Input: [1,A],[1,T],[1,S]

Valid Output:
  _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\
|ooAAAoo||ooTTToo||ooSSSoo|
|\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/
  _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\
|ooAAAoo||ooTTToo||ooSSSoo|
|\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/

Valid Output:
  _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\
|ooTTToo||ooTTToo||ooAAAoo|
|\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/
  _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\
|ooSSSoo||ooSSSoo||ooAAAoo|
|\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/

Input: [1,T],[1,A],[2,S]

Valid Output:
  _____    _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\  /ooooo\
|ooTTToo||ooTTToo||ooAAAoo||ooAAAoo|
|\ooooo/||\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/  \_____/
  _____    _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\  /ooooo\
|ooSSSoo||ooSSSoo||ooSSSoo||ooSSSoo|
|\ooooo/||\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/  \_____/

Valid Output:
  _____    _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\  /ooooo\
|ooTTToo||ooTTToo||ooSSSoo||ooSSSoo|
|\ooooo/||\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/  \_____/
  _____    _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\  /ooooo\
|ooAAAoo||ooAAAoo||ooSSSoo||ooSSSoo|
|\ooooo/||\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/  \_____/

Valid Output:
  _____    _____
 /ooooo\  /ooooo\
|ooAAAoo||ooAAAoo|
|\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/
  _____    _____
 /ooooo\  /ooooo\
|ooSSSoo||ooSSSoo|
|\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/
  _____    _____
 /ooooo\  /ooooo\
|ooSSSoo||ooSSSoo|
|\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/
  _____    _____
 /ooooo\  /ooooo\
|ooTTToo||ooTTToo|
|\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/

Input: [1,T],[1,S],[7,A]

Valid Output:
  _____    _____    _____    _____    _____    _____    _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\
|ooSSSoo||ooSSSoo||ooAAAoo||ooAAAoo||ooAAAoo||ooAAAoo||ooAAAoo||ooAAAoo||ooAAAoo|
|\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/  \_____/  \_____/  \_____/  \_____/  \_____/  \_____/
  _____    _____    _____    _____    _____    _____    _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\
|ooTTToo||ooTTToo||ooAAAoo||ooAAAoo||ooAAAoo||ooAAAoo||ooAAAoo||ooAAAoo||ooAAAoo|
|\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/  \_____/  \_____/  \_____/  \_____/  \_____/  \_____/

 Valid Output:
  _____    _____
 /ooooo\  /ooooo\
|ooAAAoo||ooAAAoo|
|\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/
  _____    _____
 /ooooo\  /ooooo\
|ooAAAoo||ooAAAoo|
|\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/
  _____    _____
 /ooooo\  /ooooo\
|ooAAAoo||ooAAAoo|
|\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/
  _____    _____
 /ooooo\  /ooooo\
|ooAAAoo||ooAAAoo|
|\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/
  _____    _____
 /ooooo\  /ooooo\
|ooAAAoo||ooAAAoo|
|\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/
  _____    _____
 /ooooo\  /ooooo\
|ooAAAoo||ooAAAoo|
|\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/
  _____    _____
 /ooooo\  /ooooo\
|ooAAAoo||ooAAAoo|
|\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/
  _____    _____
 /ooooo\  /ooooo\
|ooSSSoo||ooSSSoo|
|\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/
  _____    _____
 /ooooo\  /ooooo\
|ooTTToo||ooTTToo|
|\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/

Rules:

This is code-golf so the shortest code wins.
Standard loopholes are forbidden.

"You are the Sushi Man": I believe that assuming the reader is male is a manifestation of unconscious gender bias, that contributes to women and nonbinary people feeling unwelcome in tech contexts.

@GregMartin thanks for your comment. You are right. I changed the title and the text to avoid any gender specification.

Awesome, I like the changes!

In the first test case [1,T],[2,S],[3,A], is it valid or invalid to arrange them so that the top row is TTSA, the scond row is SSSA, and the bottom row is AAAA? It's not clear whether this satisfies "all the similar types close to each other"; they are certainly touching.

@GregMartin no it is not valid as you proposed, you must arrange each individual group into squares or rectangles, in your case the S and A are not. It could be SSSS, TAAA, TAAA for example.

What would we do then for the input [1,T],[1,S],[7,A]?

@GregMartin for the input [1,T],[1,S],[7,A] the output would be for example: first row TSAAAAAAA, second row TSAAAAAAA. I added this test case in the examples.

Ah ok: what do you think of this wording? "you always arrange the makis with the pieces of any given type in a square shape or at most in a rectangular shape (as close as possible to a square) with no gaps. The overall shape is also square or rectangular, as close as possible to a square given the above restriction, with no gaps."

@GregMartin I think it is clear, you have to group the same type in square or rectangle and the whole order in square or rectangle shape. In your last example [1,T],[1,S],[7,A] you can make a a 2x7, or 7x2, rectangle with 1x2 of T, 1x2 of S, 7x2 of A. Same as 2x1 T, 2x1 S, 2x7 A.

The ambiguity which I think my wording clears up is that the individual types of sushi have to be "as close as possible to a square", and this is more important than that the overall rectangle be "as close as possible to a square" if the two are in conflict. In the case [1,T],[1,S],[7,A], for example, you want the whole rectangle to be 2x9 rather than 3x6, because 2x9 is the only way to make all individual sushi types into rectangles.

@GregMartin Ah ok I see now... I thought you were asking clarification on that rather than suggesting an improvement. I will apply that suggested edit. Thanks for your help and contributions, my english is not the best :)

Python 3, 314 313 bytes
l=["  _____  "," /ooooo\ ","|oo%s%s%soo|","|\ooooo/|","| ¯¯¯¯¯ |"," \_____/ "];T=('T',)*3;S=('S',)*3;A=('A',)*3;i=eval('['+input()+']');x=sum(map(lambda x:x[0],i));m=[]
for f in i:m+=[f[1]]*f[0]
for p in 1,0:
    for j in l:
        for k in range(x):print((j%m[k]if '%s' in j else j),end='')
        print()

My attempt at this challenge. It's hard!
Sample Output:
[1,T],[1,S],[7,A]
  _____    _____    _____    _____    _____    _____    _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\
|ooTTToo||ooSSSoo||ooAAAoo||ooAAAoo||ooAAAoo||ooAAAoo||ooAAAoo||ooAAAoo||ooAAAoo|
|\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/  \_____/  \_____/  \_____/  \_____/  \_____/  \_____/
  _____    _____    _____    _____    _____    _____    _____    _____    _____
 /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\  /ooooo\
|ooTTToo||ooSSSoo||ooAAAoo||ooAAAoo||ooAAAoo||ooAAAoo||ooAAAoo||ooAAAoo||ooAAAoo|
|\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/||\ooooo/|
| ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ || ¯¯¯¯¯ |
 \_____/  \_____/  \_____/  \_____/  \_____/  \_____/  \_____/  \_____/  \_____/

Instead of using tabs you could use spaces for level one indentation and tabs for level two indentation.  This will save you 2 bytes overall.

The space in '%s' in is also unnecessary.

you don't need the space after if. Python2 would save you one indentation and also the prints ad input. maps are longer than comprehensions if you have to use lambdas.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Check if computer is connected to the internet
Write a program which, according to whether the script has access to the internet, produces an output which is "Truthy/Falsey". You may try and connect to any existing site, at your own discretion (don't use a shady site which only has 10% uptime - try to keep to above 80% annual uptime). If the site is down, your program does not have to work.
It must be a standalone program or a function. You may use libraries outside of the standard library to achieve this. Standard loopholes are forbidden. This is code golf, so the code with the shortest byte-count wins.
Example pseudocode:
function a:
    try:
        connect to internet
        return 1
    catch error:
        return 0

This is my first post on code golf, so if this violates any rules in any way or is a dupe, please alert me.
EDIT: Due to numerous suggestions, I have removed the UTF-8 byte count restriction

Instead of true and false, I recommend allowing any of our defaults for truthy and falsiness. Also, by internet, do you mean the network outside your local network? Do programs still have to work if say google is down or any other large site?

@muddyfish thanks so much for your answer! I will edit my question to be more clear :)

Byte count is usually done in the language's native or most convenient encoding, which is not always UTF-8. Unless you a have a good reason to enforce UTF-8, I think the encoding should be left at the programmer's choice

@LuisMendo I chose this to prevent ambiguity

I see almost everyone is using g.gl / http://g.gl/, but to. / http://to./ seems to be one byte shorter (not all languages see it as a valid url through).

Commodore Basic: PRINT "0"

The very machine I'm typing this at, is technically a part of the "Internet",
as it can be accessed from the outside (via NAT and port forwarding).
So, if you think of it, the "internet detection" script can probably be reduced to "true" :)

@Restioson We have a Meta question to define how to count size of programs. Enforcing counting in UTF8 is just going to make things more confusing. Also, what if someone solves this in, say, Vim? Or TI-Basic? How do you count those in UTF8?

@KevinCruijssen to (without the . at the end) also seems to work.

What is an objective definition of "80% uptime"? And is that defined to be in the last week, last month, or what?

Another thing, does the code have to check/ping live internet sites or is checking the DNS server okay? Because the DNS server being operational doesn't technically mean your computer can connect to the WWW, even if it might usually do.

@H Walters The reason I said "WWW" is because that's how I interpreted the question. If OP meant just the internet, that would be different.

@TheBitByte true. But I mean do not use a site which is only on on Thursdays, for example. Keep it sensible

@zeppelin your computer would no longer be connected to the internet, if, say, I made your means of network communication break, e.g unplugging your ethernet cable

@TheBitByte yes, checking a DNS server is OK, as long as it isn't on your local network (LAN, hosted by your local router)

It's nice that my question has mainly "mainstream" languages in answers as opposed to the usual horde of esolangs in answers.

@Restioson This is Code Golf SE. I'm not sure what answers you were expecting to get. Anyways, can I just ping the DNS server without having to ping a live WWW website? In other words, technically the ISP's DNS server working isn't always an indication of the WWW working, even if it usually is.

@Mark ? 0 (or even ?0?) should do it.  Untested - from memory.

@NobodyNada Hmm.. It doesn't for me, and I tested it on three different devices/networks. :S

@Mark - not really. There is a TCP/IP implementation for Commodore 64, and there even are network cards for C64 with embedded TCP/IP.

@KevinCruijssen seems http://to. is down now

Bash (with dnsutils), 3 bytes
Sends a DNS request for "." (DNS root), exit code is 0 for success and >0 otherwise.
Golfed
dig

Test
% dig >/dev/null; echo $?;
0

% nmcli nm wifi off
% dig >/dev/null; echo $?;
9

Disclaimer
This will obviously only work if your DNS server is sitting in the provider's network, i.e. in the "Internet" (as your provider network is normally a part of it), or if your system is using a public DNS server (like 8.8.8.8 from Google, which Android based systems use), as otherwise, you can get a cached copy from a local LAN server (or localhost).
But I assume this is not against the code-golf rules, as there are obviously more than one system where this does work as intended.
Pure-HTTP methods can also give false positives, due to an intermediate caching proxy, and are not guaranteed to work everywhere, so that is not something unique to this method.
A slightly more reliable version, 8 bytes
dig +tra

(a little tribute to @Digital Trauma !)
Enables the "trace mode", which will force dig to do the recursive search by itself (see https://serverfault.com/a/778830), avoiding any cache issues.

Quote from man dig: Unless it is told to query a specific name server, dig will try each of the servers listed in /etc/resolv.conf. If no usable server addresses are found, dig will send the query to the local host.

@Titus, yep that is correct, see "disclaimer" part of my answer, but as long as your DNS server (as specified in your resolv.conf) is on your provider's side, it works just nice.

Your solution depends on a non-default install; I woukld consider that exploiting a loophole. You can still win with the two additional bytes.

Your solution depends on a non-default install
Nope, it is exactly how it works on my machine (and that is already enough according to Meta). Moreover, using your provider's DNS server,  is a pretty common setup indeed (and it will normally be in your resolv.conf too).

@Titus there are also lots of systems around which will just use public DNS servers (like 8.8.8.8 from Google), e.g. almost every Android-based system.

defualt settigns depends on what settings you used at install time if you configured the network using DHCP then resolv.conf probably points at your router. if you configured networking manually it will have whatever DNS server you nominated.

What if you're connected to a LAN with DNS, but not the internet?  People who are trying to lookup short web sites on the internet here are going to figure out if they are on the internet versus such LAN's... this solution doesn't seem to be even trying to do that.

@HWalters

What if you're connected to a LAN with DNS, but not the internet?
Then you will (possibly) get a cached response (as described in "Disclaimer").

... figure out if they are on the internet versus such LAN'
Only if they do not have a caching proxy, like Squid, in their LAN (which is a very common setup too), in which case they will just get a cached response every time.

The point is that there is still a (considerable) number of real-world setups, that will work just nice, e.g. most Android devices will just use a public Google DNS.

@zeppelin I'm not sure we're on the same wavelength.  You're talking about cached entries here (and in your disclaimer).  And sure, if the LAN's connected and then disconnected, such creatures might indeed exist.  But that's kind of way off to the side of what I'm talking about... live DNS entries on the LAN... entries about the LAN, not generally accessible from the internet.  (Maybe WAN gives you a better image).

live DNS entries on the LAN... entries about the LAN, not generally >accessible from the internet (Maybe WAN gives you a better image).

HTTP-based method might as well fail to detect an isolated WLAN (e.g. if there is a proxy server which will return a "dummy" page, explaining that internet access is disabled in response to any "external" URI).
(which is pretty normal for a corporate WLAN).
But that is not the point, really, as long as there are at least some real-world setups, the method works for, that is just fine for the purposes of [codegolf].

Great answer! Wouldn't have thought an answer so short possible! Well done.

Bash + GNU utils, 8

5 bytes saved thanks to @Muzer.

wget to.

The other shell answers check the return code and echo some status output accordingly.  This is unnecessary.  The shell return code is already a usable Truthy/Falsey code and accessible in the $? parameter which is idiomatic for bash.  Return code 0 means True.  Return code >0 means False.
In use:
ubuntu@ubuntu:~$ wget to.
--2017-01-13 09:10:51--  http://to./
Resolving to. (to.)... 216.74.32.107, 216.74.32.107
Connecting to to. (to.)|216.74.32.107|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 11510 (11K) [text/html]
Saving to: ‘index.html.6’

index.html.6        100%[===================>]  11.24K  --.-KB/s    in 0.04s

2017-01-13 09:10:51 (285 KB/s) - ‘index.html.6’ saved [11510/11510]

ubuntu@ubuntu:~$ echo $?
0
ubuntu@ubuntu:~$ sudo ifconfig ens33 down
ubuntu@ubuntu:~$ wget to.
--2017-01-13 09:11:00--  http://to./
Resolving to. (to.)... failed: Temporary failure in name resolution.
wget: unable to resolve host address ‘to.’
ubuntu@ubuntu:~$ echo $?
4
ubuntu@ubuntu:~$ sudo ifconfig ens33 up
ubuntu@ubuntu:~$ # Local network up, upstream link down
ubuntu@ubuntu:~$ wget to.
--2017-01-13 09:11:34--  http://to./
Resolving to. (to.)... failed: Name or service not known.
wget: unable to resolve host address ‘to.’
ubuntu@ubuntu:~$ echo $?
4
ubuntu@ubuntu:~$

Use a domain like to. rather than 8.8.8.8, to save quite a lot.

@Muzer yes - thanks

Needs to have the dot at the end I'm afraid, otherwise it searches on your local network.

@Muzer unless there is a local to that the resolver is configured to find, it will still go to the right one (and maybe being able to ping a local to is enough of being connected to the internet)

@Muzer OK, to sometimes works and sometimes not.  I guess some caching going on.  I'll use to. just for safety.

Why is that a valid domain?

This doesn't work for me: https://hastebin.com/uviceyomiw.pas, maybe it's a Ubuntu thing?

@Kos because there's no reason it wouldn't be valid?

Batch, 8 bytes
ping to.

ping will set ERRORLEVEL to 1 if the address cannot be resolved or reached.

05AB1E, 11 9 bytes
Saved 2 bytes on "to." courtesy of ev3commander
…to..wgX›

Checks if the length of the content at http://to. is greater than 1.
.w returns 0 on error.

Always a +1 for 05AB1E answers

@WorseDoughnut And why is that?

@mbomb007 Just been a huge fan of the language since Adnan starting working on it and posting it here; it's definitely a fascinating language to delve into.

@WorseDoughnut There's already a hyperlink in the answer.

Can't you connect to http://to./ to save a byte?

@ev3commander: Apparently I can. Didn't work when i tried yesterday but it does now. Thanks :)

R, 20 bytes
curl::has_internet()

There's a function for exactly this task in the curl package.

+1 nice find. For those curious like me, this function is implemented as: function() !is.null(nslookup("r-project.org", error = FALSE))

Equivalent count: httr::url_ok('g.gl') (albeit deprecated).

@JonathanCarroll if you used 'to.' in that it would be one byte less :)

Bash 66 62 21 bytes
ping -c1 g.gl echo $?

Thanks @Alex L. for the URL shortening tip.
Ungolfed version:
r=$(ping -c1 g.gl)
if [ $? -ne 0 ];
 then echo "0"
else echo "1"
fi

This is my first answer in Bash , i'm not sure i have shortened the script enough.

I think you can use a shorter URL than google.com, which would allow you to shorten the code. Something like g.gl.

You should also be able to just echo $? instead of that whole if statement.

you missed "some" ; in the golfed line.

@IporSircer Thanks. :)
@SomethingDark Hello, echo $?  prints a 0 if success, or else it returns a 2 in this case. I have not looked into source code of the implementation of ping but i am assuming, there are different return codes depending on the stuation. Hence, i used if else strategy.

@AbelTom - it could be argued that 0 is truthy and non-0 is falsey.

@SomethingDark Haha, i tried to negate the return value too, but I could not and don't know how. 0 is accepted as truthy? i mean would that be compliant with the spec ?

Yeah, bash traditionally considers 0 to be success and everything else to be a failure

Also, I'm not sure why you're setting a variable at all; you can just say ping -c1 g.gl;echo $? (or to. instead of g.gl like some other people are doing)

@SomethingDark I actually wanted to do that initially, but i thought output should be only either 0 or 1. There's some unwanted text too when i run this program, thats the reason i stored it in a variable.

14 bytes, using -a (audible bell) for Truthy: ping -ac1 g.gl

Java, 72 bytes
a->new java.net.InetSocketAddress("to.",80).getAddress().isReachable(9);

MATL, 15 14 bytes
One byte saved thanks to Kevin Cruijssen's suggestion
'http://to.'Xi

Output is through STDOUT. This displays a non-empty string containing non-zero chars (which is truthy) if there is an Internet connection; and displays nothing (which is falsy) if there's no connection.
This can't be tested online because the Xi is not allowed in the online interpreters.
Explanation
'http://to.'  % Push this string
Xi            % Return contents of that URL as a string. If there is no Internet
              % connection this gives an error, with no output on STDOUT

Would you consider urlread('http://g.gl') to be an OK answer by itself? It will error and leave the workspace empty if the connection is down. It will display an error message, but technically that's to STDERR...? I thought it was a bit of a stretch, so I did it this way. But skipping try seems to give the same result as your code, or? You leave the stack empty too don't you? Nice answer by the way... :)

@StewieGriffin Thanks! Yes, I think urlread('http://g.gl') is valid (and is the same as my code does), as STDERR is ignored by default, and an empty STDOUT is falsy in MATLAB

would this work with ftp instead of http - save another byte?

@Floris Nice to see you also here! Unfortunately ftp doesn's seem to work for that site

Hello @LuisMendo yes I sometimes prowl other sites... too bad the ftp doesn't work!

C#, 87 bytes
_=>{try{new System.Net.WebClient().OpenRead("http://g.gl");return 1;}catch{return 0;}};

If an exception is considered falsey, which I don't think it is, then this is 65 bytes:
_=>new System.Net.WebClient().OpenRead("http://g.gl").ReadByte();

I also tried using the link http://to. as stated by @KevinCruijssen but it didn't seem to work.

8th, 23 21 bytes
Two bytes saved thanks to Kevin Cruijssen's suggestion and to my discovery: http://to seems to work as well as http://to. (saving another byte)
"http://to" net:get .

If site http://to can be reached, it then prints true. Otherwise it prints false.
It leaves retrieved data on the stack.

TOS means top of stack. i think you mean it just leaves data on the stack.

That's right. I improved my explanation. Thanks.

@ev3commander Have you tried with http://to ? It works in my case (I see an Apache2 Ubuntu Default Page). It seems that there is no need to append '.' or '/'

Perl, 15 bytes
print`curl to.`

Run with:
perl -e 'print`curl to.`' 2> /dev/null

curl outputs stuffs on STDERR, don't mind them. If the computer has access to internet, it will print a few lines of html (truthy), otherwise, it will print nothing (falsy).
Saved 1 bytes by using to. (instead of my previous b.io) thanks to @Kevin Cruijssen.

Couldn't you switch to bash and remove the print?

@BlueRaja-DannyPflughoeft Yup, that would work (there is already a answer in bash though (they use wget instead of curl but it's the same thing)).

Javascript, 16 bytes
navigator.onLine

Returns true or false.
Try It!
I'm new here, so IDK if I counted bytes properly, or if builtins are cheating...

Hi! Welcome to CGCC! I suggest adding a place where we can try this online (usually, we link Try It Online!, but feel free to link anywhere else).

Bytes have been counted correctly. Also, builtins are not cheating unless the challenge disallowed it (which it does not).

MATLAB, 32 22 bytes
urlread('http://g.gl')

Explanation:
If the internet connection is up, this will result in ans (the default variable) being a string with the entire html-code in plain text (which is true in MATLAB).
If the internet connection is down, this will write an error message to STDERR and leave the workspace empty (which is false in MATLAB).
Unfortunately, urlread requires a full url-address, so g.gl is not enough. 11 of the 22 bytes are therefore just the url-address.

Alternative approach:
A solution that catches the error and leave a 0 (also false) in the workspace if the connection is down:
0;try urlread('http://g.gl'),end

0; initializes the default variable ans to 0, which is false in MATLAB. Then we try to read the url. This will give an error if the internet connection is down, or a character array if not (which is true in MATLAB).
We don't need to catch anything, so we just end. If the urlread call was successful, then ans will be a long string with the content of the website, otherwise ans=0.

Bash, 39 bytes
exec 4<>/dev/tcp/to./80&&echo 1||echo 0

! exec 4<>/dev/tcp/to./80;echo $?

or if you don't need to print true/false but can just return it,exec 4<>/dev/tcp/to./80

JavaScript ES6, 71 43 bytes
fetch``.then(a=>alert(1)).catch(a=>alert``)

Alerts 1 if online, alerts an empty string if offline. Thanks to Patrick Roberts for helping me shave off some bytes
Old version
_=>fetch('http://enable-cors.org').then(a=>alert(a)).catch(a=>alert(0))

Alerts [object Reponse] if online, alerts 0 if offline
Removed the code snippet, it doesn't work because it loads from a different domain without CORS, but it works in the browser console

Hmm. This correctly prints "true" when I'm connected, but it doesn't print anything if I disconnect and run it in my browser. What browser/OS did you test this in? I'm using chrome-win7

@DJMcMayhem How's your cache?

@DJMcMayhem I tested in Chrome, Win10. Disabled cache from the network tab and checked Offline to test offline/online

This can be a full program in 52 bytes: fetch('://to.').then(a=>alert(1)).catch(a=>alert(0))

Doesn't navigator.onLine work?

Mathematica 10 Bytes
Assuming you have a valid copy of Mathematica, and login credentials on user.wolfram.com
CloudPut@1

will write the value 1 to the cloud.
Truthy: CloudObject[""]
Falsey: $Failed
CloudGet@%

Will return the value 1 that was uploaded to the cloud.

Note that, by default, REPL snippets are not allowed. Put & afterwards to make it into an unnamed function.

Can you point me to a link?

See Default for Code Golf: Program, Function or Snippet?.

In my opinion, this is the best answer here. But does Cloud object count as truthy? I would say that the 1 in the cloud is truthy, though. Nice answer!

@LegionMammal978, I can put the code, as is, in a .wl package file and run it as a "program" as allowable per the original question.  Ordinarily these sorts of questions call for a function with inputs; no user input is necessary.  Furthermore, testing of my truthy/false as a function works just as well with or without the &.  In CloudPut@1&===$Failed the & makes absolutely no difference. Lastly, the program both returns and prints the output, so it is not in fact a REPL snippet as you suggest.

@KellyLowder Look up Mathematica scripts. In full programs, only values outputted with Print are actually put on STDOUT.

PHP, 23 PHP + Curl, 14
Using PHP's backtick operator:
<?=`curl to.`;

Orignal answer:
I will try to make a start:
<?=file('http://x.gl');

This outputs nothing if x.gl can't be reached and Array if it is.
Another version where I'm not quite sure if they fit:
<?=getmxrr('x.gl',$a);  // 22 chars

Re "is that a loophole", I think the normal consensus is that it counts as a language dialect (so the answer is PHP + Curl, 15 bytes).

Does an array count as truthy? I'll allow it to compete anyway though, since it is my question. Just out of interest.

@Restioson php converts an array to the string "Array" when you try to print it (<?=) and boolean false will be converted to "". So the actual return value is not an array but a non empty string or an empty string.

@Cristoph I don't think "Array" counts  as truthy or falsey

@Restioson It's a string that implicitly converts to boolean true. A branch if ("Array") echo 'thruthy'; would be taken therefore it's truthy. The empty string wouldn't take the branch and is therefore falsey.

@Cristoph ah OK. Most langs I've  seen do not do this afaik

Powershell, 64 26 23 bytes
Saved 38 bytes, thanks to Shawn Esterman
Saved 3 bytes, and repaired script, thanks to briantist
Test-Connection -q g.gl

Test-Connection -Quiet to.

PowerShell can't resolve to., you'd have to use g.gl instead. Additionally you can shorten it to Test-Connection -q g.gl.

JavaScript ES6, 90 81 Bytes
f=a=>{i=new Image();i.src="//placehold.it/1x1";i.onload=b=>a(1);i.onerror=c=>a()}

JavaScript ES6, 22 21 bytes (Invalid)
Some browsers don't fully support, or produce the expected result when using navigator.onLine.
f=a=>navigator.onLine

This answer implies that this won't always return false when not connected to the internet

You can save a byte by adding a parameter to the lambda, like so: f=a=>

Although your answer still seems to be invalid, you can get rid of f=.

78 bytes: a=>{with(new Image()){src="//placehold.it/1x1";onload=b=>a(1);onerror=c=>a()}}´ (got rid of f=and usedwith(){}`)

Scala, 54 bytes
x=>(Runtime.getRuntime exec "ping -c 1 ai."waitFor)<1

Pretty simple; executes a ping command to http://ai./, and returns true if it exits with 0, or false otherwise.

Python 3 + requests, 59 55 53 39 bytes
There has to be a requests answer, right?
from requests import*
get("http://to.")

Exit status is 0 for internet, 1 for no internet. Example:
$ python inet.py
$ echo $?
0
$ # Remove ethernet cable
$ python inet.py
$ echo $?
1

Changelog:

-4 bytes (thanks Mego)
-14 bytes (thanks pppery)

You could shorten this by using a different protocol (ftp, perhaps), and doing except:0/0.

@Mego I think requests only does http(s). I've added the 0/0.

Why is the try-except statement necessary?

@pppery Umm, yes. Thanks for pointing it out. I have no idea. Must have been a relic of the original solution.

Vyxal, 8 bytes
`g.gl`¨U

Wait, ¨U exists?
Doesn't work on the online interpreter. Exits with error for falsy, runs successfully with no output for truthy.
`g.gl`   # string literal g.gl
      ¨U # GET request to that URL

For fun, here's a fairly cheaty version. Ports JavaScript:
Vyxal E, 13 bytes
`ƈ⌈(₍†.on¬ḣ)`

Try it Online!
Just runs the JavaScript alert(navigator.onLine) using the E flag

I thought it was ¨G

You can use the url \to.`` for one byte less.

Python 2.7, 70 77 Bytes
from urllib import*
a=1
try:urlopen('http://to.')
except:a=0
print a

import urllib as l
try:
 l.urlopen('http://a.uk')
 print 1
except:
 print 0

Uses 1 for truthy, 0 for falsy.  a.uk redirects to a motorbike clothing company.  Saved 3 bytes by assigning to a variable and printing that. And another one for the "to." trick (confirmed to work with urllib), two for getting rid of the pesky indents.

I think from urllib import* could save a char (and drop l. of course).

@NickT I forgot you could drop the space between import and * so I think you're right but I'm on mobile and I'll fix it later

Elixir, 33 bytes
{:ok,_}=:inet.getaddr('to',:inet)

0 if connected, 1 otherwise.

Julia + Bash (with dnsutils), 10 bytes
run(`dig`)

`command` in julia creates a cmd object that can be run with run.

PowerShell, 12 bytes
!!(irm g.gl)

Arturo, 21 bytes
download"http://x.gl"

Outputs via exit code.

R, 18 bytes
(2 bytes shorter than the previous R answer; additionally, this solution does not require an external package to be installed.)
!is.null(nsl("a"))

Try it online!
The nsl function looks up the IP address of a hostname. If there is no Internet connection, it outputs NULL, otherwise it outputs an IP address.
Note that we do not need to specify an existing domain name: when the domain name does not resolve (and as long as it does not end in a .), the domain name is instead appended to the server domain name. So we can use any 1-letter domain name, and the output of nsl is the non-NULL server IP. I think this behaviour is not specific to R.

Scratch (scratchblocks3 syntax), 32 bytes
define
say(translate(1)to(Zulu v

"1" on success and an empty string on failure. Relies on Google Translate.
(Also, a slightly more amusing solution that actually outputs "true" but was unfortunately not optimal:)
define
say(translate(gwir)to(English v

Wouldn't translating to Lao be shorter, or does Scratch not support it?

@Restioson Scratch doesn't support Lao, for some reason. The shortest language names are Thai and Zulu

Clojure, 49 bytes
#(try(slurp"http://to.")1(catch Exception _ nil))

Returns 1 if it can connect, and nil otherwise.
Just attempts to slurp the page; throwing a NoRouteToHostException exception on failure, which is caught.
Unfortunately, the protocol and dot seem to be mandatory.

Javascript (Nashorn), 61 bytes
print(new java.net.InetSocketAddress("to.",80).getAddress())

Based on Huntro's Java answer.

Lua, 90 bytes
_,c=require('socket.http').request('http://g.gl')if string.find(c,'not')then os.exit(1)end

Sends a request to g.gl - exits with code 1 if can't connect

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Find five friends to eat chicken with Paul
Paul is one of your Belgian acquaintances, and he would like you to create a program that outputs at least one of the following five strings:
12496=>14288=>15472=>14536=>14264

14264=>12496=>14288=>15472=>14536

14536=>14264=>12496=>14288=>15472

15472=>14536=>14264=>12496=>14288

14288=>15472=>14536=>14264=>12496

It represents the friends he's most proud of, and he would like to eat with them. Paul also thinks that the number 6 is perfect, and that is the only number worth using. So you cannot use any other digit than "6" in your code (0 to 5 and 7 to 9 are forbidden). Your program cannot take any inputs. The output can contain garbage before and/or after the string but should contain at least one of the above strings.
For example this is a valid output :
220frefze
f**14288=>15472=>14536=>14264=>12496**fczfe fz**15472=>14536=>14264=>12496=>14288**zfe
fzehth

I "ligthly" hinted in the question as how I expect this to be resolved, but how knows ? Maybe there is a better way... Hope you have fun.
This is code-golf : lowest score in bytes wins.

Related OEIS sequence.

I can't figure out what Paul or chickens have to do with this.

@carusocomputing : The sociable chain '12496=>14288=>15472=>14536=>14264" was found by Paul Poulet, in 1918 (a belgian mathematician). And "poulet" means "chicken" in french. Also 6 is a perfect number in the sense that the sum of its divisor is 6.

Wait, so a manchicken found a sequence of numbers in 1918... and we care more about the number sequence than the mathematical manchicken named Paul?

I have a feeling my 4-byte answer isn't precisely what you were shooting for. Feel free to remove the garbage output rule.

@Dennis, well this is true, I was'nt expecting a bruteforce 4 byte answer, you're always a surprise :p  I added this rule because I was hoping to give an edge if someone was iterating over integers and outputing all found sociable chains without hard coding a complicated number first. But in the end it seem to favor greatly base conversion, and character conversion even in non golfy language. I think designing question is really hard ! Still, Enigma used the property of the output and has the higher score so far :)

05AB1E, 18 17 bytes
•w[•Y·FDÑ¨O})„=>ý

Try it online!
Explanation
•w[•                # base 214 encoding of 12496
    Y·F             # loop 2*2 times
       D            # duplicate top of stack
        Ñ           # push divisors
         ¨          # remove the last element (itself)
          O         # sum
           }        # end loop
            )       # wrap in list
             „=>ý   # join list on "=>"

In short, we calculate each number as f(n+1) = sum(divisors(f(n)) - f(n)

Pyke, 16 bytes
wヰw$VDlsh)J"=>

Try it here!
wヰ             -  12496
  w$            -   4
    V    )      -  repeat ^:
     D          -   duplicate(^)
      l         -     factors(^)
       s        -    sum(^)
        h       -   ^ + 1
          J     - v.join(^)
           "=>  -  "=>"

Anytime a string literal is at the end of a program, it swaps it with the token just before it, saving 1 byte in cases such as this. Pyke's factors function doesn't include the number itself nor 1. If numbers were allowed, 1 byte could be saved by replacing w$ with 4
Pyke, 21 bytes
uバ㟐㱰㣈㞸J"=>

Try it here!
Create a list of the numbers required and joins them. Not very interesting apart from the trick with the strings.

MATLAB, 44 bytes
['','=>@EBIJ=@>DDIJ=A@C>IJ=@A?BIJ=@>B@'-6-6]

Try it online!
I haven't found a pattern in the numbers (and it would be hard to use the pattern to anything anyways, since I can't use numbers), so I'll just go for the naive approach.
'=>@EBIJ=@>DDIJ=A@C>IJ=@A?BIJ=@>B@' is the string '12496=>14288=>15472=>14536=>14264' when 12 is added to the ASCII-values. Now, input that string, subtract 6+6, and concatenate with the empty string '' to convert it to a character array.

Yeah, sorry, I wanted to prevent the hard coding of number, but it's sure giving an edge to 'golfy' language. There is no pattern although each number is the sum of the divisor of the previous one.

I like the way the coded string still contains =>.

JavaScript (ES6), 57 bytes/47 (UTF-8) characters
Thanks to user5090812 for 10 B save
_=>[...'バ㟐㱰㣈㞸'].map(a=>a.charCodeAt()).join`=>`

Explanation
First we create an array and fill it with the characters in the string バ㟐㱰㣈㞸. Then we loop over the string (a has the value of the current element) and we change the character into its character code. Then we join all values in the array by =>.
Old: 67 bytes
_=>[6,6,6,6,6].map((_,a)=>`バ㟐㱰㣈㞸`.charCodeAt(a)).join`=>`

Explanation
First we create an array of length 5. Then we change the values of the array at each index for the character code of the character at that same index in the string バ㟐㱰㣈㞸, which are the numbers of all of Paul's friends in order. When we got that, we join the array together, and we use => as separator.
Usage
To use it, simply run this:
f=_=>[...'バ㟐㱰㣈㞸'].map(a=>a.charCodeAt()).join`=>`;alert(f())

Output
12496=>14288=>15472=>14536=>14264

How about _=>[...'バ㟐㱰㣈㞸'].map(s=>s.charCodeAt()).join`=>`

@user5090812 Thanks for the suggestion!

Ruby, 36 bytes (26 characters)
p"バ㟐㱰㣈㞸".unpack("U*")*"=>"

Because, why not. Boring as hell.
older version - 53 bytes
p %w(jol mld oim n6b mke).map{|x|x.to_i ~-6*~-6}*'=>'

Explanation: encoding the numbers in base 25 gives the 5 six-free strings, to decode them I only have to represent the number 25 using only 6: (6-1)(6-1) => ~-6~-6

I count 36 bytes with UTF8, not 26.

I guess he counted the characters, and not the bytes. I always use this site for byte counts.

Corrected count now.

Perl 6, 63 59 bytes

{$/=6;$/--;join "=>",<JOL MLD OIM N6B MKE>».parse-base($/*$/)}

{join "=>",<JOL MLD OIM N6B MKE>».parse-base(--($_=6)*$_)}

Decodes the numbers from base 25, because that's the only base supported by .parse-base (2 to 36) where none of them have invalid digits.
Thanks to Neil for -3 bytes.
Perl 6, 82 75 bytes

{my \a="BXS".parse-base(6*6);join "=>",(a,{sum grep $_%%*,^$_}...^{$_==a if $++})}

{my \a="BXS".parse-base(6*6);join "=>",({$/=$_//a;sum grep $/%%*,^$/}...a)}

Decodes the number 15472 in base 36, and then generates the sequence by calculating each number as the sum of proper divisors of the previous number.
Perl 6, 69 bytes (47 characters) - noncompeting
{"{١٢۴۹6}=>{١۴۲۸۸}=>{١۵۴۷۲}=>{١۴۵۳6}=>{١۴۲6۴}"}

Doesn't use any of the forbidden ASCII digits, uses Unicode digits from the Arabic-Indic block instead (2 bytes each)! The { } string interpolations make sure they're parsed as Perl 6 number literals, and then stringified to their ASCII representations.
Okay, this is cheating - that's why I didn't use it as my main answer... :)

Since I don't readily have access to a Perl 6 interpreter, does it work to write --$/*$/?

@Neil: It does. Thanks! In fact, it even works if I inline the assignment, like --($/=6)*$/).

Jelly, 5 4 bytes
ȷṗȷỌ

Prints all five strings. Takes advantage of the fact that "garbage" output is allowed and buries the five strings in 103003 characters of output.
How it works
ȷṗȷỌ  Main link. No arguments.

ȷ     Set the return value to 1000.
 ṗȷ   Cartesian power; form all arrays of length 1000 that consist of integers in
      [1, ..., 1000].
   Ọ  Unordinal; convert all integers to characters.

What's the byte offset of the required string within the output?

Is there any proof to support any one of the required strings is actually printed?

@Neil The character offset should be 48049051056053060061048051049055055060061048052051054049060061048051052050053060061048051049053051000. Not sure about bytes.

@EriktheOutgolfer If by actually you mean with reasonable time and memory constraints, then no. The challenge doesn't specify any limits though, and they're unlimited by default.

@Dennis No, I mean ever. Of course it's implied it won't finish its job anytime soon. Judging by the code, though, I think that it's really unlikely to ever print any of those strings. Then, again, I just thought of some reasonable proof...

@EriktheOutgolfer The proof is actually quite straightforward. The output contains all strings of length 1000 that consist of Unicode characters 1 to 1000.

@Dennis Yeah, that's exactly what I thought of. The problem is, well, I'm not Dennis.

C, 94 84 77 Bytes
Stoopid simple.  Special thanks @Neil
g(){char*m="!mnpuryzmpnttyzmqpsnyzmpqoryzmpnrp";for(;*++m;)putchar(*m-66+6);}

f(){printf("%d=>%d=>%d=>%d=>%d",'~''r'-'d','~''d'-'h','~''r'-'L','~''z'+'d','~'*'t'-'P');}

At least on ideone, you can move the char*m inside the for() to save a byte, and it also makes the function reusable (necessary condition of functions). Also, you output a trailing null; *++m would fix that. Also, you can save some bytes by subtracting 60 instead of 66: g(){for(char*m="!mnpuryzmpnttyzmqpsnyzmpqoryzmpnrp";*++m;)putchar(*m-66+6);}.

Or you could copy the approach from the MATLAB answer, which would save another byte on top of that.

@Neil my compiler won't let me declare inside of the for loop initial declaration used outside C99 mode but I'm happy to simplify the putchar.  Thanks!

PHP, 73 63 60 bytes
for(;$c="|`*X6H-$*@"[$i];)echo!!$i&++$i?"=>".!!6:"",ord($c);

Run with -nr.
a little less lazy: took string as list of =>1(ascii)(ascii)
i.e.: 124,96,=>1,42,88,=>1,54,72,=>1,45,36,=>1,42,64;
print =>1 by string index, append ascii code
breakdown
            # loop through string with index $i
for(;$c="|`*X6H-$*@"[$i];)echo
            # string ascii values: 124,96,42,88,54,72,45,36,42,64
    !!$i        # true if $i>0
    &++$i       # odd if (old) $i is 0,2,4,6,8
                # -> true for 2,4,6,8
        ?"=>".!!6   # if true, print "=>1"
        :"",        # else print nothing
    ord($c);    # print ascii value

C++, 92 bytes
#include <cstdio>
int main(){for(char c:"UVX]ZabUXV\\abUYX[VabUXYWZabUXVZX")putchar(c-6*6);}

PHP, 53 bytes
<?=join('=>',unpack('v*',gzinflate('�`p������s')));

Hex dump:
00000000: 3c3f 3d6a 6f69 6e28 273d 3e27 2c75 6e70  <?=join('=>',unp
00000010: 6163 6b28 2776 2a27 2c67 7a69 6e66 6c61  ack('v*',gzinfla
00000020: 7465 2827 bb60 70c1 bcc0 e684 c50e 7300  te('.`p.......s.
00000030: 2729 2929 3b                             ')));

Output:
12496=>14288=>15472=>14536=>14264

Explanation:
Each of the five-digit integer sections is encoded as an unsigned short little endian, then concatenated together and the result is gzipped. This happens to produce a byte steam that has no offending digit characters, which is then hard-coded into a string. To extract, un-gzip the stream, unpack the two-byte shorts, interpret each as a string, and join with >=.

how about a breakdown?

Java 8, 134 bytes
Golfed:
()->{String s="";for(String a:new String[]{"JOL","MLD","OIM","N6B","MKE"}){if(!s.isEmpty())s+=("=>");s+=Long.valueOf(a,25);}return s;}

Ungolfed, full program:
import java.util.function.*;

public class FindFiveFriendsToEatChickenWithPaul {

  public static void main(String[] args) {
    System.out.println(toString(() -> {
      String s = "";
      for (String a : new String[] { "JOL", "MLD", "OIM", "N6B", "MKE" }) {
        if (!s.isEmpty()) s += ("=>");
        s += Long.valueOf(a, 25);
      }
      return s;
    }));

  }

  private static String toString(Supplier<String> s) {
    return s.get();
  }

}

Batch, 191 bytes
@set/as=n=66*(66+66+66+6*6)+66/6+66/6+6,u=6/6
@call:t
@call:t
@echo %s: ==^>%
@exit/b
:t
@call:c
:c
@for /l %%i in (%u%,%u%,%n%)do @set/an-=%%i*!(%n%%%%%i)
@set/an=-n
@set s=%s% %n%

I estimate that it would take a minimum of 32 bytes to calculate each number using only 6s plus another 32 to print them all out, which is already 192 bytes, so I'm winning by computing the amicable chain. Also, I think five %s in a row is a record for me. Also, neat Batch trick: the %n% is substituted before the for loop is evaluated, so the loop calculates all the factors of n, and subtracts them from n, thus resulting in the negation of the desired result.

Jelly, 12 bytes
“<ọ’ÆṣÐĿj“=>

Prints the fourth string and nothing else.
Try it online!
How it works
“<ọ’ÆṣÐĿj“=>  Main link. No arguments.

“<ọ’          Yield the 1-based indices of '<' and 'ọ' in Jelly's code page, i.e.,
              [61, 222], and convert the array from base 250 to integer.
              This yields 15472.
      ÐĿ      Iteratively call the link to the left until the results are no longer
              unique and return the array of all unique results.
    Æṣ        Compute the proper digit sum of the previous value (initially 15472).
        j“=>  Join, separating by the string "=>".

Python 2, 78 72 bytes
print''.join(chr(ord(x)-6-6)for x in'=@>DDIJ=A@C>IJ=@A?BIJ=@>B@IJ=>@EB')

Edit - Thanks to Stewie Griffin for saving 6 bytes!
Also, another solution would be to output all the possible permutations. OP says garbage is fine.
from itertools import permutations
print str(list(permutations(''.join(str(x)+'.'for x in range(int('9'*5)).replace(',','').replace('\'','')
# also 9 and 5 need to be converted using ord and chr

There is too much redundancy in converting from int or list to str. I guess this would be easier in some esoteric languages, but I know none of them.

Could you add 66 instead of 12? This would save another byte.

It will go out of the normal ASCII-range @GB, meaning you would have to count two bytes per character.

I see, I didn't count the '=>' characters.


text:
Expose nondeterminism resulting from the OS thread scheduler
As we all know, modern operating systems have thread schedulers that can pick different orders to schedule your threads based on internal logic which your code is not privy to. Normally you architect your multithreaded code to ensure that this nondeterminism imposed on you does not meaningfully affect your output.
The goal here is the opposite. Produce a program which prints the integers in the interval [0,99] but in an order which will vary from run to run due to the OS thread scheduler.
You must achieve "enough nondeterminism", defined as:

In 10 sequential sets of 10 trials your program must produce at least 9 unique permutations within each trial. You may have a reasonable number of failed sets of trials on either side of the consecutive 10 which succeed.
Or, to put it another way, you need 100 runs of your program where each block of 10 runs has at most two runs which output the same thing.

So, occasionally swapping 98 and 99 won't cut it.
This is a code-golf, so the answer which uses the fewest bytes wins.
Minutiae

Write your output to stdout, one entry per line
If you mangle the format by having two threads interleave character writes to stdout (even occasionally) resulting in things like three digit numbers or empty lines, your result is invalid
The only exception to the above rule is that you may emit a single empty line after printing the last required number (you're welcome)
If you ever miss or duplicate any required values your result is invalid
Your program does not need to be nondeterministic on a single core processor (though kudos if it is)
Your program may use green threads/fibers which are not actually managed by the OS kernel iff it still meets the other requirements of the challenge and the threading system is part of your language or the standard library for your language
Runtime for your program must be reliably under 5 seconds on a modern processor
You do not get to specify changes to the environment which happen outside of your program such as waits or settings changes; your program should pass whether run 100ish times back to back or with an hour between each run or 100ish times in parallel (that would probably help actually...)
You may use a coprocessor such as a GPU or Xeon Phi and its own internal scheduling mechanism for tasks. The rules apply to this the same way they apply to green threads.
Feel free to provoke the scheduler with all manner of sleeps, yields, and other tricks as long as you obey the rules specified in this post

Banned Operations
The only source of nondeterminism you are allowed to draw on is when the scheduler schedules your threads to run. The following list is not exhaustive, intended only to provides examples of things you are not allowed to do as they admit other sources of nondeterminism.

Directly or indirectly accessing any sort of PRNG or hardware RNG capability (unless it is as an inherent part of the scheduler).
Reading in any kind of input (system time, filesystem, network, etc.)
Reading thread IDs or Process IDs
Customizing the OS scheduler; you must use a standard OS scheduler from a mainstream OS
Customizing your green thread/fiber scheduler is also prohibited. This means that if you write a language for this challenge you must use OS threads.

Answer Validation
Preferably an answer would work across all common OSes and modern processors, with kudos awarded proportional to the breadth of support. However, this is not a requirement of the challenge. At a minimum an answer must support one modern SMP processor and modern OS. I'll test leading answers to the extent of my hardware availability.

If your entry will not produce the required output on an i7 5960x running Windows 10 v1607 x64, specify the environment required
If it's something I can easily reproduce with VMWare Workstation, provide the exact OS and VM specs
If it can't be produced in under either of those conditions, record a simultaneous screen capture of the test as described in the header section and a handheld video recording of your screen with your mouse and keyboard interaction (or whatever control scheme your nonstandard computation device uses) clearly visible and post both videos along with your answer and include an explanation of why it works
Alternately, get a reputable long-standing user (who is not you) with matching hardware to reproduce the result and vouch for you
If your entry is in an exotic programming language that a typical developer won't be set up to compile/jit/interpret, provide setup instructions
If you entry depends on a specific version of the JVM/Python interpreter/other, specify which
If it takes more than 10 minutes of back-to-back runs to get your 10 successful sequential sets of trials in my testing you fail (so don't let the success condition be a freak occurrence, especially if you're near the upper runtime bound)

-1 for the "If I get bored....". I'd say specify exactly how long it can take.

@EasterlyIrk It also says 'reliably under five seconds on a modern CPU'

@Pavel that's not what I'm referring to. The 10 successful trials aren't related to the 5 seconds.

@EasterlyIrk Fair enough, it's now 10 minutes.

@Techrocket9 cool, downvote rescinded.

Perl 6, 27 bytes
await map {start .say},^100

Explanation:
      map {          },^100  # Iterate over the range 0..99, and for each of number:
           start             # Send the following task to a thread pool of OS threads:
                 .say        # Print the number, followed by a newline.
await                        # Wait until all tasks have completed.

I hope this satisfies the task. (If not, please let me know).
Testing:
The shell script I used to test sufficient nondeterminism:
#!/usr/bin/bash
for i in {1..10}; do
    set=""
    for j in {1..10}; do
        set="${set}$(perl6 nondet.p6 | tr '\n' ',')\n"
    done
    permutations="$(echo -e "$set" | head -n -1 | sort | uniq | wc -l)"
    echo -n "$permutations "
done

For me, this outputs:
10 10 10 10 10 10 10 10 10 10

Setup instructions:
I ran the test with an up-to-date Rakudo Perl 6 on 64bit Linux, though I guess it'll work on other platforms.
The Rakudo download page has setup instructions. I compiled mine from git like this:
git clone git@github.com:rakudo/rakudo.git
cd rakudo
perl Configure.pl --gen-moar --make-install
export PATH="$(pwd)/install/bin/:$PATH"

Try it online:
Or just test it online, using this Try It Online link provided by @b2gills. I checked a few runs and got a different order each time, but haven't had the patience to run it 100 times through that online interface.

https://tio.run/nexus/perl6#@59YnphZopCbWKBQXVySWFSioFecWFmrE2doYPD/PwA

Validated on Windows 10 x64 on an i7 5960x with Rakudo Perl version 2016.11

bash, 32 28 bytes
for i in {0..99};{ echo $i&}

I ran this 100 times and got 100 different results.
Edit: Saved 4 bytes thanks to @DigitalTrauma.

You beat me to it.  Actually mine is a tiny bit shorter for i in {0..99};{ echo $i&}, but you posted first - you can take it :)

Here's a way you can test it in TIO.  This does 10 runs of the script, capturing output from each run, them md5ing the output from each run.  We can see the md5s are different each time.  The md5s are sorted to make potential duplicates apparent.

@DigitalTrauma Undocumented but nice!

Yep - there's a tip for this.

Interestingly, this fails to achieve "enough nondeterminism" when run in Microsoft's official bash-on-windows on an E5-2699 v4, but it works in a RHEL Workstation VM with 4 cores on the same machine so it passes.

PowerShell, 54 46 44 39 bytes
workflow p{foreach -p($i in 0..99){$i}}

PowerShell Workflows are not supported in TIO, so you can't try it there. Should work great on your Windows 10 machine though :)
Defines a function p which will output the list of numbers when invoked.
Timing
A single run reliably runs in about 600ms on my machine. The 100 tests defined below finish in under 2 minutes.
Testing
Here's complete code to test it:
workflow p{foreach -p($i in 0..99){$i}}
#workflow p{foreach($i in 0..99){$i}}
# uncomment above to prove testing methodology does detect duplicates

1..10 | % {
    $set = $_
    Write-Host "Set $set of 10"
    1..10 | % -b {
        $runs = @()
    } -p {
        $run = $_
        Write-Host "-- Run $run of 10 in set $set"
        $runs += "$(p)"
    } -e {
        Write-Host "-- There were $(10-($runs|Get-Unique).Count) duplicate runs in set $set"
    }
}

Output on my machine:

Set 1 of 10
-- Run 1 of 10 in set 1
-- Run 2 of 10 in set 1
-- Run 3 of 10 in set 1
-- Run 4 of 10 in set 1
-- Run 5 of 10 in set 1
-- Run 6 of 10 in set 1
-- Run 7 of 10 in set 1
-- Run 8 of 10 in set 1
-- Run 9 of 10 in set 1
-- Run 10 of 10 in set 1
-- There were 0 duplicate runs in set 1
Set 2 of 10
-- Run 1 of 10 in set 2
-- Run 2 of 10 in set 2
-- Run 3 of 10 in set 2
-- Run 4 of 10 in set 2
-- Run 5 of 10 in set 2
-- Run 6 of 10 in set 2
-- Run 7 of 10 in set 2
-- Run 8 of 10 in set 2
-- Run 9 of 10 in set 2
-- Run 10 of 10 in set 2
-- There were 0 duplicate runs in set 2
Set 3 of 10
-- Run 1 of 10 in set 3
-- Run 2 of 10 in set 3
-- Run 3 of 10 in set 3
-- Run 4 of 10 in set 3
-- Run 5 of 10 in set 3
-- Run 6 of 10 in set 3
-- Run 7 of 10 in set 3
-- Run 8 of 10 in set 3
-- Run 9 of 10 in set 3
-- Run 10 of 10 in set 3
-- There were 0 duplicate runs in set 3
Set 4 of 10
-- Run 1 of 10 in set 4
-- Run 2 of 10 in set 4
-- Run 3 of 10 in set 4
-- Run 4 of 10 in set 4
-- Run 5 of 10 in set 4
-- Run 6 of 10 in set 4
-- Run 7 of 10 in set 4
-- Run 8 of 10 in set 4
-- Run 9 of 10 in set 4
-- Run 10 of 10 in set 4
-- There were 0 duplicate runs in set 4
Set 5 of 10
-- Run 1 of 10 in set 5
-- Run 2 of 10 in set 5
-- Run 3 of 10 in set 5
-- Run 4 of 10 in set 5
-- Run 5 of 10 in set 5
-- Run 6 of 10 in set 5
-- Run 7 of 10 in set 5
-- Run 8 of 10 in set 5
-- Run 9 of 10 in set 5
-- Run 10 of 10 in set 5
-- There were 0 duplicate runs in set 5
Set 6 of 10
-- Run 1 of 10 in set 6
-- Run 2 of 10 in set 6
-- Run 3 of 10 in set 6
-- Run 4 of 10 in set 6
-- Run 5 of 10 in set 6
-- Run 6 of 10 in set 6
-- Run 7 of 10 in set 6
-- Run 8 of 10 in set 6
-- Run 9 of 10 in set 6
-- Run 10 of 10 in set 6
-- There were 0 duplicate runs in set 6
Set 7 of 10
-- Run 1 of 10 in set 7
-- Run 2 of 10 in set 7
-- Run 3 of 10 in set 7
-- Run 4 of 10 in set 7
-- Run 5 of 10 in set 7
-- Run 6 of 10 in set 7
-- Run 7 of 10 in set 7
-- Run 8 of 10 in set 7
-- Run 9 of 10 in set 7
-- Run 10 of 10 in set 7
-- There were 0 duplicate runs in set 7
Set 8 of 10
-- Run 1 of 10 in set 8
-- Run 2 of 10 in set 8
-- Run 3 of 10 in set 8
-- Run 4 of 10 in set 8
-- Run 5 of 10 in set 8
-- Run 6 of 10 in set 8
-- Run 7 of 10 in set 8
-- Run 8 of 10 in set 8
-- Run 9 of 10 in set 8
-- Run 10 of 10 in set 8
-- There were 0 duplicate runs in set 8
Set 9 of 10
-- Run 1 of 10 in set 9
-- Run 2 of 10 in set 9
-- Run 3 of 10 in set 9
-- Run 4 of 10 in set 9
-- Run 5 of 10 in set 9
-- Run 6 of 10 in set 9
-- Run 7 of 10 in set 9
-- Run 8 of 10 in set 9
-- Run 9 of 10 in set 9
-- Run 10 of 10 in set 9
-- There were 0 duplicate runs in set 9
Set 10 of 10
-- Run 1 of 10 in set 10
-- Run 2 of 10 in set 10
-- Run 3 of 10 in set 10
-- Run 4 of 10 in set 10
-- Run 5 of 10 in set 10
-- Run 6 of 10 in set 10
-- Run 7 of 10 in set 10
-- Run 8 of 10 in set 10
-- Run 9 of 10 in set 10
-- Run 10 of 10 in set 10
-- There were 0 duplicate runs in set 10

Interestingly, this takes 51 seconds per run on my E5-2699 v4 box, but only .7 seconds on my i5-5200U laptop. It achieves the required degree of nondeterminism on the laptop while coming in under the 5 second max, so it passes. Apparently, PowerShell's scheduler doesn't play well with many cores and short tasks.

And it takes 58 seconds on the i7 5960x

Hm... 74 seconds on an i5-6300U laptop. Maybe it's an issue with Windows 10 or PowerShell 5.1, as the i5-5200U is the only machine among those tested not running Win10 (it's running 8.1).

@Techrocket9 weird, I was testing on Win10, PS 5.1. In ISE though.

GCC on Linux, 47 bytes
main(i){for(i=99;fork()?i--:!printf("%d\n",i););}

This gave me different results pretty much every time, having been compiled with gcc (no flags) version 4.9.2. Specifically, I was on 64-bit Debian 8.6 (kernel version 3.16.31).
Explanation
If the fork() returns zero (child process), the value of i is printed, and the loop condition is false, because printf will return a value greater than zero. In the parent process, the loop condition is just i--.

Same as the bash answer. Deterministic on windows, but passes on Linux (in this case Debian).