text:
Convert a string of binary characters to the ASCII equivalents
Take a string of binary characters separated by a space, and convert it to an ASCII string.
For example...
1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100

Would convert to...
Hello World

This is a code-golf challenge so the shortest solution wins.

+1 for making a challenge without story and other fripperies, straight to the point

@bebe Fictitious fantastical fripperies form half the fun.

Hello. Let's imagine that your technology is so advanced that it does not support ASCII. Would it be allowed to convert to the native character encoding, or would it have to convert ASCII to the native character encoding? I'm thinking ZX81 here.

JavaScript (ES6) 49 55 56 64
s.replace(/\d+./g,x=>String.fromCharCode('0b'+x))

Edit Accepting @bebe suggestion - thanks
Edit2 Didn't know about binary numeric literal - thanks @kapep
Edit3 Wow 6 not 4 bytes saved thx @ETHproductions
Explanation as requested in comments
String.replace can take 2 arguments:

regular expression /\d+./g : one or more digits followed by one different character - the g flag specify to search the pattern more than once
a function, here specified in arrow format, where the argument (x) wil be the found string (the sequence of digits eventually followed by a space) and the value of the function is what is replaced (in this case, the single character from the code).

It's worth noting that the at the end of the string the regexp matches the sequence of digits without a trailing space, in this case the dot matches the last digit. Try '123'.match(/(\d+)./) to verify.
(Still) one of the more verbose pieces of javascript ever...
(Assignment to string s not counted)

var s='1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100'
var x=
s.replace(/\d+./g,x=>String.fromCharCode('0b'+x))

console.log(x)

s.replace(/\d+./g,x=>String.fromCharCode(parseInt(x,2))) 56

s.replace(/\d+./g,x=>String.fromCharCode(eval("0b"+x))) 55

Can you please explain what the /\d+./g,x=>does?

@izlin I added some explanation to the answer

I know this is an old answer, but you can change eval('0b'+x) to '0b'+x-0 to save 4 bytes.

Firstly, it's 54. Secondly,s.split(' ').map(x=>String.fromCharCode(eval('0b'+x))) is also 54, but it returns char array

@username.ak it's 55, count again. But it will be less an a couple of minutes

@ETHproductions great, thanks

Believe it or not, I've discovered you can actually remove the -0. I guess String.fromCharCode casts to number implicitly

@ETHproductions unbelievable. (and again 4 stroked is 4)

Ruby, 36 32
s.split.map{|x|x.to_i(2).chr}*""

Or 31
s.gsub(/\w+ ?/){$&.to_i(2).chr}

Optimizations thanks to Chron

You could substitute .join"" for *"" to save a few characters.  You could also do it with gsub instead of split+map+join, something like: s.gsub(/\w+ ?/){$&.to_i(2).chr} (31 chars).

s.gsub(/\d+./){$&.to_i(2).chr} works and it's 30 chars, I have no idea why it works though. The . shouldn't match the last time but it does.

Bash+common linux utils, 25 bytes
dc<<<2i$s[Pz0\<m]dsmx|rev

dc explanation

push 2 to the stack; pop and use as input radix
push input string to stack (all values at once)
Define recursive macro m to:

pop, then print value as ASCII
push stack depth to stack
push 0 to stack
pop top 2 stack values; compare and call m macro if stack non-empty

duplicate top of stack (macro definition)
pop and save macro to m register
pop and execute macro

Because we push the whole binary string to the stack first, when we pop each value, we end up with the string reversed.  So we use the rev utility to correct that.
Example usage:
$ s="1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100"
$ dc<<<2i$s[Pz0\<m]dsmx|rev
Hello World
$

PowerShell, 49
-join(-split$s|%{[char][convert]::toint32($_,2)})

EDIT: Didn't see the other PowerShell answer. But there is essentially only one way of solving this.

C - 57 43 38/31
38 Byte version:
for(int*x=s;putchar(strtol(x,&x,2)););

Or only 31 bytes if s is a pointer:
while(putchar(strtol(s,&s,2)));

I don't think this is exactly how for and while loop are supposed to be used... but it works.

Mathematica, 52 bytes
Ah, Mathematica's lovely function names
f=FromCharacterCode[#~FromDigits~2&/@StringSplit@#]&

Powershell (52 49)
-join(-split$s|%{[char][convert]::ToInt16($_,2)})

Simple loop over binary string in $s. Having to include the [convert] kills my score though.
EDIT: There really is only one way of pulling this off in Powershell, wowie. Joey and I both got pretty much the same answer working independently!
Input:
1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100

Output:
Hello World

You can use the unary split operator, saving three characters (at which point our answers are identical ... big surprise ;-)).

@Joey Ohh, good point! Can't believe I missed that. You get the +1 from me for catching that, thanks!

Pyth, 12
smCv+"0b"dPZ

Note that s is not a legal variable in Pyth, so I used Z instead.
Explanation:
        print(
s             sum(
m                 map(lambda d:
C                     chr(
v                         eval(
+"0b"d                         "0b"+d)),
P                     split(
Z                           Z))))

Example:
=Z"<the binary string from above>"smCv+"0b"dPZ
Hello World

The fact it does not use whitespace in the formatting (here's looking at you Python) is a major +1

@Pharap Yeah, one way of looking at Pyth is it's Python with all of the elements that make it take more characters removed, like whitespace, parenthesis, multi-character tokens, etc.

I don't know Pyth, but would it not save 4 characters to use id2 in place of v+"0b"d? In any case, this is both unreadable and cool.

@DLosc I added that function to Pyth after this question was asked, in large part due to this question. It would be shorter with present day Pyth, but present day Pyth is not allowed for this challenge.

I see. I wondered if it might be something like that.

I really like the formatting of your Explanation section.

x86 machine code on DOS - 22 bytes
00000000  30 d2 b4 08 cd 21 2c 30  72 06 d0 e2 08 c2 eb f2  |0....!,0r.......|
00000010  b4 02 cd 21 eb ea                                 |...!..|

Since there are no real string variables in machine code (and in particular, no variables named "s") I settled for stdin as input.
NASM input:
    org 100h

section .text

start:
    xor dl,dl
loop:
    mov ah,8
    int 21h
    sub al,'0'
    jb print
    shl dl,1
    or dl,al
    jmp loop
print:
    mov ah,2
    int 21h
    jmp start

Perl 33 32
Edit: Updated solution, 32.
say$s=~s/\d+ ?/chr oct"0b$&"/rge

Previous solution (33):
$_=$s;say map{chr oct"0b$_"}split

or
say map{chr oct"0b$_"}split/ /,$s

Test:
perl -E '$s="1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100";$_=$s;say map{chr oct"0b$_"}split'

J (23)
u:;(#.@:("."0))&.>cut s

Test:
   s=:'1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100'
   u:;(#.@:("."0))&.>cut s
Hello World

Explanation:
                  cut s    NB. split S on spaces
   (          )&.>         NB. for each element
        ("."0)             NB. evaluate each character
      @:                   NB. and
    #.                     NB. convert bitstring to number
  ;                        NB. unbox each number
u:                         NB. convert to ASCII

Python shell  44   40 chars
''.join(chr(int(x,2))for x in s.split())

Thanks for the help Griffin.

''.join(chr(int(x,2))for x in s.split())

Golfscript - 21
' '/{1/{~}%2base}%''+

You can test it here.

APL (15)
⎕UCS{2⊥⍎¨⍕⍵}¨⍎s

Test:
      s←'1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100'
      ⎕UCS{2⊥⍎¨⍕⍵}¨⍎s
Hello World

Explanation:

⍎s: evaluate s, turning it into an array of integers. Arrays are written as numbers separated by spaces, so this splits s.
{...}¨: for each element:

⍕⍵: turn the number back into a string
⍎¨: evaluate each individual digit, giving a bitstring
2⊥: base-2 decode, giving the numbers

⎕UCS: get the character for each number

Unless otherwise specified you should count bytes instead of characters: http://codegolf.stackexchange.com/tags/code-golf/info :)

@Averroes: the APL charset fits in a byte with room to spare: http://frankenstein.d-n-s.org.uk/~marinus/aplcharset.png

Ah, I didn't know it. My bad. Sorry!

PHP (61)
<?=join(array_map('chr',array_map('bindec',explode(' ',$s))))

foreach(str_split($s,8)as$v)echo chr(bindec($v));

@JörgHülsermann the encoding may skip leading zeros therefore str_split($s,8) won't work. foreach(explode(' ',$s)as$v)echo chr(bindec($v)); would be valid but I don't plan to edit one of my first PPGC answers that clearly isn't really golfed anyway. Thank you anyway!

Bacchus, 25 bytes
S,' 'j:A=(Ö,2,10b:c),A¨

Explanation:
S,' 'j split the String S by the empty space and converts it to a block (some sort of array).
:A= get the previous Block and assing it to A variable.
(),A¨ for Each element in A
Ö,2,10b Read the current element (represent by Ö) in base 2 and transform it to base 10.
:c get the previous value and print as char

GolfScript 23
' '/{[{49=}/]2base}%''+

Online test here.

C - 63
since C has no base 2 converter in standard library: test here

edit: there is, i'm just too stupid to know about it
r;f(char*s){for(;*s;(*s|32)-32||(putchar(r),r=0))r=2*r|*s++&1;}

Run Length Encoded Brainfuck, 49 bytes
Since there are no variables in Brainfuck, I just used standard input and output instead.
The code 32+ should be interpreted as 32 +s by the interpreter. Just replace them manually if your interpreter doesn't support RLE.
>,[32->+<[16-<[>++<-]>[<+>-]>-<]>[<<.[-]>>-]<,]<.

Expanded (non-RLE) version: (91 bytes)
>,[-------------------------------->+<[----------------<[>++<-]>[<+>-]>-<]>[<<.[-]>>-]<,]<.

The code assumes that EOF is encoded as 0.
Explanation
The following layout is used:
+---+---+------+
| x | a | flag |
+---+---+------+

Where x is the ASCII byte to be printed, a is the a character from standard input and flag is 1 if a was a space.
>,            Read a character a into the second cell
[             While not EOF:
  32-           Decrease a by 32 (a -= ' ')
  >+<           Set the flag to 1
  [             If a was not a space:
    16-           Decrease by 16 more ('0' == 32+16)
    <[>++<-]      a += 2*x
    >[<+>-]       Move it back (x = a)
    >-<           Reset the flag, it was not a space.
  ]>
  [             If a was a space (flag == 1):
    <<.[-]        Print and reset x
    >>-           Reset the flag
  ]
  <,            Read the next caracter a
]
<.            Print the last character x

+1 Because everything should have a brainfuck implementation.

Is "Run Length Encoded Brainfuck" an actual separate language? I can't find an interpreter.

Java 8 : 60 bytes
Using lambdas in Java 8 (75 bytes):

Arrays.stream(s.split(" ")).reduce("",(a,b)->a+(char)Byte.parseByte(b,2));

And if you allow static imports (which some here used) it is (61 bytes):
stream(s.split(" ")).reduce("",(a,b)->a+(char)parseInt(b,2))

A tiny bit shorter version using for loop (60 bytes):
for(String n:s.split(" ")){out.print((char)parseInt(n,2));}

What, they actually made a replacement for the monstrosity known as anonymous class? Awesome.

@Sieg yes Java has lambdas/closures now as well, but it is mostly synthetic sugar on top of anonymous classes... (obviously)

Clojure 63 (or 57)
The all-Clojure impl:
(apply str(map #(char(read-string(str"2r"%)))(re-seq #"\d+"s)))

With Java interop:
(apply str(map #(char(Long/parseLong % 2))(.split s" ")))

REPL session:
golf> (def s "1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100")
#'golf/s
golf> (apply str(map #(char(read-string(str"2r"%)))(re-seq #"\d+"s)))
"Hello World"
golf> (apply str(map #(char(Long/parseLong % 2))(.split s" ")))
"Hello World"

QBasic, 103
s$=s$+" ":FOR i=1 TO LEN(s$):c$=MID$(s$,i,1):IF c$=" "THEN n=0:r$=r$+CHR$(n)ELSE n=n*2+VAL(c$)
NEXT:?r$

What? We have no fancy binary-to-decimal functions here. Do it yourself!
I'm counting the newline (which I think is necessary to get the if-then-else without an END IF) as one byte, per this meta post. I don't know whether QB64 on Windows would accept a code file that way or not. Probably doesn't much matter.

Haskell -- 48 (+13 imports (?))
Here's my first golf attempt in Haskell.
map(chr.foldl1((+).(*2)).map digitToInt)$words s

You need to import Data.Char
usage (in ghci):
Prelude> :m +Data.Char
Prelude Data.Char> let s = "1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100"
Prelude Data.Char> map(chr.foldl1((+).(*2)).map digitToInt)$words s
"Hello World"

Explanation:
map(chr.foldl1((+).(*2)).map digitToInt)$words s
                                        $words s -- split s on spaces into a list
                         map digitToInt          -- convert each digit in input string to int
              ((+).(*2))                         -- a function that multiplies its first
-- argument by 2, then adds the second argument
        foldl1((+).(*2)).map digitToInt          -- fold the above over the list of ints:
-- in other words this is a function that reads strings as binary and gives the value as int
   (chr.foldl1((+).(*2)).map digitToInt)         -- cast to character
map(chr.foldl1((+).(*2)).map digitToInt)$words s -- map our function over the list of words

Hopefully I've followed scoring conventions correctly regarding imports.  Feel free to edit in a correction if I haven't.  I treated the ":m +Data.Char" needed to import in ghci as 13.

NodeJS – 62
Buffer(s.split(' ').map(function(a){return parseInt(a,2)}))+''

PHP – 75
array_reduce(explode(' ', $b),function($a,$b){return $a.chr(bindec($b));});

how do you run nodejs with es6 compatibility? the latest one still does not support lambda functions for me

@bebe Arrow functions are implemented in v8 but they aren't integrated with node yet. I'll edit my post.

@c.P.u1 they work for me

-16 bytes suggested by an anonymous user

JavaScript 111
This does the number conversion without parseInt or eval.  Reading the string backwards and counting bits it set's bit x if it's a one. When a space is found a the number is converted to a char and a new 0 number is started for setting bits.
x=n=0,w='',s=' '+s
for(i=s.length;i--;){m=s[i]
if(m==1)n|=1<<x
x++
if(m==' ')w=String.fromCharCode(n)+w,n=x=0
}

+1 for doing it the old-fashioned way--inspired me to write a QBasic version, too.

Invalid, needs to be a function or full program (one that takes input)

Groovy 64
{it.split(" ").collect{Integer.parseInt(it,2) as char}.join("")}

CJam, 11 bytes
NS/{:~2bc}/

s isn't a legal variable name in CJam, so I chose N instead.
Try it online.
Example run
$ cjam <(echo '
> "1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100"
> :N;
> NS/{:~2bc}/
> '); echo
Hello World

How it works
NS/            " Split N at spaces.                            ";
   {     }/    " For each chunk:                               ";
    :~         "   Evaluate each character ('0' ↦ 0, '1' ↦ 1). ";
      2b       "   Convert from base 2 array to integer.       ";
        c      "   Cast to character.                          ";

Zsh, 27 26 22 bytes
-1 from roblogic, -4 from a new strategy using an array and ${a/b/c} replacement.
printf %s ${(#)@/#/2#}

Try it online!
Try it online!
Try it online!
The (#) flag causes arithmetic expansion to be done to the contents of the parameter. Flags are parsed after the replacement. # matches the start of a string when at the start of a ${ / / } pattern. So each parameter is # prefixed with 2#, which Zsh recognizes as a base 2 number when (#) arithmetic expansion is done.

This relies on flexible I/O, each group of bits in its own parameter. This is what the pure bash answer does as well. To parse a single string, +4 bytes are needed: (Example)
printf %s ${(#)${=1}/#/2#}

use printf and you dont need to append \\c, saving 1 byte

Vyxal s, 3 bytes
vBC

Try it Online!
How?
vBC
vB   # Vectorized convert to decimal
  C  # Convert character codes to list of characters
     # S flag concatenates result

If we have to receive input separated by spaces, then:
Vyxal s, 4 bytes
⌈vBC

Try it Online!

05AB1E, 4 bytes
Saved 3 bytes thanks to @Emigna
#CçJ

Try it online!

#CçJ also works. Although in both this and your version you need ð¡ instead of # if the input can be only 1 char.

GNU Sed, 19 bytes
Inspired by an excellent @Digital Trauma answer.
Golfed
s/\w*/dc -e2i&P;/eg

Test
echo 1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100|\
sed 's/\w*/dc -e2i&P;/eg'

Hello World

Pyth, 7 bytes
smCid2c

Takes input as string.
Try it!

05AB1E (legacy), 4 bytes
#CçJ

Try it online!
Explanation:
#CçJ
#   : Split implicit input at spaces
 C  : Convert every element to int
  ç : chr(n)
   J: Join elements, push it to the stack for printing

Edit: I noticed I perfectly duplicated a previous answer by my own, but keep it.

Because the language is newer than the question

That's ok.  No need to mark it as non-competing.

Okay. Thanks! Removed

K4, 18 bytes
Solution:
"c"$2/:'"1"=" "\:s

Example:
q)s:"1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100"
q)k)"c"$2/:'"1"=" "\:s
"Hello World"

Explanation:
"c"$2/:'"1"=" "\:s / the solution
                 s / the input
            " "\:  / split (\:) on " "
        "1"=       / equal to "1" ?
    2/:'           / join (/:) each (') from base-2
"c"$               / cast to characters

K (ngn/k), 15 11 bytes
Solution:
`c$2/10\. s

Try it online!
Explanation:
`c$2/10\. s / the solution
          s / input s
        .   / value "1100" => 1100
     10\    / convert to base 10
   2/       / convert from base 2
`c$         / cast to character

-4 bytes thanks to ngn!

it's shorter if you evaluate s as is, encode it in decimal, and decode it from binary: ``c$2/10. s`

Python 3, 33 bytes
bytes(int(c,2)for c in s.split())

Try it online!
This solution outputs a byte string in Python. If it is required to return a regular Python string:
Python 3, 42 bytes
bytes(int(c,2)for c in s.split()).decode()

Try it online!

brainfuck, 74 61 bytes
,[>++++[>++++<-]>[<+<-->>-]<<[>[<->-]<<[>++<-]]<[.[-]]>>>,]<.

Try it online!
Explanation:
[tape: char, 'input, 16, 16]
[      else]

,[                      for each input
  >++++[>++++<-]>           set const 16
  [<+<-->>-]                decrement input by 32
  <<[                       if not input = space
    >[<->-]                     decrement input by 16
    <<[>++<-]                   add double of char to input
  ]
  <[                        else
    .                           print character
    [-]                         delete character
  ]
  >>>,                      input next character
]
<.                      print last character

Python 3, 43 bytes
for i in s.split():print(end=chr(int(i,2)))

fixed a blunder! Thanks to @caird-coinheringaahing XD
Try it online!

The question says the binary string will be stored in a variable called s?

@JoKing Have you read the challenge? OP's code doesn't work (Try it online!), but not because of the reason you've stated. However this does work

Perl 5 -a, 24 bytes
say map chr oct"0b$_",@F

Try it online!

Nice one! Came up with similar but abusing $\ for 22: Try it online!

Definitely a shame that the binary isn't 0-padded, could be 17 bytes :/ Try it online!

Pip, 10 bytes
C*FB*(a^s)

Sadly can't use the -s flag here.
Try it online!

Scala 2.12, 47 bytes
_ split " "map(_./:(0)(_*2+_-48)toChar)mkString

Try it online!
Splits on spaces, maps each string representing a binary number to an integer, turns into a Char, and then joins all those characters together. Scala 2.12 is required because of postfix operators.

J, 32 bytes
{&a.@#.@(-&48)@(a.&i.);._2@,&' '

Try it online!

Factor, 30 bytes
[ " "split [ bin> ] ""map-as ]

Try it online!

Excel Insider Beta v2203+, 41 Bytes
Worksheet function that takes input from range A1 and outputs to the calling cell.
Makes use of the TextSplit(...) function, one of many text and array functions added in Excel Insider Beta Version 2203.
=Concat(Char(Bin2Dec(TextSplit(A1," "))))

Lua, 59 bytes
for k in s:gmatch'%d+'do io.write(s.char(tonumber(k,2)))end

To convert to a string rather than write to stdout: s:gsub('[10]+ ?',function(b)return s.char(tonumber(b,2))end).

Erlang, 45 Bytes
[binary_to_integer(X,2)||X<-re:split(S," ")].

Strings are represented as a list of integers in Erlang. This returns a list of ASCII codes which, when printed, will be represented as a string if all ASCII codes are printable characters.

REXX, 56 bytes (or 15)
o=
do w=1 to words(s)
  o=o||x2c(b2x(word(s,w)))
  end
say o

Alternatively, if the input values are an even 8 bits instead of varying in length as in the example, this may be shortened to just one line:
say x2c(b2x(s))

AHK, 115 bytes
Loop,Parse,s," "
{x:=D(A_LoopField)
Send % Chr(x)
}
D(x){
Return (StrLen(x)>1?D(SubStr(x,1,-1))<<1:0)|SubStr(x,0)
}

The loop parses the string using a space as the delimeter.
The function D(x) converts x from binary to decimal.
The Chr function returns the ASCII character with the value x.

Tcl, 46 bytes
proc B s {binary f B* [regsub -all " " $s ""]}

Try it online!

Tcl, 51 bytes
proc B s {binary format B* [regsub -all " " $s ""]}

Try it online!

Same byte count: https://tio.run/##XYtNCoAgFISvMkirVr4reI1qYUIh9CNqi5DO/krdVDCLj/lmolmYnd8NFALSaDftT0xQLboQvd1mrNoh9YAQF5owXOyOGNApCEkyR0JSISqQ@Q/0qDKtTaleiur/@8p7MfAN

q/kdb+, 22 bytes
Solution:
10h$0b sv'"1"=-8$" "vs

Example:
q)10h$0b sv'"1"=-8$" "vs"1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100"
"Hello World"

Explanation:
Split string on " ", left-pad each to 8 characters, return boolean list where each string is equal to "1", convert each 8-bit list to a byte and then cast to a string:
10h$0b sv'"1"=-8$" "vs / the solution
                 " "vs / split (vs) on " "
              -8$      / pad ($) to 8-long, negative means left-pad
          "1"=         / is item in each list equal to 1, returns true (1) or false (0) for each
    0b sv'             / convert each (') from boolean list to bytes
10h$                   / cast ($) to character type (10h)

Deorst, 11 bytes
o k`]mxmcE;

Try it online!
How it works
Example input: 1001000 1100101
o<space>    - Push a  space;    STACK = [' ', '1001000 1100101']
  k         - Turn off sort;    STACK = [' ', '1001000 1100101']
   `        - Split;            STACK = [['1001000', '1100101']]
    ]       - Flatten;          STACK = ['1001000', '1100101']
     mx     - Map from binary;  STACK = [72, 101]
       mc   - Map to character; STACK = ['H', 'e']
         E; - Concatenate;      STACK = ['H', 'e', 'He']

Perl, 27 bytes
say pack"(B8)*",split' ',$s

Doesn't work. Note that each character is a group of 7 bytes.

Julia 1.0, 40 bytes
join(Char.(parse.(Int,split(s),base=2)))

Try it online!

Gol><>, 27 24 bytes
IWaSD$|rlF2LX*}|lR+oiE;~

Try it online!
Explanation:
I                         //Read the next number as integer
 W                        //Loop to extract single digits
  aSD                     //  Perform a mod & div by 10 on the current number
     $|                   //  Repeat until the number is 0
       r                  //Reverse the stack to go from LSB to MSB
        lF                //Loop over all single bits and replace all 1's with their corresponding value
          2LX             //  Push 2^x where x is the number of the current bit -> value of topmost bit
             *            //  Multiply the value of the topmost bit with the bit itself
              }|          //  Shift right to get the next bit
                lR+       //Add all values on the stack together
                   o      //Output the decimal value as a char
                    iE;~  //Check for EOF if true terminate

Common Lisp, 79 bytes
(map'string'code-char(let((*read-base* 2))(read-from-string(format()"(~a)"s))))

Try it online!

Powershell, 48 bytes
Inspired by Joey's and fuandon's answers.
-join(-split$s|%{[char][convert]::ToByte($_,2)})

Perl 6, 24 bytes
*.words>>.&{:2($_)}.chrs

Try it online!
Anonymous Whatever lambda that takes a string and returns a string.
Explanation
*.words                   # Split by spaces
       >>.&{      }       # Map each word to
            :2($_)        # Parsing it as binary
                   .chrs  # Convert to characters

Bash (Pure): 54
Pure bash and no fork!
f(){ for a;do printf -vv \\%o $[2#$a];printf $v;done;}

f 1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100
Hello World

Explanation

f() declare function f
for a;do ... done take each argument successively and attrib them to variable a in loop
$[2#$a] convert binary to decimal
printf -vv \\%o $... convert decimal to octal, preceded by backslash \ for next printf and attribute this to variable v.
printf $v will render character.

C# (Visual C# Interactive Compiler), 61 bytes
s.Split(" ").Aggregate("",(a,b)=>a+(char)Convert.ToByte(b,2))

Splits the binary string, and adds each byte into the string. You need to have the seed for aggregate, or else the first byte won't be parsed.
Try it online!

Invalid, needs to be either a full program or a function/lambda

64

Look at the javascript answer on the first page. It doesn't use a function. The question even says the variable is predefined.

:/ then that's invalid too

But the OP says that the the binary string is already contained in a variable named s.

Oh wait >_> didn't see that

Japt -P, 4 bytes
¸®Íd

Try it
¸®Íd     :Implicit input of string
¸        :Split on spaces
 ®       :Map
  Í      :  Convert from binary string to integer
   d     :  Get character at that codepoint
         :Implicitly join & output

Julia 1.0, 44 bytes
prod(Char.(parse.(Int,split(s," "),base=2)))

Try it online!

Python 3, 55 bytes
lambda s:"".join(map(lambda b:chr(int(b,2)),s.split()))

Try it online!
Or 46 bytes if we return an iterator instead of a string:
lambda s:map(lambda b:chr(int(b,2)),s.split())

Try it online!

TECO, 35 bytes
Z+1<0A"DQn*2#(0A-48)Un|QnI^[0Un'1:D>

^[ stands for esc.
Explanation
I1001000 1100101 1101100 1101100 1101111 100000 1010111 1101111 1110010 1101100 1100100^[
! insert input string to the buffer !
J     ! reset to zero point !
Z+1<  ! loop over all chars !
0A"D  ! if the current char is a digit !
Qn*2#(0A-48)Un ! append the bit to register n !
D     ! remove current char !
|     ! else !
QnI^[ ! insert value of register n as ASCII !
0Un   ! clear n !
1:D   ! delete one char without signaling error !
'     ! end if !
>     ! end loop !
HT    ! type out result !

JavaScript, 64 bytes
s=>s.replace(/\d+./g,c=>eval(`'\\x${('0b'+c|0).toString(16)}'`))

Try it online!
Trying something different to this JS answer, not sure if it can be shorter.

Python 3, 48 44 bytes
[print(end=chr(int(i,2)))for i in s.split()]

Try it online!
previous answer,
[print(end=chr(eval('0b'+i)))for i in s.split()]

Try it online!
Learnt the print(end=...) trick in the "Scream the loudest" challenge. Pretty neat.
As far as I know, there is no direct conversion to ascii from binary string, so we have to suffer the '0b' in the eval.
Thanks to this python answer for giving int(i,2)

Python 3, 53 bytes
lambda x:[print(end=chr(int(i,2)))for i in x.split()]

Try it online!
Used the int(i,2) to convert number from base 2 to 10. In-built functions for the win.

Octave, 30 bytes
Nothing too fancy, but it's relatively short
@(x)['',bin2dec(strsplit(x))']

Try it online!
@(x)                            % Take x as input
@(x)            strsplit(x)     % split string at spaces and create a cell array
@(x)    bin2dec(strsplit(x))    % Convert each row to integers
@(x)    bin2dec(strsplit(x))'   % Transpose into column vector
@(x)['',bin2dec(strsplit(x))']  % Concatenate with the empty string to cast to chars

Thunno 2 J, 3 bytes
OḂC

Attempt This Online!
But, if a list of strings was an allowed input format:
Thunno 2 J, 2 bytes
ḂC

Attempt This Online!
Explanation
OḂC  # Implicit input
O    # Split on spaces
 Ḃ   # Convert from binary
  C  # Convert to characters
     # Implicit output

Python, 46 bytes
''.join(map(lambda x:chr(int(x,2)),s.split()))

source: Stack Exchange

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

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

sort: votes


text:
How many characters per character?
At http://shakespeare.mit.edu/ you can find the full text of each of Shakespeare's plays on one page (e.g. Hamlet).
Write a script that takes in the url of a play from stdin, such as http://shakespeare.mit.edu/hamlet/full.html, and outputs the number of text characters each play character spoke to stdout, sorted according to who spoke the most.
The play/scene/act titles obviously do not count as dialogue, nor do the character names. Italicized text and [square bracketed text] are not actual dialogue, they should not be counted. Spaces and other punctuation within dialogue should be counted.
(The format for the plays looks very consistent though I have not looked at them all. Tell me if I've overlooked anything. Your script does not have to work for the poems.)
Example
Here is a simulated section from Much Ado About Nothing to show what I expect for output:

More Ado About Nothing
Scene 0.
Messenger
I will.
BEATRICE
Do.
LEONATO
You will never.
BEATRICE
No.

Expected output:
LEONATO 15
Messenger 7
BEATRICE 6

Scoring
This is code golf. The smallest program in bytes will win.

What if someone did this Shakespeare challenge in Shakespeare? It would be amazing if that was even possible...

Can we assume we have a list of the characters in the play?  Or must we infer the characters from the text?  The latter is very difficult given that some characters (e.g. Messenger) have a mix of upper and lower case letters.  Others have  names with only upper case letters (e.g. LEONATO); and some of those are compound names.

Yes you should infer the names. They are formatted very differently than the dialogue so given the html differentiating them shouldn't be too tricky.

Yes, perhaps if one works directly with the HTML...

Should 'All' be considered as a separate character?

@DavidCarraher Well I'm not sure why you wouldn't use the html unless you couldn't... I'll ignore the names rule iff you are using the Shakespeare language.

@es1024 Yes. Any play character with a unique title is considered separate, even if the result does not exactly make sense.

Doesn't really qualify, but playing with javascript just for fun -> FIDDLE

PHP (240 characters)
Divides the html into strings (using  as a delimeter), then runs a couple of regular expressions to extract name and words spoken. Saves length of words spoken into array.
Golfed:

<?@$p=preg_match_all;foreach(explode('/bl',implode(file(trim(fgets(STDIN)))))as$c)if($p('/=s.*?b>(.*?):?</',$c,$m)){$p('/=\d.*?>(.*?)</',$c,$o);foreach($m[1]as$n)@$q[$n]+=strlen(implode($o[1]));}arsort($q);foreach($q as$n=>$c)echo"$n $c\n";

Ungolfed:

<?php
$html = implode(file(trim(fgets(STDIN))));
$arr = explode('/bl',$html);
foreach($arr as $chunk){
    if(preg_match_all('/=s.*?b>(.*?):?</',$chunk,$matches)){
        $name = $matches[1];
        preg_match_all('/=\d.*?>(.*?)</',$chunk,$matches);
        foreach($name as $n)
            @$names[$n] += strlen(implode($matches[1]));
    }
}
arsort($names);
foreach($names as $name=>$count)
    echo "$name $count\n";

Note: This considers 'All' to be a separate character.
Example:
$php shakespeare.php <<< "http://shakespeare.mit.edu/hamlet/full.html"
HAMLET 60063
KING CLAUDIUS 21461
LORD POLONIUS 13877
HORATIO 10605
LAERTES 7519
OPHELIA 5916
QUEEN GERTRUDE 5554
First Clown 3701
ROSENCRANTZ 3635
Ghost 3619
MARCELLUS 2350
First Player 1980
OSRIC 1943
Player King 1849
GUILDENSTERN 1747
Player Queen 1220
BERNARDO 1153
Gentleman 978
PRINCE FORTINBRAS 971
VOLTIMAND 896
Second Clown 511
First Priest 499
Captain 400
Lord 338
REYNALDO 330
FRANCISCO 287
LUCIANUS 272
First Ambassador 230
First Sailor 187
Messenger 185
Prologue 94
All 94
Danes 75
Servant 49
CORNELIUS 45

Kindly show some example(s) of output.

@DavidCarraher An example has been added.

Rebol - 556 527
t: complement charset"<"d: charset"0123456789."m: map[]parse to-string read to-url input[any[(s: 0 a: copy[])some[""copy n some t(append a trim/with n":")some newline]
newline any[""copy q some t
newline(while[f: find q"["][q: remove/part f next find f"]"]s: s + length? trim head q)|
some t
newline][
|](foreach n a[m/:n: either none? m/:n[s][s + m/:n]])| skip]]foreach[x y]sort/reverse/skip/compare to-block m 2 2[print[x y]]

This could probably be golfed further however its unlikely to get below the answer(s) already provided :(
Ungolfed:
t: complement charset "<"
d: charset "0123456789."
m: map []

parse to-string read to-url input [
    any [
        (s: 0 a: copy [])

        some [
            "" copy n some t
            (append a trim/with n ":")
            some newline
        ]

 newline
        any [
            "" copy q some t
 newline (
                while [f: find q "["] [
                    q: remove/part f next find f "]"
                ]
                s: s + length? trim head q
            )
            |
 some t
 newline
        ]
        [
 | ]
        (foreach n a [m/:n: either none? m/:n [s] [s + m/:n]])

        | skip
    ]
]

foreach [x y] sort/reverse/skip/compare to-block m 2 2 [print [x y]]

This program removes [square bracketed text] and also trims surrounding whitespace from the dialogue.  Without this the output is identical to es1024 answer.
Example:
$ rebol -q shakespeare.reb <<< "http://shakespeare.mit.edu/hamlet/full.html"
HAMLET 59796
KING CLAUDIUS 21343
LORD POLONIUS 13685
HORATIO 10495
LAERTES 7402
OPHELIA 5856
QUEEN GERTRUDE 5464
First Clown 3687
ROSENCRANTZ 3585
Ghost 3556
MARCELLUS 2259
First Player 1980
OSRIC 1925
Player King 1843
GUILDENSTERN 1719
Player Queen 1211
BERNARDO 1135
Gentleman 978
PRINCE FORTINBRAS 953
VOLTIMAND 896
Second Clown 511
First Priest 499
Captain 400
Lord 338
REYNALDO 312
FRANCISCO 287
LUCIANUS 269
First Ambassador 230
First Sailor 187
Messenger 185
Prologue 89
All 76
Danes 51
Servant 49
CORNELIUS 45

Common Lisp - 528
(use-package :plump)(lambda c(u &aux(h (make-hash-table))n r p)(traverse(parse(drakma:http-request u))(lambda(x &aux y)(case p(0(when(and n(not(ppcre:scan"speech"(attribute x"NAME"))))(setf r t y(#1=ppcre:regex-replace-all"aside: "(#1#"^(\\[[^]]*\\] |\\s*)"(text x)"")""))(dolist(w n)(incf(gethash w h 0)(length y)))))(1(if r(setf n()r()))(push(intern(text(aref(children x)0)))n)))):test(lambda(x)(and(element-p x)(setf p(position(tag-name x)'("A""b"):test #'string=)))))(format t"~{~a ~a~^~%~}"(alexandria:hash-table-plist h)))

Explanation
This is a slightly modifed version which adds printing informations (see paste).
(defun c (u &aux
                 (h (make-hash-table)) ;; hash-table
                 n ;; last seen character name
                 r p
                 )
      (traverse                 ;; traverse the DOM generated by ...
       (parse                   ;; ... parsing the text string
        (drakma:http-request u) ;; ... resulting from http-request to link U
        )

       ;; call the function held in variable f for each traversed element
       (lambda (x &aux y)
         (case p
           (0 ;a
            (when(and n(not(alexandria:starts-with-subseq"speech"(attribute x "NAME"))))
              (setf r t)
              (setf y(#1=ppcre:regex-replace-all"aside: "(#1#"^(\\[[^]]*\\] |\\s*)"(text x)"")""))
              (format t "~A ~S~%" n y) ;; debugging
              (dolist(w n)
                (incf
                    (gethash w h 0) ;; get values in hash, with default value 0
                    (length y)))) ;; length of text
            )
           (1 ;b
            (if r(setf n()r()))
            (push (intern (text (aref (children x)0)))n))))

       ;; but only for elements that satisfy the test predicate
       :test
       (lambda(x)
         (and (element-p x) ;; must be an element node
              (setf p(position(tag-name x)'("A""b"):test #'string=)) ;; either  or ; save result of "position" in p
              )))

        ;; finally, iterate over the elements of the hash table, as a
        ;; plist, i.e. a list of alternating key values (k1 v1 k2 v2 ...),
        ;; and print them as requested. ~{ ~} is an iteration control format.
  (format t "~&~%~%TOTAL:~%~%~{~a ~a~^~%~}" (alexandria:hash-table-plist h)))

Notes

I remove bracketed text as well as the "aside: " occurence that is not present in brackets (I also trim whitespace characters). Here is a trace of execution with the text being matched and the total for each character, for Hamlet.
As other answers, All is assumed to be a character. It could be tempting to add the value of all to all other characters, but this would be incorrect since "All" refers to the characters actually present on stage, which requires to keep a context of who is present (tracking "exit" "exeunt" and "enter" indications). This is not done.

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


text:
Convert numbers to symbols without string or char literals
Read infinitely from stdin, and convert every number to the corresponding symbol on a US qwerty keyboard.
No string or character literals anywhere are permitted.
E.g. if the input is 117758326, the output is !!&&%*#@^.
Letters and symbols that aren't on numbers are left alone; 11g2;;'1g2311hh21930 turns into !!g@;;'!g@#!!hh@!(#)
Shortest code, in bytes, wins.
For those who don't have a US qwerty keyboard, use the following as a guide:
1 -> !
2 -> @
3 -> #
4 -> $
5 -> %
6 -> ^
7 -> &
8 -> *
9 -> (
0 -> )

C, 90 bytes
The line between a character and an integer literal is a very fine one in C.
a[]={8,0,31,2,3,4,61,5,9,7};main(d){for(;~(d=getchar());)putchar(d>47&d<58?a[d-48]+33:d);}

shoot, there's a string literal in the printf. fixing later

putchar() - and its 4 bytes shorter too!

this is 92
a[]={41,33,64,35,36,37,94,39,42,40};main(d){for(;d=getchar();)putchar(d>47&d<58?a[d-48]:d);}

@DigitalTrauma yeah I know, I just didn't think of it right away for some reason and had to leave really quickly then

@bebe thanks a lot! some neat ideas there. :) I'm not really using C for golfing, usually.

It's 38 not 39

@soktinpk cheers, fixed

a[]={8,0,31,2,3,4,61,5,9,7};main(d){for(;d=getchar();)putchar(d>47&d<58?a[d-48]+33:d);}

@millinon whoa, huge savings! thanks ;)

I'm actually getting an error where it doesn't terminate on EOF. EOF is typically -1, so evaluating EOF doesn't yield false.

@millinon sorry, i read infinitely quite literally. you have to check for eot at getchar if you need an escape code :(

@bebe When I tested my original code, I didn't get EOF, just new lines.

If you want to test for EOF, you can use d>0 instead of d!=10. Then newlines will still work, and it'll stop at EOF or a null byte.

@millinon Yeah I just tried actual console input instead of STDIN redirection, and PowerShell doesn't send EOF. But I guess that would be a fair assumption.

a bit late but... ...for(;~(d=getchar());)... 90!

@bebe cheers! ^^

Perl - 74 57 42
Update thanks to core1024's comment:
s/\d/chr 33+(8,0,31,2..4,61,5,9,7)[$&]/eg

Run with:
perl -p program_name.pl

Update thanks to manatwork's comment:
say s/\d/chr@{[8,0,31,2,3,4,61,5,9,7]}[$&]+33/erg while<>

Test with:
perl -E 'say s/\d/chr@{[8,0,31,2,3,4,61,5,9,7]}[$&]+33/erg while<>'

Old attempts:
say s/[1234567890]/chr qw(41 33 64 35 36 37 94 38 42 40)[$&]/erg while(<>)

Using qw counts as a string literal though.
Test:
perl -E 'say s/[1234567890]/chr qw(41 33 64 35 36 37 94 38 42 40)[$&]/erg while(<>)'

Another way: Perl 40 - I think this counts as a string literal as well.
say tr/1234567890/!@#$%^&*()/r while(<>)

Test with:
perl -E 'say tr/1234567890/!@#$%^&*()/r while(<>)'

Are you sure that isn't a string literal? !@#$%^&*() sure looks like one.

@isaacg I didn't read the question closely enough and I think you're right. I updated with another solution.

As documentation describes qw// as “quote a list of words”, in my interpretation there you have 10 string literals. So I suggest to change it into array of integers (@{[41,33,…]} or something better) (no change in code size); leave off the parenthesis around the statement modifier's expression (2 characters shorter); subtract 33 from all character codes and add it separately (3 characters shorter); replace character class with \d wildcard (10 characters shorter): say s/\d/chr(@{[8,0,31,2,3,4,61,5,9,7]}[$&]+33)/erg while<>.

@manatwork thanks! nice work! I updated the answer. Also you can take the parenthesis out of chr(...).

You can use the -p flag to drop the while, say and the r RegEx modifier from your code. You can also save more bytes by using 33+(31,2..4,61)[] instead of @{[31,2,3,4,61]}[]+33.

You count your code's bytes +1 for the p flag. Try to save this in a text file with shebang like #!/usr/bin/perl -p or just perl -p file.pl.

JavaScript (ES6) - 79 76 87
Edit - bloated out by 11 chars after it was pointed out that it failed the "non-numbers are left alone" rule (thanks @soktinpk)
Warning - you'll need to reload your browser after you run it since it's following the "Read infinitely from stdin" bit...
(f=x=>f(alert(+(p=prompt())+1?String.fromCharCode([8,0,31,2,3,4,61,5,9,7][p]+33):p)))()

Note that I've interpreted prompt as stdin & alert as stdout
Tested in Firefox console.

Wouldn't you have to iterate over it? The input is not guaranteed to be one digit...

Also, this doesn't satisfy the rule characters which aren't digits should be left alone.

@soktinpk - on your first point, it loops indefinitely by recursively calling itself (it's an interpretation of how to indefinitely read from stdin in javascript... the implication of the question is that it should process each character as it comes in, which is effectively what I'm doing, via a prompt). Your second point is spot on though, I missed that... will have to revisit the code...

@soktinpk - fixed now - but it cost me 11 characters. Curse you! :P

Pyth, 43
W1sm?C+33@[8Z31 2 3 4 61 5tT7)vd}Cdr48 58dw

Uses 33+table lookup, instead of straight table lookup. No translate function here, just a normal map. Note that Z=0 and tT=9.

Scala, 106 bytes
def f{println(readLine.map{c=>try{(Seq(8,0,31,2,3,4,61,5,9,7)(c.toInt-48)+33).toChar}catch{case _=>c}});f}

Pretty-printed:
def f {
  println(readLine.map { c =>
    try {
      (Seq(8,0,31,2,3,4,61,5,9,7)(c.toInt - 48) + 33).toChar
    } catch {
      case _ => c
    }
  })
  f
}

pyg-i (68)
Here is a solution in pyg-i, a fork of pyg I created:
while 1:P(Ip().t(dict(Z(R(48,58),(41,33,64,35,36,37,94,38,42,40)))))

The python 3 equivalent would be this:
while 1:print(input().translate(dict(zip(range(48,58),(41,33,64,35,36,37,94,38,42,40)))))

Or, with a little cheating, it can be done in 50 bytes.  Note that this is a bytes literal, not a string literal:
while 1:P(Ip().t(dict(Z(R(48,58),b"(!@#$%^&*("))))

CoffeeScript (70)
Update: This may be seen as reading between the lines, but while strings and characters aren't allowed, regexs are. (I just converted the regex to a string).
alert prompt().replace /\d/g, (t)->([]+/!@#$%^&*()/)[1...-1][(+t+9)%10]

Or (for infinite)
loop alert prompt().replace /\d/g, (t)->([]+/!@#$%^&*()/)[1...-1][(+t+9)%10]

The normal version (in case regex isn't allowed):
alert prompt().replace(/\d/g, (t) ->String.fromCharCode(([]+4133643536+3794384240).match(/\d{2}/g)[t]))

Test it out here.
But, according to the problem statement,

Read infinitely from stdin

That will probably hang your browser eventually, but here it is (just prepend loop, extra 5 bytes, to the code):
loop alert prompt().replace(/\d/g, (t) ->String.fromCharCode(([]+4133643536+3794384240).match(/\d{2}/g)[t]))

Looks like you used a string literal.

@isaacg Updated, sorry.

Befunge 98 - 119 bytes
This is also with the STRN fingerprint, that allows "S" to stand for a convert integer to string instruction.
v>0 NRTS 4( >&S v         >$a,v
5 )!@#$%^&*(    >:1       w1  v
7^       p<     ^,g1--3*77<
>*1-:30p80^ ^                 <

Haskell, 89
f 50=64
f 54=94
f 55=38
f 56=42
f 57=40
f 48=41
f x|x<48||x>57=x|0<1=x-16
g=map$chr.f.ord

tests:
Prelude> g "11g2;;'1g2311hh21930"
"!!g@;;'!g@#!!hh@!(#)"
Prelude> g "117758326"
"!!&&%*#@^"

CJam - 32
qA,s26063649909601297730 95b:cer

Try it at http://cjam.aditsu.net/
Explanation:
q reads the whole input
A, creates the array [0 1 ... 9] (A=10)
s converts to string, obtaining "0123456789"
95b converts the previous big number to an array of base-95 digits, which are the ASCII codes of the 10 symbols we want
:c converts the ASCII codes to characters, obtaining the string ")!@#$%^&*("
er transliterates "0123456789" to ")!@#$%^&*(" in the input string

tcl, 156
proc x n {format %c $n}
while 1 {puts [string map "1 [x 33] 2 [x 64] 3 [x 35] 4 [x 36] 5 [x 37] 6 [x 94] 7 [x 38] 8 [x 36] 9 [x 40] 0 [x 41]" [gets stdin]]}

testable on http://www.tutorialspoint.com/execute_tcl_online.php?PID=0Bw_CjBb95KQMRE4tMlc3cmJhNG8

PYTHON: 166 86
Not better than the current answers, but the shortest Python solution I can think of as of yet.
(thanks to pseudonym117 for helping me shorten this significantly)
def g(s):
 d=')!@#$%^&*('
 g=''
 for c in s:
  try:g+=d[int(c)]
  except:g+=c
 yield g

d=')!@#$%^&*(' is way shorter, though it uses string literals. your original answer does too though

Whoops, definitely grazed right over that limitation. I'll leave this one up anyway, and take your suggestion which for some reason I totally didn't think of.

also w=int(c) seems to not do anything at all, and g+=d[c] would need to be changed to g+=d[int(c)]

w=int(c) is to catch anything that isn't a number that may be in the string. int() raises an exception if it isn't passed a proper integer.

ah. still, combining the 2 lines into 1 would work identically.


text:
The Mouse's Tale
Write a program that outputs Lewis Carroll's poem The Mouse's Tale from Alice in Wonderland, drawn in its distinctive tail-like shape.

Plain text of the poem:

Fury said to a mouse, That he met in the house, 'Let us both go to law: I will prosecute you.— Come, I'll take no denial; We must have a trial: For really this morning I've nothing to do.' Said the mouse to the cur, 'Such a trial, dear sir, With no jury or judge, would be wasting our breath.' 'I'll be judge, I'll be jury,' Said cunning old Fury; 'I'll try the whole cause, and condemn you to death.'

Your output could be ASCII art or an image or an animation or a webpage or pretty much anything that follows the rules. The point of course is to be artistic and original.
The highest voted answer will win in approximately one week.
Rules

Your representation of the poem must exactly match the quoted text above.
Your representation must be legible. Any literate person with decent eyesight should be able to decipher it and not have to zoom in.
The tail must be vertically oriented, taking roughly 2 to 3 times more vertical space than horizontal space.
The tail must be thicker at the top and grow thinner as it gets to the bottom.
There must be at least 3 distinct curves or turns in the shape of the tail. (I count 5 above.)
You may not use existing images/layouts of the poem as your output or in your code.
You must actually write a program that generates your output. You cannot simply arrange some text in Photoshop.

JavaScript, animated edition
Live Demo

HTML

        "It is a long tail, certainly," said Alice, looking down with wonder at the Mouse's tail; "but why do you call it sad?" And she kept on puzzling about it while the Mouse was speaking, so that her idea of the tale was something like this:—"

CSS
#wrapper { width: 300px; font: 16px serif; text-align: justify; }
p { margin: 0; padding: 0; }
p.wordEl { position: relative; }

JS
var poem = "Fury said to a mouse, That he met in the house, 'Let us both go to law: I will prosecute you.- Come, I'll take no denial; We must have a trial: For really this morning I've nothing to do.' Said the mouse to the cur, 'Such a trial, dear sir, With no jury or judge, would be wasting our breath.' 'I'll be judge, I'll be jury,' Said cunning old Fury; 'I'll try the whole cause, and condemn you to death.'\" ",
    words = poem.match(/.{0,15}[ ]/g),
    wordEls = [],
    tail = document.getElementById('tail'),
    startFontSize = 16,
    endFontSize = 8;

for (var i = 0; i < words.length; ++i) {
    var word = words[i].slice(0, words[i].length - 1);

    var wordEl = document.createElement('p');
    wordEl.className = 'wordEl';
    wordEl.innerText = word;
    wordEl.style.setProperty('font-size', (Math.round(((words.length - i) / words.length) * (startFontSize - endFontSize)) + endFontSize) + 'px');
    wordEls.push(wordEl);

    tail.appendChild(wordEl);
}

var counter = 0;
setInterval(function() {
    ++counter;
    for (var i = 0; i < wordEls.length; ++i) {
        var sn = Math.sin((i*2 + counter) / 5) * 150; // sn = result of math.SiN
        var wsn = sn * (i / wordEls.length); // weighted sn
        wordEls[i].style.setProperty('left', (wsn + 150) + 'px');
    }
}, 50);

-1: cannot read it=) Really like that idea of the animation!

I can just read it at this speed so it's alright.

I fixed the fiddle: http://jsfiddle.net/aLay9/3/


text:
Base-2 integer logarithm of 64-bit unsigned integer
Problem:
In your choice of language, write the shortest function that returns the floor of the base-2 logarithm of an unsigned 64-bit integer, or –1 if passed a 0. (Note: This means the return type must be capable of expressing a negative value.)
Test cases:
Your function must work correctly for all inputs, but here are a few which help illustrate the idea:
               INPUT ⟶ OUTPUT

                   0 ⟶ -1
                   1 ⟶  0
                   2 ⟶  1
                   3 ⟶  1
                   4 ⟶  2
                   7 ⟶  2
                   8 ⟶  3
                  16 ⟶  4
               65535 ⟶ 15
               65536 ⟶ 16
18446744073709551615 ⟶ 63

Rules:

You can name your function anything you like.
Character count is what matters most in this challenge.
You will probably want to implement the function using purely integer and/or boolean artithmetic. However, if you really want to use floating-point calculations, then that is fine so long as you call no library functions. So, simply saying return n?(int)log2l(n):-1; in C is off limits even though it would produce the correct result. If you're using floating-point arithmetic, you may use *, /, +, -, and exponentiation (e.g., ** or ^ if it's a built-in operator in your language of choice). This restriction is to prevent "cheating" by calling log() or a variant.
If you're using floating-point operations (see #3), you aren't required that the return type be integer; only that that the return value is an integer, e.g., floor(log₂(n)).
If you're using C/C++, you may assume the existence of an unsigned 64-bit integer type, e.g., uint64_t as defined in stdint.h. Otherwise, just make sure your integer type is capable of holding any 64-bit unsigned integer.
If your langauge does not support 64-bit integers (for example, Brainfuck apparently only has 8-bit integer support), then do your best with that and state the limitation in your answer title. That said, if you can figure out how to encode a 64-bit integer and correctly obtain the base-2 logarithm of it using 8-bit primitive arithmetic, then more power to you!
Have fun and get creative!

Why the restriction to C? Language-specific challenges are generally frowned upon. Also, what's the meaning of the bonus? (And also I don't think there is any need to show two ungolfed solutions right away.)

@MartinBüttner — Oh, ok, I didn't realize that. I'm new here (not to SX but to CG.SX). Thanks for pointing that out. I'll remove the restriction and delete the second example, and I'll eliminate the language-specific requirement.

@MartinBüttner — Actually, went ahead and deleted both examples.

No floating point? There goes my best idea (inspired by the famous fast inverse square root.) Assign the number to float, cast it bitwise to an integer, and extract the exponent from it by rightshifting by a constant.

@steveverrill — OK, I'll edit the question to allow floating-point so long as no external library functions are used. Looking forward to hearing your idea!

As you changed the rules for me I went ahead and posted :-) All questions on PPCG should have an objective winning criterion. My answer is not a winner under pure code golf. If it is your intention to reward creative answers, you should do so in an objective way. See this question for example:  http://codegolf.stackexchange.com/q/23581/15599. Otherwise, you can delete your rule 3 and make it a pure code golf. I won't mind if you do that.

@steveverrill — I'll delete rule 3 and make it a pure code golf. That doesn't preclude someone from posting a perverse solution for fun. :)

If only I knew enough about x86 machine code to submit a 2-instruction LZCNT and subtract from 63...

C,89
Per my comment on the question, here's a quirky way to do it, inspired by this famous function: http://en.wikipedia.org/wiki/Fast_inverse_square_root
f(uint64_t x){__float128 y=x;__int128_t i = *(__int128_t*)&y;return x?(i>>112)-16383:-1;}

I store the number as a float. Then to extract the exponent of the float, I cast it bitwise to an integer, rightshift the integer and subtract the bias.
Unfortunately to get the last example to run correctly, a 128 bit float is required. A 64 bit float has only 52 bits for the mantissa, so it rounds 18446744073709551615 up to 18446744073709551616 (2^64). The standard IEEE 128-bit float has a 112 bit mantissa (which we shift out and discard) and a bias of 16383 on the exponent. These are the constants you see in the function.
the requirement f(0)=-1 has to be handled with a ternary operator ?:. Otherwise it would return -16383.
Here's a complete program using type names per GCC. I can't get it to run on visual studio or ideone at the moment, will try later.
#include <stdint.h>

uint64_t a;

f(uint64_t x){
  __float128 y=x;
  __int128_t i = *(__int128_t*)&y;
  return x?(i>>112)-16383:-1;
}

main(){
  scanf("%llu",&a);
  printf("%llu %d",a,f(a));
}

Wicked cool. Can this method be adapted to use long double instead of __float128, assuming your compiler's long double is at least 80 bits? Because I know that at least on my compiler, which has long double of 80 bits, it works fine for all 64-bit unsigned integers to do return (int)log2l(x);.

@Todd If your 80-bit long double can hold the 64-bit integer without rounding (I believe most do) you should be able to adapt this. I went with the first thing I found, some of the definitions were a bit vague, and it was guaranteed to work with 128 bits, so I didn't waste much time looking at 80 bits. You'll still need an integer larger than 64 to cast your 80-bit float into, though (unless you cast it into an array.) You might get away with casting to a 64 bit integer on big-endian machines, which are more likely to throw away the least significant bits than the most significant bits.

C 40 54
Edit Clever recursive trick by @Kyle - that's creative!
int l(uint64_t n){return n?l(n/2)+1:-1;}

(Previous version: That's the bare starting point - creativity level 0)
int l(uint64_t n){int r=-1;for(;n;n>>=1)r++;return r;}

Test: Ideone

Nice. I can see how to shorten that by 1 character with either of {int r=-1;for(;n;n/=2)r++;return r;} or {int r=0;for(;n;n/=2)r++;return--r;}, but I can't see how to go any shorter than that.

make it a ternary-recursive?
return n?l(n/2)+1:-1;

Daaaayammm, guys!! That is amazing work. That's not just creative; that's sick genius right there.

Haskell, 24 bytes
Can't come remotely close to the Golfscript answer, but I think this one in Haskell has everything else beat so far...
f 0= -1;f n=f(div n 2)+1

E.g.: Running with the test cases provided gives:
> map f [0,1,2,3,4,7,8,16,65535,65536,18446744073709551615]
[-1,0,1,1,2,2,3,4,15,16,63]

Ah, a recursive solution! Very nice.

Of course, recursion is the bread and butter of haskell

Golfscript 7 (or 11)
2base,(

or, if you want the actual function definition:
{2base,(}:f

you can test it here.
If you consider "base" to be cheating, then add two chars for:
{}{2/}/,(

Wow. That is clever. Convert it to a base-2 number, take the length, and decrement. Nice.

I would consider a log function as cheating, but not base as you've used it, as you've basically stringified it (into an array) and measured the length. It's not quite in the spirit of what I'd been thinking (which was to use integer arithmetic) but every language has peculiar magical features, and this isn't your standard straightfoward cheat. I'm guessing nobody is going to do better than this one!

Thanks! I actually like my alternative solution better (and I'd understand if you want to disallow "base" type operations - feel free). My alternative collects all the divisions by 2 until it reaches 0, then takes the size and decrements.

It is interesting that Golfscript's base function returns an empty array for the value 0, rather than [0]. That gives you the –1 with no extra effort. :)

Yeah I always thought that feature of GS was weird but now it makes sense - it allows you to easily calculate logs in any base.

Your 9-character looping solution is awesome. Probably my favorite so far. It's 100% within the spirit of the question, and extremely terse. (Although, technically, it's not a callable function, so it's really only 99% within the spirit of the question. It's 4 more characters to make it an actual function definition then?)

Yeah I meant to imply that the same rule applies to that version - add 4 to make it callable. That's why I said "add two chars" instead of "make it 9 bytes", because it depends on which you were counting.

Technically you should add a semicolon after f

@aditsu I believe the semicolon is unnecessary for the function definition to be valid. Why? Because if the user wanted well-golfed code, they'd typically define it where they first use it. So the user of the code would finish it with a '~' (tilde). While declaring your functions at the top of your program and using them below is considered best practice in normal programming, doing so in codegolf is a waste of precious characters.

Python 2, 26
t=lambda n:len(bin(n+n))-4

This is similar to the Python 3 answer by Tim S.  However, doubling n and then subtracting 4 from the length has the advantage of working whether n is positive or zero.
If n > 0, then doubling n adds one to the binary length, so we compensate by subtracting 4 instead of 3. On the other hand, if n = 0, then the function returns -1 as desired.

APL (Dyalog Unicode), 7 bytes
⌊2⍟.5∘⌈

Try it online!
APL (Dyalog Unicode), 13 bytes
{⍵=0:¯1⋄⌊2⍟⍵}

My first APL answer!
Try it online! (Courtesy of Adám.)

It's 13 bytes because it uses it's own code page

Try it online!

Gotcha. I'll keep a note of that.

-6: ⌊2⍟.5∘⌈

A month late, but I'll add it in lmao

GNU dc, 30 bytes
[_1pq]sz?d0=z[d2/d0<m]dsmxz2-p

Takes input from STDIN.  Counts the number of times we can divide by 2.
Test output:
$ for i in 0 1 2 3 4 7 8 16 65535 65536 18446744073709551615
> do echo $i | dc log.dc
> done
-1
0
1
1
2
2
3
4
15
16
63
$

Ha! NICE. Wasn't expecting something like that!

J, 11 chars
Uses the length of the base2 representation but for 0 it yields 1 We add the signum of the original number and subtract 2 thus getting the desired values for all n>=0.
   (2-~*+#@#:) 18446744073709551615x  NB. x is for extended precision number
63

your solution only 9 characters according to the usual scoring rules as you can omit the braces.

Rust, 28 bytes
|n|63-n.leading_zeros()as i8

Try it on the Rust Playground!
An anonymous function that takes in a u64 and outputs the answer as an i8. Change 63 to 127 and it'll work for u128s too.

x86_64 machine language on Linux, 11 8 bytes
0x0:  83 C8 FF          or eax, -1
0x3:  48 0F BD C7       bsf  rax, rdi
0x7:  C3                ret

-3 thanks to @PeterCordes
This uses the "bit scan reverse" instruction to put the index of the most significant 1 bit in rax. The or eax, -1 is to handle the case of zero input. This version no longer depends on ABM or BMI1 instructions and should work on all x86_64 processors.
To Try it online!, compile and run the following C code
(*f)()="\x83\xc8\xff"     // or eax, -1
       "\x48\x0f\xbd\xc7" // bsr rax, rdi
       "\xc3";            // ret

main(){
  printf("%d\n",f(0));
  printf("%d\n",f(1));
  printf("%d\n",f(2));
  printf("%d\n",f(3));
  printf("%d\n",f(4));
  printf("%d\n",f(7));
  printf("%d\n",f(8));
  printf("%d\n",f(16));
  printf("%d\n",f(65535));
  printf("%d\n",f(65536));
  printf("%d\n",f(18446744073709551615));
}

You can use a global-scope asm statement to write a function in asm (instead of manually-encoded machine code), and there's no need to use an ugly hack like a function-pointer to a string literal because you're golfing the machine code, not the C representation of it; that's just a test harness.  https://tio.run/##dc7fCoIwFAbw@z3FWAUbWGhuahk9STe2PzrQKU5Bip7dbEU3rZux73c4H4dvS87nubANRup4MQig@sbNADe90IF7HXajrSBch1Os3rntIFzGxeSiHa@vKN2O/GAvBwRIDkZjdWmkgAp/v3VrSpLPK214PQoJT3YQut1VZ9AU2mByB7DrtRkURhuxtAUKh2Tp@tHIq3uvxl6lXk29mvlvSLycMBazvxP/TpRRmqSUhmmchgfGoiRyFY/5CQ

bsr with a zero input leaves the destination unmodified (AMD documents this; Intel implements it in practice but documents is as "undefined"; that's why bsr/bsf, and even lzcnt/tzcnt/popcnt, have false dependencies on the output register), and otherwise 63-lzcnt = bsr, the bit-index of the highest set bit. Alternatively; gcc's trick of "xor $0x3f, %eax\n" bit-scan result instead of 63-x almost works, but not for EAX=64.  Anyway, BSR is shorter than LZCNT, so it's a win if you don't mind de-facto standard behaviour that only AMD documents.

8 bytes: or eax,-1 / bsr rax, rdi / ret https://tio.run/##dY7NSsQwFEb3eYpLxkKKHaeZJu38iDt3sxIEF246TdsJTJOStKCIz16TFlEwZnVz7vk@brVuq2qaStsR3BxeFUYAmw3uR3uBmzX9AboHiEz5thCsDfh9AlE9MwCvQQbn96G23jhb4wJCJt@xxWCLcYCnxxe4hS3ovtKidmOnhel80tTD3Pf7uSSdkyg@IiTVAA0ZlZWtqgVctWrj47SSqrqOruveDkLqu8vDLHalVCT@QNAb920IjoS7JmlIGruuP5QG6TZIsyBlQVoE6S58Qx7EOecZ/3cTztAdY3nBWFpkRbrnnOaUP59O3v2cvgA

More about BSF/BSR output dependency: Why does breaking the "output dependency" of LZCNT matter? / VS: unexpected optimization behavior with _BitScanReverse64 intrinsic  (quotes and links AMD's manual, but C intrinsics don't expose that unmodified-output functionality)

Can you output only al and use mov al, -1 (B0 FF)?

Python 3, 38 bytes
def f(n):return(-1,len(bin(n))-3)[n>0]

bin(n) produces a string like 0b100, so you have to subtract 3, not just 1. (a,b)[condition] is a trick I took from Tips for golfing in Python.

lambda x:len(bin(x))-3if x else-1 is what I came up with, but since it's so similar to yours, I'll give it as a golf tip. f=lambda x:x and len(bin(x))-3or-1 this would work, except that the output is 0 for 1, so it will incorrectly return -1.

C, 72
Using a binary split method
int k(uint64_t x){int i=64,r=-!x;while(i/=2)x>>i?x>>=i,r+=i:0;return r;}

ungolfed, unwound version with lookup table options.
#define USETABLE256
int msb(unsigned long long x){
    char ret = -1;

    if (x>0xFFFFFFFF){ ret+=32; x>>=32; }
    if (x>0xFFFF){ ret+=16; x>>=16; }
    if (x>0xFF){  ret+=8;  x>>=8;  }
#ifdef USETABLE256
    return ret + ((const char[256]){
 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
    })[x];
#else
    if (x>0xF){        ret+=4;  x>>=4;  }
#ifdef USETABLE16
    return ret + ((const char[16]){0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4})[x];
#else
    if (x>3){        ret+=2;  x>>=2;  }
    if (x>1){        ret+=1;  x>>=1;  }
    return ret + x;
#endif
#endif
}

Nice. Both of these run in essentially constant time then? Given that log₂64 is constant, that is?

Hey, it looks like you can shave off 5 additional characters from the (original version of) body of your looping version by doing this: int i=32,r=-!n;for(;i;i/=2)n>=1LL<<i?r+=i,n>>=i:0;return r;. That gets you down under 80 characters (to 78, if I'm subtracting correctly)!

technosaurus — I really like your looping version a lot because I think it is probably the fastest possible general way to do it. Have you benchmarked the looping version vs. the table-lookup version? One advantage the looping version has is that it doesn't have to do any memory accesses.

I see you took the suggested edits. :) You can also shave off one more character still by replacing i>>=1 with i/=2 :-) BTW, my apologizes for any confusion on n vs. x. (In my own test program, I was using n and I just cut & pasted it without thinking.)

@ToddLehman - thanks changed - left the bitops in the unwound version (compiler normally does this for factors of 2 anyhow).  I added the lookup table versions for systems where jumps are expensive compared to memory access.  It will vary with architecture.  Putting them as an inline const vs using a local variable helps with locality to try to prevent cache misses.

That's cool. BTW, you could shave yet off another character, bringing it down to 77 characters, by starting i at 64 instead of 32 and then combining the test and the shift: int i=64,r=-!n;while(i/=2)x>=1LL<<i?r+=i,x>>=i:0;return r;

Oh hey! You might like this! It's possible to shave off still another 5 characters (bringing it down to 72) by testing x>>i rather x>=1LL<<i. Check it out: int i=64,r=-!x;while(i/=2)x>>i?x>>=i,r+=i:0;return r;. I'm pretty sure now it's impossible to get it any shorter in C using this method.

@ToddLehman nice, I used it to put together this macro that optimizes well for any integer type #define MSB(x) do{int i=(sizeof(x)*8),r=-!x;while(i>>=1)x>>i?x>>=i,r+=i:0;x=r;}while(0)

Awesome. I like that you wrapped it in a #define macro. MSB(x) can't be used as an rvalue, but at least it works for any integer size.

@ToddLehman the compilers did not optimize /2 very well but with the sizeof part it can do any integer type without extra jumps .... oddly you can calculate the number of jumps by passing the number of bits to itself

technosaurus — That's odd; what compiler are you using? Do you mean that it generated different assembly code between i>>=1 and i/=2? (Wait...oh! Because i is int and not unsigned int?)

Befunge 93 - 23
1-&: v
v+1\ _$.@
>\2/:^

Limited by implementation to 2^31 or 32-bit signed ints. Given a 64 bit unsigned (128 bit signed?!) implementation this code meets criteria.

TI-30XB - 19 (Instructions)
I won't actually participate in this contest with the following codes, but I found out this clever solution for my TI-30XB calculator: log(x)/log(2)+10^12-10^12. First of all, I wont participate because I clearly used the log function. Second, who actually has TI calculators... Third, this one's probably gonna win because its only 19 instructions. :D (Oh wow, but look at that golfscript code...) I just want to point out that there are more ways to floor a float, if any of you are interested. (For the C programmers its probably still smaller to use int's instead). By the way I am just abusing overflow handeling here. Since the TI-30XB stores floats, adding 10^12 to it will remove everything behind the dot.
TI-BASIC - 35 bytes
This one is a actual participant, but I bet none of you can execute it... Oh well just buy a TI-84 Plus then :D
:PROGRAM:LOG
:0→X
:If N=0
:-1→X
:While N>1
:iPart(N/2→N
:X+1→X
:END
:X

You would call the function (Or programs as they are called) like this:
:PROGRAM:TEST
:65535→N
:prgmLOG

X should now contain the value 15. Also, note that the X on the end of the program can actually be removed if the program is executed using prgmLOG (As shown above), since the X at the end is only used to display the number when the function is executed via the HOME screen. Yes, While, If, End and iPart( are one instruction each.

This is really clever! Nice solution. Fun to see!

Technically, these don't work as the calculators' floats are not precise enough to store 64 bits. If we allow them, then sum(Ans≥2^randIntNoRep(1,63 would also work.

x87 machine code, 27 23 bytes
Binary:
00000000: 9bd9 2e15 01d9 e8df 2cd9 f1df 1cad 85c0  ........,.......
00000010: 7902 f7d0 c37f 0f                        y......

Listing:
9B D9 2E 013F   FLDCW CW            ; set FPU CW register for floor rounding
D9 E8           FLD1                ; 1 * multplier into ST(1)
DF 2C           FILD QWORD PTR[SI]  ; load input into ST(0)
D9 F1           FYL2X               ; ST(0) = ST(1) * log2( ST(0) )
DF 1C           FISTP WORD PTR[SI]  ; store result into [SI]
AD              LODSW               ; result into AX
85 C0           TEST AX, AX         ; was result negative (zero divide)?
79 02           JNS  OKAY           ; if not, return result
F7 D0           NOT  AX             ; otherwise, negate AX (AL = -1)
            OKAY:
C3              RET                 ; return to caller
0F7F        CW  DW  0F7FH           ; x87 control word to round down

Callable function input as 64 bit signed QWORD at [SI], output in AL.
Size notes: checking for Zero and returning an explicit -1 costs 6 bytes.  Also, setting FPU to floor rounding costs 7 bytes.
Input/Output from test program:

ARMv8, 24 12 bytes
OakSim is technically an ARMv7 simulator, but if you want to test all test cases except for the last, you can still use it as reference.
The register widths of ARMv7 are 32 bit. I haven't found a good ARMv8 simulator yet, but the instruction set is backwards compatible, and the register widths should be 64 bit long.
Hexdump:
0x00010000: 10 0F 6F E1 3F 00 60 E2 1E FF 2F E1             ..o.?.`.../.

(If you're testing on OakSim's ARMv7, here is the respective hexdump:)
0x00010000: 10 0F 6F E1 1F 00 60 E2 1E FF 2F E1             ..o...`.../.

Explanation
This is a procedure that expects the argument in r0. Output goes to r0.
This expects the address of the caller in lr, as per the ATPCS (ARM Thumb Procedure Call Standard).
log:                  /* Name of our function */
    clz r0, r0        /* r0 = Count Leading Zeroes in r0 */
    rsb r0, r0, 63    /* r0 = 63 - r0 */
                      /* change this number to 31
                         if you're testing on ARMv7 */
    bx lr             /* Branch back to caller */

Example call:
b test         /* Skip over this procedure */
log:
               /* ommitted to save space */
test:
    mov r0, 0  /* Set input argument to e.g. 0 */
    mov lr, pc /* Set lr to address of program counter */
    b log      /* Jump to the procedure */

Note that ARMv8 is an entirely different instruction set than ARMv7.  The encoding is different as well.

Risky, 5 bytes
{?+0-_?:0

Try it online!
Uses a built-in log2 function, but since it operates on integers, it's technically allowed.
Explanation
{?+0-_?:0
{         log2(
 ?          input
  +         +
   0        0
          )
    -     -
     _    (
      ?     input
       :    =
        0   0
          )

Risky, 7 bytes
!_?}_2-__2-:?

Try it online!
Doesn't use a built-in log2 function.
Explanation
!_?}_2-__2-:?
!             length(
 _              (
  ?               input
                )
   }            base-convert
    _           (
     2            2
                )
              )
      -       -
       _      (
        _       (
         2        2
                )
          -     -
           :    (0 ≠
            ?     input
                )
              )

K (ngn/k), 13 bytes
-1+/|\(64#2)\

Try it online!
Uses "The log base 2 of an integer is the same as the position of the highest bit set" as outlined here.

(64#2)\ encode as 64 bits
|\ cumulative boolean or
-1+/ sum and subtract one

If it's ok for an input of 0 to return 0 instead of -1, #1_2\ can be used to save a byte.

Ruby, 30 bytes
f=->n{n>0?n.to_s(2).size-1:-1}

E.g.
irb(main):019:0> f[0]
=> -1
irb(main):024:0> f[65535]
=> 15
irb(main):025:0> f[65536]
=> 16

This converts n to a base-2 string and measures the length?

@Todd Yep! Also, it has to handle 0 as a special case.

Batch - 82
Due to language limitations, this only supports 32-bit ints

@set a=-2&set n=%1
:1
@set /aa=%a%+1&set /an=%n%/2&if %n% GTR 0 goto 1
echo %a%

PHP - 50 40
My final answer* inspired by @edc65, who was inspired to do a recursive version from @Kyle
function l($n){return $n?l($n>>1)+1:-1;}

My original version before the recursive answer was this:
function l($n){while($n){$n>>=1;$r++;}return$r-1;}

*I had to use the binary shift (>>) because division (/) kept making it a floating point, yielding wildy inaccurate/large answers (doing floating division until it ran out of decimal places and "became 0").
And casting to an (int) or using floor() cost more characters than the simple right shift.

Pxem, 56 bytes (content)
Unprintables are as backslash followed by its code point in octal.
.c.w\000\001\001.v.c.t.y\002.!.c.m.v\001.+.v.a.m.z\001.-XX.a.v.n.d.a.s-1.p

Usage

Call this subroutine after setting only one item as input.
Outputs the result to STDOUT instead of returning, as Pxem cannot have negative values unless given from STDIN.
Some garbages may return.

With comments
XX.z
# if top is not zero; then
.c.wXX.z
  # stack usage: input, 2^counter, counter(initially zero)
  .a\000\001\001.v.c.tXX.z
  # while input is greater than 2^counter; do
  .a.yXX.z
    # increment counter; done
    .a\002.!.c.m.v\001.+.v.aXX.z
  # if input differs from 2^counter; then decrement counter; fi
  .a.m.z\001.-XX.aXX.z
  # output counter; return
  .a.v.n.dXX.z
# done; output minus one
.a.a.s-1.p

Try it online!

Jelly, 5 bytes
BL’_¬

Try it online!
Explanation
BL’_¬ Main monadic link
B     Convert to binary
 L    Length
  ’   Decrement
   _  Subtract
    ¬   the argument negated

Clever solution! Nice!

JavaScript (Node.js), 17 bytes
n=>n?1+f(n/2n):-1

Try it online!
Similar

Holy crap, that's brilliant!

Julia, 23 bytes
!x=ndigits(2x,base=2)-2

Try it online!
based on mathmandan's answer

Wolfram Language (Mathematica), 21 bytes
If[#<1,-1,#0[#/2]+1]&

Try it online!

PowerShell Core, 38 bytes
param($a)for(;$a){$a=$a-shr1;$i++}$i-1

Try it online!
With a filter for 39 bytes
Longer and incorrect results with the built-ins :eyes:
Explanation
param($a)for(;$a){ # while a is not 0
$a=$a-shr1         # shift right by 1 the bits of a
$i++}              # increases the counter i by 1
$i-1               # outputs the counter minus one

MMIX, 16 bytes (4 instrs)
Essentially the same as the C answer, except it forces round-down and therefore can use a 64-bit float.
00000000: 0a000300 e400c010 3d000034 f8010000  ½¡¤¡ỵ¡ĊÑ=¡¡4ẏ¢¡¡

log2    FLOTU  $0,ROUND_DOWN,$0
        INCH   $0,#C010
        SR     $0,$0,52
        POP    1,0

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