text:
Randomize points on a disc
I read about circles somewhere, and just now learned about discs (it's actually a pretty common concept) and thought about codegolf.
Your task is to randomize a point/several points on a disc with the radius 1.
Rules:

All points must have an equal probability to be generated
Floating point coordinates must be used; the minimum requirement is two decimals (e.g. the points (0.12, -0.45) or (0.00, -1.00) are valid)
You get -20 bytes if your program actually displays the bounding circle and the point(s) generated in it. Coordinates still has to be valid but not displayed, and the image generated has to be at least 201 by 201 pixels in size
You get -5 bytes if your program takes the number of points to be generated as input on stdin
If you decide not to plot the bounding circle and the point(s), your program has to output the point(s) generated on the format (x, y) or (x,y) on stdout
If you decide to take the number of generated points as input, but not to plot it - your program has to output all the randomized points on the format stated above with or without one space in between

Shortest submission in bytes wins!

@sweerpotato Yes, please specify that all the points in and on the circle are valid. I did not realize you meant both. Also, this question seems like it would fit a code-golf challenge better than a popularity-contest, but that's just my opinion.

"Do XYZ in a creative way" is the classic Bad Popcon Question™. What one person considers creative is what another person considers the obvious way.

Out of curiosity, why a 201x201 pixel output requirement for plots?

@JohnE I suggested 201x201 pixels as it matches the required 2 decimal place accuracy

May we output the coordinates as complex numbers? For example: 0.3503082505747327+0.13499221288682994j.

If you decide to output the points graphically you may calculate the points as complex numbers as long as the coordinates are valid. If you decide to use stdout you have to output the coordinates on the format stated

In what format(s) may we output the points when we need to give back a list of points (to qualify for the -5)?

On the format stated with or without one space in between the generated points (last bullet)

Is newlines also ok (so one coordinate per line)? Or must it always be spaces?

No newlines, one or zero spaces in between the generated points

extra points: demonstrate that uniform density in both polar coordinates and carthesian system both give valid output (unless you consider that the limit of precision defines a point, which therefore is not a point, but a square)

Can we remove the space after the comma in the output?

Pyth, 26 - 5 = 21 bytes
VQp(sJ*@OZ2^.n1*yOZ.l_1)eJ

Takes the number of coordinates to generate on stdin, and outputs them on stdout like such:
(-0.5260190768964058, -0.43631187015380823)(-0.12127959509302746, -0.08556306418467638)(-0.26813756369750996, -0.4564539715526493)

Uses a strategy similar to @MartinBüttner, generating polar coordinates and radii, except it does it using complex exponentiation.

You can remove the p, can't you? It just changes the output to separate lines.

@Pietu1998 That's not allowed, see the comments on the main question.

Oh, all right.

CJam, 28 27 bytes
PP+mr_mc\ms]1.mrmqf*"(,)".\

This solution is not rejection-based. I'm generating the points in polar coordinates, but with a non-uniform distribution of the radii to achieve a uniform density of the points.
Test it here.
Explanation
PP+     e# Push 2π.
mr_     e# Get a random float between 0 and 2π, make a copy.
mc\     e# Take the cosine of one copy and swap with the other.
ms]     e# Take the sine of the other copy and wrap them in an array.
        e# This gives us a uniform point on the unit circle.
1.mr    e# Get a random float between 0 and 1.
mq      e# Take the square root. This is the random radius.
f*      e# Multiply x and y by this radius.
"(,)".\ e# Put the resulting numbers in the required format.

Why does it work? Consider a narrow annulus of radius r and (small) width dr. The area is approximately 2π*r*dr (if the annulus is narrow, the inner and outer circumference are almost identical, and the curvature can be ignored, such that the area can be treated as that of a rectangle with side lengths of the circumference and the width of the annulus). So the area increases linearly with the radius. This means that we also want a linear distribution of the random radii, in order to achieve a constant density (at twice the radius, there is twice as much area to fill, so we want twice as many points there).
How do we generate a linear random distribution from 0 to 1? Let's look at the discrete case first. Say, we have a desired distribution of 4 values, like {0.1, 0.4, 0.2, 0.3} (i.e. we want 1 to be 4 times as common as 0, and twice as common as 2; we want 3 three times as common as 0):

How can pick one of the four values with the desired distribution? We can stack them up, pick a uniformly random value between 0 and 1 on the y-axis and pick the segment at that point:

There's a different way to visualise this picking though. We could instead replace each value of the distribution with the accumulation of the values up to that point:

And now we treat the top line of this chart as a function f(x) = y and invert it to get a function g(y) = f-1(y) = x, which we can apply to a uniformly random value in y ∈ [0,1]:

Cool, so how can make use of this to generate a linear distribution of radii? This is the distribution we want:

The first step is to accumulate the values of the distribution. But the distribution is continuous, so instead of summing over all previous values, we take an integral from 0 to r. We can easily solve that analytically: ∫0r r dr = 1/2 r2. However, we want this to be normalised, i.e. to multiply it by a constant such that this gives 1 for the maximum value of r, so what we really want is r2:

And finally, we invert this to get a function we can apply to a uniform value in [0,1], which we can again do analytically: it's just r = √y, where y is the random value:

This is a fairly useful technique that can often be used to generate simple distributions exactly (it works for any distribution, but for complicated ones the last two steps may have to be solved numerically). However, I wouldn't use it in this particular case in production code, because the square root, sine and cosine are prohibitively expensive: using a rejection-based algorithm is on average much faster, because it only needs addition and multiplication.

Very nice explanation!

Mmm pictures :D

Mathematica, 68 44 - 20 = 24 bytes
Many thanks for David Carraher for letting me know about RandomPoint, which saved 24 (!) bytes. Mathematica does have a built-in for everything.
Graphics@{Circle[],Point@RandomPoint@Disk[]}

This plots the point and the bounding circle to qualify for the bonus:

The result is a vector image, so the size specification of 201x201 pixels doesn't really make sense, but by default it does render larger than that.

How about Graphics[{Circle[], Point@RandomPoint@Disk[]}] ?

Be my guest.  Also, to save 1 byte...Graphics@{Circle[], Point@RandomPoint@Disk[]}

@DavidCarraher Thanks a lot! :)

I don't know Mathematica syntax but surely you can save another byte by removing the space after the ,?

@fluffy I already did in the posted version

Ah, so you did.

CJam, 31 26 bytes
{];'({2dmr(_}2*@mhi}g',\')

This works by repeatedly generating random points in a square of side length 2 and keeping the first that falls inside the unit disc.
Thanks to @MartinBüttner for golfing off 3 bytes!
Try it online in the CJam interpreter.
How it works
{                  }g       Do:
 ];'(                         Clear the stack and push a left parenthesis.
     {      }2*               Do twice:
      2dmr                      Randomly select a Double between 0 and 2.
          (_                    Subtract 1 and push a copy.
               @              Rotate the copy of the first on top of the stack.
                mh            Compute the Euclidean norm of the vector consisting
                              of the two topmost Doubles on the stack.
                  i           Cast to integer.
                            If the result is non-zero, repeat the loop.
                     ',\    Insert a comma between the Doubles.
                        ')  Push a right parenthesis.

iKe, 53 51 bytes
Nothing particularly special, but I suppose we ought to have at least one graphical solution:
,(80+160*t@&{.5>%(x*x)+y*y}.+t:0N 2#-.5+?9999;cga;3)

Try it in your browser.
Edit: I can shave off two bytes by applying @MartinBüttner's approach for modifying the distribution of polar coordinates. I think it's also quite a bit more direct:
,(80*1+(%?c){x*(cos y;sin y)}'6.282*?c:9999;cga;3)

If you'd also draw the bounding circle you'd qualify for -20.

iKe has a raster-based drawing model, making that requirement rather unfair. I think it would cost quite a bit more than 20 characters to render an approximation of a bounding circle as well.

Perl, 59 Bytes
while(($x=1-rand 2)**2+($y=1-rand 2)**2>1){};print"($x,$y)"

This is just a simple solution, generating points in a square and rejecting those too far away.  My singular golfing trick is to include the assignments inside of the condition.
Edit: In the process of golfing, I found an interesting way to print random points on a circle.
use Math::Trig;$_=rand 2*pi;print"(",sin,",",cos,")"

Octave, 24 53 - 20 = 33 bytes
polar([0:2e-3:1,rand]*2*pi,[ones(1,501),rand^.5],'.')

Generates 501 equally-spaced theta values plus one random number and scales them all to [0..2π]. Then generates 501 1's for the radius of the circle, plus a random radius for the point and takes the square root to ensure uniform distribution over the disc. Then plots all the points as polar coordinates.

Here is a quick demonstration of the distribution (without the unit circle):
polar(2*pi*rand(99),rand(99).^.5,'.')

Octave / Matlab, 74 64 bytes
Rejection method, 64 bytes:
u=1;v=1;while u^2+v^2>1
u=rand;v=rand;end
sprintf('(%f,%f)',u,v)

Direct method, 74 bytes (thanks to Martin Büttner for helping me correct two errors):
t=rand*2*pi;r=1-abs(1-sum(rand(2,1)));sprintf('(%f,%f)',r*cos(t),r*sin(t))

R, 99 95 81-20 = 79 75 61 Bytes
symbols(0,0,1,i=F,asp=1,ylim=c(-1,1));points(complex(,,,runif(9),runif(9,-1)*pi))

Use the complex number construction to build the x/y's from polar coordinates.  Taking the input was a bit expensive and there is probably a better way to do this.  The ylim and xlim is to ensure the entire circle is plotted and the asp ensures the points are shown under the circle symbol.
Thanks to @jbaums and @flodel for the savings
Try it here

runif(9,0,1) can be simplified to runif(9)

@jbaums, thanks ... one of things that I always seem to forget:)

Can shave 14: symbols(0,0,1,i=F,asp=1,ylim=c(-1,1));points(complex(,,,runif(9),runif(9,-1)*pi))

@flodel very nice thank you.

Another teeny saving: yli works in place of ylim.

Processing /Java 141 bytes-20=121
the requirement for 201*201 being the minimum size requires me to put in the setup method since Processing.org defaults to 200x200 :(
void setup(){noFill();size(201,201);}void draw(){float f=10,a=PI*2*random(),r=random();point(f+f*sin(a)*r,f+f*cos(a)*r);ellipse(f,f,f*2,f*2)}

I didn't know processing/java was allowed, neat!

QBasic, 138 bytes - 20 - 5 = 113
INPUT n
r=200
SCREEN 12
RANDOMIZE TIMER
CIRCLE(r,r),r
PAINT(r,r)
FOR i=1TO n
DO
x=RND*r*2
y=RND*r*2
LOOP UNTIL POINT(x,y)
PSET(x,y),1
NEXT

Takes user input and draws the disc and points. Tested on QB64.

This is a pretty basic "throw at the dartboard and keep what sticks" strategy. The catch is that "what sticks" is not determined mathematically but graphically: a white disc is plotted on a black background, and then randomly generated points are rejected until they are not black. The points themselves are drawn in blue (though it's hard to tell when they're single pixels--click on the image to enlarge).

HPPPL, 146 (171-20-5) bytes
EXPORT r(n)BEGIN LOCAL R,A,i,Q;RECT();Q:=118.;ARC_P(Q,Q,Q);FOR i FROM 1 TO n DO R:=√RANDOM(1.);A:=RANDOM(2*π);PIXON_P(G0,IP(Q+Q*R*COS(A)),IP(Q+Q*R*SIN(A)));END;FREEZE;END;

Example for 10000 points (including timing in seconds for the real device):

The function itself is called by r(n). The rest in the image above is only for timing purposes.
Result (disc diameter is 236 pixels):

The version above does not store the point coordinates, so I wrote a version that takes two parameters r(n,p). n is the number of points and p=0 returns the points to the terminal, p=1 plots the points and the disc), in case storing coordinates is mandatory.
This version is 283 (308-20-5) bytes long:
EXPORT r(n,p)BEGIN LOCAL R,A,j,Q,x,y;Q:=118.0;CASE IF p==0 THEN print() END IF p==1 THEN RECT();ARC_P(Q,Q,Q) END END;FOR j FROM 1 TO n DO R:=√RANDOM(1.0);A:=RANDOM(2*π);x:=R*COS(A);y:=R*SIN(A);CASE IF p==0 THEN print("("+x+", "+y+")") END IF p==1 THEN PIXON_P(G0,IP(Q+Q*x),IP(Q+Q*y)) END END;END;FREEZE;END;

The ungolfed version:
EXPORT r(n,p)
BEGIN
LOCAL R,A,j,Q,x,y;
  Q:=118.0;
  CASE
    IF p==0 THEN print() END
    IF p==1 THEN RECT();ARC_P(Q,Q,Q) END
  END;
  FOR j FROM 1 TO n DO
    R:=√RANDOM(1.0);
    A:=RANDOM(2*π);
    x:=R*COS(A);
    y:=R*SIN(A);
    CASE
      IF p==0 THEN print("("+x+", "+y+")") END
      IF p==1 THEN PIXON_P(G0,IP(Q+Q*x),IP(Q+Q*y)) END
    END;
  END;
  FREEZE;
END;

Terminal output for r(10,0):

r(10,1) shows the disc with the points, like shown above.

awk - 95 - 5 = 90
{
    for(;$1--;printf"("(rand()<.5?x:-x)","(rand()<.5?y:-y)")")
        while(1<(x=rand())^2+(y=rand())^2);
}

Since i wasn't quite sure about the rand()<.5 part, I did some distribution testing with this, using this script:
BEGIN{ srand() }
{
    split("0 0 0 0", s)
    split("0 0 0 0", a)

    for(i=$1; i--; )
    {
        while( 1 < r2 = ( x=rand() )^2 + ( y=rand() )^2 );

        x = rand()<.5 ? x : -x
        y = rand()<.5 ? y : -y

        ++s[ x>=0 ? y>=0 ? 1 : 4 : y>=0 ? 2 : 3 ]

        ++a[ r2>.75 ? 1 : r2>.5 ? 2 : r2>.25 ? 3 : 4]
    }

    print "sector distribution:"
        for(i in s) print "sector " i ": " s[i]/$1

    print "quarter area distribution:"
        for(i in a) print "ring " i ":   " a[i]/$1
}

which for an input of 1e7 gives me this result, after I sipped once or twice at my coffee:
1e7
sector distribution:
sector 1: 0.250167
sector 2: 0.249921
sector 3: 0.249964
sector 4: 0.249948
quarter area distribution:
ring 1:   0.24996
ring 2:   0.25002
ring 3:   0.250071
ring 4:   0.249949

which I think is quite alright.
A little explanation:
After scribbling about for a while it turned out, that if you want to divide the disc into four rings with equal area, the radii where you would have to cut are sqrt(1/4), sqrt(1/2) and sqrt(3/4). Since the actual radius of the point I test would be sqrt( x^2 + y^2), I can skip the square rooting all together. The 1/4, 2/4, 3/4 "coincidence" might be related to what M. Buettner pointed out earlier.

JavaScript, 75 bytes
Rejection-based:
do x=(r=()=>4*Math.random()-2)(),y=r()
while(x*x+y*y>1)
alert(`(${[x,y]})`)

Direct method (80 bytes):
alert(`(${[(z=(m=Math).sqrt((r=m.random)()))*m.sin(p=m.PI*2*r()),z*m.cos(p)]})`)

Python, 135 130 bytes
from random import*
def r():return uniform(-1,1)
p=[]
while not p:
    x,y=r(),r()
    if x**2+y**2<=1:p=x,y
print'(%.2f, %2f)'%p

Removed the **0.5 thanks to @jimmy23013’s suggestion (because it is a unit circle, I am now checking whether the distance squared between (x, y) and (0, 0) is equal to 12. This is the same thing).
This also freed me to remove the parentheses.

I think you don't need the **0.5.

@jimmy23013 Thank you! removed.

uniform(-1,1) can be replaced with random()*2-1 to save 1 byte. You can also change def r():return uniform(-1,1) with r=lambda:uniform(-1,1) to save 6 bytes. Merging these together, def r():return uniform(-1,1) can be changed to r=lambda:random()*2-1 to save 7 bytes. x**2+y**2 can be reduced to x*x+y*y to save 2 bytes. It also seems you can change (%.2f, %2f) to %f,%f to save 6 bytes. Try It Online on TIO!.

Python 3.8 (pre-release), 82 79 78 Bytes
from random import*
r=random
while(x:=r()*2-1)*x+(y:=r()*2-1)*y>1:1
print(x,y)

-3 from TheThonnu by murdering whitespace and exponents.
-1 from TheThonnu by showing that you can change function names by variable assignment.
Verify that it actually works by running on TIO.

The walrus likes to assign variables and return their value at the same time, and I don't understand why...

79 bytes

78 bytes

@TheThonnu a newline takes the same amount of bytes as a semicolon, so it doesn’t  really matter which one you use. I also changed the capital R to a lowercase one.

Befunge-with-graphics, 224 212 bytes (237 before deductions)
Takes input from stdin, draws image to the screen.
>99*3*:s000fc88*3*::f765+jv
v1j0-10::*:+29p02j50p01j50<
>0g29+:*-:*20g92+:*-:*+v
v:-1xg02g01_v#!`*:*:+92<
>!#v_       >94+2*1j
v
0vu<
6>z:1-#v_@
#^$$$$$<
>$$99*3*%r
0
|!:-1\<>0>~:52*-   #v_$r
\  > v*  ^+**25\-"0"<
>#v?v 4
  0123+
  >>>>^

Explanation
Random coordinates are generated using the ? operator, to build a large random number. Each of the 4 directions the ? operator could go adds a new digit to a base-4 number which is then eventually modulo'd by the screen width to get a random coordinate on the screen. (bottom-most bit)
The distance from the centre of the circle is then calculated, and if it's outside the circle it generates a new pair of coordinates. Else, it draws a pixel and repeats, decrementing a counter. (top block of stuff)
Finally, the screen is updated and events are handled. (bit with all the $$$$s)
Circle with 10 points (to verify there are actually 10):

Circle with 10000 points:

I'm not certain this counts because of many factors

Befunge-with-graphics is my "made up" language, but it predates my knowledge of this question.
Since befunge doesn't support floating point, all coordinates are in pixels and may not have the required precision. The image, however, is greater than 201x201 pixels in size.
Technically no points can appear directly on the edge of the circle.

Desmos, 52 - 20 = 32 Bytes
r=1
a=1
b=1
(acosb,asinb)
a->random(),b->2πrandom()

I’ve never golfed in Desmos before. Click the bottom action to generate a random point. Try prettified version online. If anyone knows a shorter way to graph a polar coordinate point, please tell me, since I’m unaware of any builtin to graph a point in polar coordinates.


text:
We can do better: FALSE
The interpreter executable for FALSE is 1020 bytes large. I think we can do better than THIS:
��Û������������������ˆ��È���ˆB0�ˇ*,x�r�pH@NÆ˝T,�g�Œ$F(FIÏa®.GÏu0C˙íp%NÆ˝ÿJÄg�™,@"$<��ÌNÆˇ‚JÄg�í*�"�$&<��a®NÆˇ÷,�"NÆˇ‹F�k�r‹Ç*BA˙¸C˙Ra�ºª∆j��Úp�@�0j�^@�[f(¸A˙�8¸+(¸`�ˇ¯&Ã`‘@�]f8¸Nu c êàTÄ1@ˇ˛`º@�aj�T@�!kÆ@�{fª∆j��ö�}fÙ`ö@�"fB(¸A˙�(¸`��� Lª∆j
�"g›`ÚRçB ���gB êàTÄ1@ˇ˛(¸"NÆ8¸¸L`�ˇT@�'fp�8¸+<(¿`�ˇ@@�`f
 $Uå8¿`�ˇ0A˙�ˆ∞(�fVàr�8ÿQ…ˇ¸`�ˇ2g��p–¡`‡A˙TC˙^a��∫ ��gB\ êáÄ��� ‰à(¸��Ú G!@�!@�A˙¬"$<��ÓNÆˇ‚(�g��$"�$&ñáNÆˇ–"NÆˇ‹"N,x�NÆ˛bap�NuaÓ`"JNÆ˝Np
Nu@�:j�˛ûr�¬¸�
@�0“Ä�0k�:jp�`‰8¸+<(¡`�˛d@�{j�˛®@�aÂH8¸AÏ8¿8¸+`�˛H  êà‚àSÄ8ÿQ»ˇ¸Nu�+ —ï�- ëï�* ¡Ì�*Ä�/ "É¿H¡*Å�.    `%ld�A˙ˇ˙"$
NÆ¸FXç�! ]Nê�: ] ù�; ]+�= ∞ïW¿HÄH¿*Ä�? ] gNê�$�+�%�Xç�\ *≠�+@��@ -�+m��+U�*Ä�_�Dï�& ¡ï�| Åï�~�Fï�> ∞ï[¿HÄH¿*Ä�#L›�HÁ�¿ o�NêJùg WNê`Pè�,"$NÆ˛»�^"NÆ˛Œ+��¯ Âà+5���ﬂ"NÆ˛ò"NÆ˛òa.out���Û���������������������È����KÔ˜�IÔ¯�(à,x�C˙�p%NÆ˝ÿJÄfNu,@NÆˇƒ,�NÆˇ *�`dos.library�"N,x�NÆ˛bp�Nu����Ú

Challenge
Write a FALSE interpreter in any language (doesn't have to be an executable!). As usual, shortest bytes wins. Make sure to try to get it under 1020 though :)
Language Specs
Literals

123 put integer onto the stack
'c put character code onto the stack

Stack

$ DUP
% DROP
\ SWAP
@ ROT
ø PICK (dup the nth stack item)

Arithmetic

+ ADD
- SUBTRACT
* MULTIPLY
/ DIVIDE
_ negate (negative numbers are entered 123_)
& bitwise AND
| bitwise OR
~ bitwise NOT

Comparison (false is zero, true is all bits set (-1 or ~0) so that bitwise operators may be used)

> greater than
= equals

Lambdas and flow control (tests are for non-zero)

[...] define and put a lambda onto the stack
! execute lambda
? conditional execute: condition[true]?.

An if-else can be expressed as: condition$[\true\]?~[false]?

# while loop: [condition][body]#

Names

a-z put a reference to one of the 26 available variables onto the stack
: store into a variable
; fetch from a variable

Input and Output

^ read a character (-1 for end-of-input)
, write a character
"string" write a string (may contain embedded newlines)
. write top of stack as a decimal integer
ß flush buffered input/output

Other

{...} comment
 whitespace is ignored, may be needed to separate consecutive integers

Examples
Copy file:
{ copy.f: copy file. usage: copy < infile > outfile  }

ß[^$1_=~][,]#

Factorial:
{ factorial program in false! }

[$1=~[$1-f;!*]?]f:          { fac() in false }

"calculate the factorial of [1..8]: "
ß^ß'0-$$0>~\8>|$
"result: "
~[\f;!.]?
["illegal input!"]?"
"

Primes to 100:
{ writes all prime numbers between 0 and 100 }

99 9[1-$][\$@$@$@$@\/*=[1-$$[%\1-$@]?0=[\$.' ,\]?]?]#

I think the code you posted might not be displaying correctly. It probably contains unprintable characters. Can you provide a link to where you got the code?

Sure! http://strlen.com/files/lang/false/False12b.zip

Please include the language specification of FALSE in your challenge to make the post self-contained.

It might be a good idea to specify a controlled subset of FALSE. The inline machinecode facility of the language would make this considerably harder to implement portably, and the IO primitives might also limit participation by users of some languages.

What would you suggest removing?

@RK. The ` should be removed, as the inline machine code facility of the language would make this considerably harder to implement portably.(thanks @JohnE) The I/O can stay, imo.

Can you give some example programs with explanations?

I took some from the FALSE page on strlen.

@ConfusedMr_C I have no idea how your comment didn't show up in my notifications, but OK!

You say that a letter pushes a reference. What happens when you try to use an operator on a reference? E.g. 3 a + Or can we be guaranteed that variables always occur adjacent to a : or ;?

Also, can we be guaranteed to have a valid FALSE program as input?

I want to do this is betaload, but it's too complex. Things like ' would need to recognize every character. That's too bad, because FALSE is really very similar to Underload.

@ConorO'Brien I think math with references would be undefined behavior. Should we just edit the question and guarantee a valid input program so that the question can be on-topic?

@mbomb007 idk, there are still more problems. E.g. how does the flush command work?

@ConorO'Brien Python has sys.stdout.flush().

source: Stack Exchange

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

sort: votes


text:
Mutant pangolin
This is a code-golf challenge whereby you need to devise a program that acts like a quine or a quine that modifies itself to illustrate machine learning.
Background
There is a basic artificial intelligence program called 'the pangolin game' which is described here. The basic ideas is that the program when run the first time asks:

OK, please think of something
Is it a pangolin?

You may then reply either:

Yes

In which case it says:

Good. That was soooo easy.

Or if not it says:

Oh. Well you win then -- What were you thinking of?

To which you might say:

a dog

To which it would say

Please give me a question about a dog, so I can tell the difference between a dog and a pangolin

you might reply

Does it eat ants?

It would then ask:

What is the answer for a dog?

To which you would say

no

And it would say

Thanks

Next time it runs, it would ask the question above, and would build up a binary tree of such questions.
The challenge
Enough of the background. This challenge is to write a self modifying pangolin program. The rules are as follows:

Program output (as described above) should be to STDERR. The final response will always be "Good. That was soooo easy." or "Thanks". After this, it should output either the current version of the program, or a new version of the program that incorporates the question to STDOUT. No answer written in a language that does not support writing to STDOUT and STDERR or reading from STDIN will be valid.
In other words under UNIX you could invoke the program like this:

example:
$ mylanguage myprogram > myprogram.1
[dialog goes here]
$ mylanguage myprogram1 > myprogram.2
[dialog goes here]

The program has to use exactly the specified prompts (because shortening the prompts shows no skill). The prompts are (without the quotes, and where %s is substituted) as follows:

list:
"OK, please think of something"
"Is it %s?"
"Good. That was soooo easy."
"Oh. Well you win then -- What were you thinking of?"
"Please give me a question about %s, so I can tell the difference between %s and %s"
"What is the answer for %s?"
"Thanks"

When expecting yes/no answers, your program should accept y or yes in any case for 'yes', and n or no in any case for 'no'. What you do with non-conforming inputs is up to you. For instance you might decide to take any answer that begins with y or Y as 'yes', and anything else as no.
You may assume that the names of the things supplied and the questions consist only ASCII letters, numbers, spaces, hyphens, question marks, commas, full stops, colons, and semicolons, i.e. they match following regex ^[-?,.;: a-zA-Z]+$. If you can cope with more than that (especially the quoting characters in your chosen language) you get to be smug, but don't gain any extra points.
Your program may not read or write any file (excluding STDIN, STDOUT, and STDERR), or from the network; specifically it may neither read nor write its own code from disk. Its state must be saved in the program code itself.
When the program is run and guesses the answer correctly, it must perform exactly as a quine, i.e. it must write to STDOUT exactly its own code, unchanged.
When the program is run and guesses the answer incorrectly, it must encode the provided new question and answer within its own code and write it to STDOUT in its own code, so it is capable of distinguishing between its original guess and the provided new object, in addition to distinguishing between all previously given objects.
You must be able to cope with multiple sequential runs of the software so it learns about many objects. See here for examples of multiple runs.
Test runs are given at the link in the head (obviously covering only the STDIN and STDERR dialog).
Standard loopholes are excluded.

Should the program be able to mutate multiple times and support more than 2 animals? If so, can you provide an example "Please give me a question about ..." dialogue when there are already two or more animals the program knows about?

What if the user only says "dog" instead of "a dog"? Shall we parse the sentence to detect "a/an" or can we treat the answer literally? I assume so given the prompts you gave (%s).

@w0lf yes, you need to cope with multiple rounds. There are examples of multi-round games here: https://studentnet.cs.manchester.ac.uk/ugt/COMP26120/lab/ex9game.html - I will fix the documentation.

@coredump if the user says "dog" not "a dog", then the replies will not be grammatical. That's not an issue.

Oof. Trying to do this in Runic would be a nightmare. The primary reason being that wiring up all the bits to cope with arbitrary input strings (which then need to be present as string literals in the resulting output program) would be basically impossible. Oh and Runic can't output to STDERR.

This seemed like a fun "game", so rather than golf it, I made a codepen where you can play the Pangolin Game to your heart's content. Enjoy!

Common Lisp, 631 576
(let((X"a pangolin"))#1=(labels((U(M &AUX(S *QUERY-IO*))(IF(STRINGP M)(IF(Y-OR-N-P"Is it ~A?"M)(PROG1 M(FORMAT S"Good. That was soooo easy.~%"))(LET*((N(PROGN(FORMAT S"Oh. Well you win then -- What were you thinking of?~%")#2=(READ-LINE S)))(Q(PROGN(FORMAT S"Please give me a question about ~A, so I can tell the difference between ~A and ~A~%"N N M)#2#)))(PROG1(IF(Y-OR-N-P"What is the answer for ~A?"N)`(,Q ,N ,M)`(,Q ,M ,N))(FORMAT S"Thanks~%"))))(DESTRUCTURING-BIND(Q Y N)M(IF(Y-OR-N-P Q)`(,Q ,(U Y),N)`(,Q ,Y,(U N)))))))(write(list'let(list`(X',(U x)))'#1#):circle t)()))

Example session
Name the script pango1.lisp and execute as follows (using SBCL):
~$ sbcl --noinform --quit --load pango1.lisp > pango2.lisp
Is it a pangolin? (y or n) n
Oh. Well you win then -- What were you thinking of?
a cat
Please give me a question about a cat, so I can tell the difference between a cat and a pangolin
Does it sleep a lot?
What is the answer for a cat? (y or n) y
Thanks

Another round, adding the bear:
~$ sbcl --noinform --quit --load pango2.lisp > pango3.lisp
Does it sleep a lot? (y or n) y

Is it a cat? (y or n) n
Oh. Well you win then -- What were you thinking of?
a bear
Please give me a question about a bear, so I can tell the difference between a bear and a cat
Does it hibernate?
What is the answer for a bear? (y or n) y
Thanks

Adding a sloth (we test the case where the answer is "no"):
~$ sbcl --noinform --quit --load pango3.lisp > pango4.lisp
Does it sleep a lot? (y or n) y

Does it hibernate? (y or n) n

Is it a cat? (y or n) n
Oh. Well you win then -- What were you thinking of?
a sloth
Please give me a question about a sloth, so I can tell the difference between a sloth and a cat
Does it move fast?
What is the answer for a sloth? (y or n) n
Thanks

Testing the last file:
~$ sbcl --noinform --quit --load pango4.lisp > pango5.lisp
Does it sleep a lot? (y or n) y

Does it hibernate? (y or n) n

Does it move fast? (y or n) y

Is it a cat? (y or n) y
Good. That was soooo easy.

Remarks

I first forgot printing "Thanks", here it is.
As you can see, questions are followed by (y or n), which is because I'am using the existing y-or-n-p function. I can update the answer to remove this output if needed.
Common Lisp has a bidirectional *QUERY-IO* stream dedicated to user-interaction, which is what I'am using here. Standard output and user-interaction do not mess, which follows IMHO the spirit of the question.
Using SAVE-LISP-AND-DIE would be a better approach in practice.

Generated output
Here is the last generated script:
(LET ((X
       '("Does it sleep a lot?"
              ("Does it hibernate?" "a bear"
               ("Does it move fast?" "a cat" "a sloth"))
              "a pangolin")))
  #1=(LABELS ((U (M &AUX (S *QUERY-IO*))
                (IF (STRINGP M)
                    (IF (Y-OR-N-P "Is it ~A?" M)
                        (PROG1 M (FORMAT S "Good. That was soooo easy.~%"))
                        (LET* ((N
                                (PROGN
                                 (FORMAT S
                                         "Oh. Well you win then -- What were you thinking of?~%")
                                 #2=(READ-LINE S)))
                               (Q
                                (PROGN
                                 (FORMAT S
                                         "Please give me a question about ~A, so I can tell the difference between ~A and ~A~%"
                                         N N M)
                                 #2#)))
                          (PROG1
                              (IF (Y-OR-N-P "What is the answer for ~A?" N)
                                  `(,Q ,N ,M)
                                  `(,Q ,M ,N))
                            (FORMAT S "Thanks~%"))))
                    (DESTRUCTURING-BIND
                        (Q Y N)
                        M
                      (IF (Y-OR-N-P Q)
                          `(,Q ,(U Y) ,N)
                          `(,Q ,Y ,(U N)))))))
       (WRITE (LIST 'LET (LIST `(X ',(U X))) '#1#) :CIRCLE T)
       NIL))

Explanations
A decision tree can be:

a string, like "a pangolin", which represents a leaf.
a list of three elements: (question if-true if-false) where question is a closed yes/no question, as a string, and if-true and if-false are the two possible subtrees associated with the question.

The U function walks and returns a possibly modified tree.
Each question are asked in turn, starting from the root until reaching a leaf, while interacting with the user.

The returned value for an intermediate node (Q Y N) is (Q (U Y) N) (resp. (Q Y (U N))) if the answer to question Q is yes (resp. no).
The returned value for a leaf is either the leaf itself, if the program correctly guessed the answer, or a refined tree where the leaf is replaced by a question and two possible outcomes, according to the values taken from the user.

This part was rather straightforward. In order to print the source code, we use reader variables to build self-referential code. By setting *PRINT-CIRCLE* to true, we avoid infinite recursion during pretty-printing. The trick when using WRITE with :print-circle T is that the function might also returns the value to the REPL, depending on whether write is the last form, and so, if the REPL doesn't handle circular structures, like it is defined by the standard default value of *PRINT-CIRCLE*, there will be an infinite recursion. We only need to make sure the circular structure is not returned to the REPL, that's why there is a NIL in the last position of the LET. This approach greatly reduces the problem.

Looks good! The (y or n) is not required, but I am tempted to permit it as it is an improvement.

@abligh Thanks. About y/n, that would be nice, it helps and IMHO this is not really in contradiction with #3 which is about avoiding shortening the prompts.

Python 2.7.6, 820 728 bytes
(Might work on different versions but I'm not sure)
def r(O,R):
 import sys,marshal as m;w=sys.stderr.write;i=sys.stdin.readline;t=O;w("OK, please think of something\n");u=[]
 def y(s):w(s);return i()[0]=='y'
 while t:
  if type(t)==str:
   if y("Is it %s?"%t):w("Good. That was soooo easy.")
   else:w("Oh. Well you win then -- What were you thinking of?");I=i().strip();w("Please give me a question about %s, so I can tell the difference between %s and %s"%(I,t,I));q=i().strip();a=y("What is the answer for %s?"%q);w("Thanks");p=[q,t];p.insert(a+1,I);z=locals();exec"O"+"".join(["[%s]"%j for j in u])+"=p"in z,z;O=z["O"]
   t=0
  else:u+=[y(t[0])+1];t=t[u[-1]]
 print"import marshal as m;c=%r;d=lambda:0;d.__code__=m.loads(c);d(%r,d)"%(m.dumps(R.__code__),O)
r('a pangolin',r)

Well, it's not not as short as the Common Lisp answer, but here is some code!

Python 3, 544 bytes
q="""
d=['a pangolin'];i=input;p=print
p("OK, Please think of something")
while len(d)!=1:
    d=d[1+(i(d[0])[0]=="n")]
x=i("Is it "+d[0]+"?")
if x[0]=="n":
    m=i("Oh. Well you win then -- What were you thinking of?")
    n=[i("Please give me a question about "+m+", so I can tell the difference between "+d[0]+" and "+m),*[[d[0]],[m]][::(i("What is the answer for "+m+"?")[0]=="n")*2-1]]
    p("Thanks")
    q=repr(n).join(q.split(repr(d)))
else:
    p("Good. That was soooo easy.")
q='q=""'+'"'+q+'""'+'"'+chr(10)+'exec(q)'
p(q)
"""
exec(q)

Try it Online!
The questions/answers/responses are stored in an array, where if the array stores three items (e.g. ['Does it eat ants',['a pangolin'],['a dog']]) then it gets an answer to the question and repeats with just the contents of either the second or third item, depending on the answer. When it gets to an array with only one item, it asks the question, and since it has its entire source codeas a string it is able to use the split-join method to insert the extension to the array in order to add the new branch.
I originally wrote this not realising the quine requirement, so rereading the question and having to find a way that I could both execute code and use it as a string was difficult, but I eventually stumbled upon the idea of the nice expandable quine format:
q="""
print("Some actual stuff")
q='q=""'+'"'+q+'""'+'"'+chr(10)+'exec()'
print(q)
"""
exec(q)

Python 3, 497 bytes
t=["a pangolin"];c='''p=print;i=input;a=lambda q:i(q)[0]in"Yy"
def q(t):
  if len(t)<2:
    g=t[0]
    if a(f"Is it {g}?"):p("Good. That was soooo easy.")
    else:s=i("Oh. Well you win then -- What were you thinking of?");n=i(f"Please give me a question about {s}, so I can tell the difference between {s} and {g}.");t[0]=n;t+=[[g],[s]][::1-2*a(f"What is the answer for {s}?")];p("Thanks")
  else:q(t[2-a(t[0])])
p("Ok, please think of something");q(t);p(f"t={t};c=''{c!r}'';exec(c)")''';exec(c)

Quite similar to Harmless' answer for tree representation. It recursively asks the next question, while going deeper into the list, until there is only one response.
Ungolfed version (without quining)
tree = ['a pangolin']

def ask(question):
  answer = input(question + '\n')
  if answer.lower() in ['yes', 'no']:
    return answer.lower() == 'yes'
  else:
    print('Please answer "yes" or "no".')
    return ask(question)

def query(tree):
  if len(tree) == 1:
    guess = tree.pop()
    if ask(f'Is it {guess}?'):
      print('Good. That was soooo easy.')
      tree.append(guess)
    else:
      thing = input('Oh. Well you win then -- What were you thinking of?\n')
      new_question = input(f'Please give me a question about {thing}, so I can tell the difference between {thing} and {guess}.\n')
      answer = ask(f'What is the answer for {thing}?')
      print('Thanks')
      tree.append(new_question)
      if answer:
        tree.append([thing])
        tree.append([guess])
      else:
        tree.append([guess])
        tree.append([thing])
  else:
    if ask(tree[0]):
      query(tree[1])
    else:
      query(tree[2])

while True:
  input('Ok, please think of something\n')
  query(tree)

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:
Horizontal graph of word length
Input
A list of words separated by any number of spaces.
Output
A horizontal ASCII art graph, where the n-th line is composed by as many asterisks (*) as the n-th word is long.
Example usage
The > signals user input, you should not input it when testing the program.
> This is an example histogram of word length
****
**
**
*******
*********
**
****
******

> a aa aaa aaaa aaaaa
*
**
***
****
*****

> double space  example
******
*****
*******

Reference implementation
In case of doubt over the specification, the output of your program should match exactly that of the below program under all inputs.
puts gets.chomp.split.map{|word| '*' * word.length}.join("\n")

So is a trailing newline allowed? crosses fingers

@BetaDecay Yes, allowed ...........

Will the input ever have leading or trailing spaces?

Well the Ruby answer is right there in the question, so there isn't much room for improvement. If you're using puts you don't need the join though, as it would be done anyway when the array is passed to stdout. :-D

@PhiNotPi No, fully disallowed

What you're describing is not a histogram. A histogram would show the number of words with x characters on line x. In the first example, line 1 would have 0 asterisks (no words with length 1) line 2 would have 3 asterisks (is, an, of) and so on.

@nitro2k01 histogram is indeed not accurate, how would you rename this challange?

Just horizontal graph I guess. Or more like vertical graph, where vertical refers to the Y axis the word index is on.

@nitro2k01 horizontal graph seems more clear

Ok, I realize you're right. Horizontal it is.

Does the input need to come from stdin or can it be from command line arguments?

@slebetman stdin only

Retina, 5 + 3 = 8 bytes
 +
\n
.
*

Every line goes in its own file, so I've added 1 byte for each additional file. Also, the \n should be replaced with an actual newline.
Each pair of lines is a pattern-replacement pair.  + matches one or more spaces and replaces it with a newline. . matches any character except a newline, and it replaces that with a *. This is applied globally, so every character is replaced with a *.

Pyth, 9 bytes
jm*ld\*cz

Explanation:
jm*ld\*cz
       cz    chop input on whitespace
 m           map to
   ld        length of the segment
  *  \*      number of asterisks
j            joined on newlines

CJam, 10 bytes
r{,'**Nr}h

How it works:
r{     r}h         e# This do-while loop basically reads all the whitespace separated tokens
                   e# from input. It separates the tokens on running lengths of whitespace
  ,                e# Take the length of the token
   '**             e# Get a string of that many '*' characters
      N            e# Print a new line

Try it online here

Python 3, 43 bytes:
for w in input().split():print('*'*len(w))

Thanks to @BetaDecay for pointing out a syntax error.
Sample run:
> This is an example histogram of word length
****
**
**
*******
*********
**
****
******

(The string below is entered as a literal, rather than as text)
> 'example\twith\nweird\rwhite   space'
*******
****
*****
**********

Bonus: vertical histogram
Thanks to @Caridorc for pointing out my error that made the bonuses have 1 to many rows.
l=[len(x)for x in input().split()]
for i in range(len(l)-1,0,-1):print(''.join(['*'if j>=i else' 'for j in l]))

Demo:
> This is an example histogram of word length
   **
   **  *
   **  *
*  ** **
*  ** **
********
********

Bonus: vertical histogram (upside down)
l=[len(x)for x in input().split()]
for i in range(len(l)-1):print(''.join(['*'if j>i else' 'for j in l]))

Demo:
> This is an example histogram of word length
********
********
*  ** **
*  ** **
   **  *
   **  *
   **

Vertical is off by one

R - 33
write(gsub(".","*",scan(,"")),"")

where

scan(,"") reads from stdin and splits on white-space into a character vector.
gsub(".", "*", ...) replaces all characters into *.
write(..., "") prints to stdout with "\n" as the default separator.

R, 38 bytes (with some help in comments)
cat(gsub(" +|$","\n",gsub("\\S","*",x)))

How it works

gsub replaces all no-spaces with *
second gsub adds \n (newline) to the end of each element
cat prints accordingly

Demo

Perl 5 + -p040l012, 7 bytes
s/./*/g

Try it online!

Perl 5 + -p, 15 bytes
y/ /
/s;s/./*/g

Try it online!

This is excellent! You can save 1 byte by changing the first substitution to a transliteration: y/ /\n/s;

@ThisSuitIsBlackNot Ooh nice! thank you!

Javascript ES6
Function, 46 chars
f=s=>s.replace(/\S/g,'*').replace(/\s+/g,'\n')

Program, 55 chars
alert(prompt().replace(/\S/g,"*").replace(/\s+/g,"\n"))

Your function is actually 46 characters long, and your program is 55.

@darkness3560, thank you for the correction. I used expressions like "f=s=>s.replace(/\S/g,'*').replace(/\s+/g,'\n')".length to measure the length and forgot about \.

><>, 38 37 Bytes
Curse you double space case *shakes fish*.
<v&0
 >i:84*=?v0(?;67*o&1&
 \ &0o?&a/

You can try it online (all you need to do is give input through the field near the bottom and then hit the Give button). Suggestions for further golfing are always welcome, especially ideas to remove those wasteful spaces in front of the second and third lines.
If you were allowed to print an additional newline for extra spaces, the code could be a whopping 27 bytes:
>i:84*=?v0(?;67*o
^     oa<

Explanation
Note: the order of the explanation will correspond to the pointer's location (so if the code is explained out of what one would consider order, it is because it is the order in which the pointer executes it).
Line 1:
<v&0
<      redirects flow leftward
   0   pushes 0 onto the stack
  &    pops 0 and puts it in the register
 v     redirects flow downward

Line 2:
>i:84*=?v0(?;67*o&1&
>                     redirects flow leftward
 i:                   pushes input and then duplicates it
   84*                pushes 32 (the space character numerically)
      =?v             pops 32 and input and redirects flow downward if they're equal
         0(?;         pops input and terminates if input is less than 0*
             67*o     pushes 42 (asterisk) and prints it
                 &1&  pushes register value and then puts 1 in the register

*in ><>, the command i returns -1 if no input is given

Line 3:
N.B. This line goes in reverse, so read right to left.
 ^ &0o?&a<
         <  redirects flow leftward
        a   pushes 10 (newline) onto the stack
     o?&    prints a newline if the register is not 0
   &0       sets the register to 0
 ^          redirects flow upwards (back to the second line)

Basically, the program test to make sure the input (which is read one character at a time) is not a space and then prints an asterisk. It terminates if there is no input (the input value is -1). To make sure it doesn't print additional newlines, it uses the register value, which it either sets to 0 or 1. Because of the way I set it up, it doesn't care about the extraneous values pushed onto the stack (e.g. the value of the register when it sets it to 1 after printing an asterisk); they remain on the stack when the program terminates but do nothing.
I know it might be a bit confusing since I used 84* and 67* instead of " " and "*" respectively, but that was because I didn't feel like putting strings in the program for whatever reason.

You're welcome ;)

Gema, 11 9 characters
 =\n
?=\*

Sample run:
bash-4.3$ gema ' =\n;?=\*' <<< 'This is an example histogram of word length'
****
**
**
*******
*********
**
****
******

bash-4.3$ gema ' =\n;?=\*' <<< 'a aa aaa aaaa aaaaa'
*
**
***
****
*****

bash-4.3$ gema ' =\n;?=\*' <<< 'double space  example'
******
*****
*******

PHP 5.3, 55 53 51 50 bytes
<?for(;$i<strlen($a);){echo$a{$i++}!=' '?'*':"
";}

Usage:

Call the Script and define a global variable ($a)

php -d error_reporting=0 script.php?a="This is an example histogram of word length"

Output:

****
**
**
*******
*********
**
****
******

Java, 102 bytes
class R{public static void main(String[]a){for(String s:a)System.out.println(s.replaceAll(".","*"));}}

Haskell, 31 bytes
putStr.unlines.map(>>"*").words

Usage example:
Main> putStr.unlines.map(>>"*").words $ "This is an example histogram of word length"
****
**
**
*******
*********
**
****
******

you could replace putStr. with f= to lower the byte count, or use main=interact$ instead of putStr. to read from STDIN and make it a complete program

@HEGX64: but f=unlines.map(>>"*").words returns something like "****\n**\n**\n" and does not output a "horizontal ASCII art graph" as requested.

CJam, 11 bytes
Competing for second place in CJam after @Optimizer found a clever 10 byte solution. This is a straightforward 11 byte solution:
lS%:,'*f*N*

Try it online
Alternate solution that uses a loop instead of the two maps, also 11 bytes:
lS%{,'**N}/

Explanation for first solution:
l     Get input.
S%    Split at spaces.
:,    Apply length operator to each word.
'*f*  Map each length to corresponding repetitions of '*.
N*    Join with newlines.

JavaScript (ES6), 37
f=s=>s.replace(/./g,m=>m<"!"?`
`:'*')

Shorter version using only one replace.

Dammit, I just finished my ES6 function, 38 bytes. Take my upvote while I run away in shame! :D

J, 10 bytes
   '*'$~$&>;:'This is an example histogram of word length'
****
**
**
*******
*********
**
****
******

Bonus: vertical (12 bytes)
   |:'*'$~$&>;:'This is an example histogram of word length'
********
********
*  ** **
*  ** **
   **  *
   **  *
   **
    *
    *

Bonus: flipped vertical (14 bytes)
   |.|:'*'$~$&>;:'This is an example histogram of word length'
    *
    *
   **
   **  *
   **  *
*  ** **
*  ** **
********
********

PowerShell, 35 31 Bytes
Pretty competitive for a change. Go go gadget unary operators. I also keep forgetting that parens on some functions, like the -split and -replace used here, are optional.
%{$_-split"\s+"-replace".","*"}

Called via pipeline input (equivalent to stdin for PowerShell):
PS C:\Tools\Scripts\golfing> "a aa aaa" | %{$_-split"\s+"-replace".","*"}
*
**
***

As a bonus, if we can instead use command-line arguments, we can get down to 20 Bytes and have something that works both with and without a single-string as input:
$args-replace".","*"

PS C:\Tools\Scripts\golfing> .\horizontal-graph-word-length.ps1 "double space  example"
******
*****
*******

PS C:\Tools\Scripts\golfing> .\horizontal-graph-word-length.ps1 double space  example
******
*****
*******

JavaScript (ES5)
Program, 54 chars
alert(prompt().replace(/\S/g,'*').replace(/ +/g,'\n'))

Function, 60 chars
function(i){return i.replace(/\S/g,'*').replace(/ +/g,'\n')}

Example usage:

var h=function(i){return i.replace(/\S/g,'*').replace(/ +/g,'\n')},
d=document,g=d.getElementById.bind(d),i=g('i'),o=g('o')
i.onchange=function(){o.textContent=h(i.value)}
<input id="i"/>

Python 3, 72 bytes
A nice one liner :)
print(''.join(map(lambda x:"*"*len(x)+"\n"*int(x!=""),input().split())))

Output:
>>> print(''.join(map(lambda x:"*"*len(x)+"\n"*int(x!=""),input().split())))
Hello world  how are you?
*****
*****
***
***
****

There's a trailing newline here. If you want it without, you've got to add 5 bytes:
print(''.join(map(lambda x:"*"*len(x)+"\n"*int(x!=""),input().split()))[:-1])

Javascript (ES6)
New solution (39 bytes):
s=>[...s].map(c=>c==' '?`
`:'*').join``

Regex solution (42 bytes):
s=>s.replace(/\S/g,"*").replace(/ +/g,`
`)

Non-regex solution (71 bytes):
s=>s.split(" ").map(v=>"*".repeat(v.length)).filter(a=>a!="").join(`
`)

These solutions define anonymous functions.  Assign them to variables or call them like so:
(s=>s.replace(/\S/g,"*").replace(/ +/g,`
`))("[your string here]")

(s=>s.split(" ").map(v=>"*".repeat(v.length)).filter(a=>a!="").join(`
`))("[your string here]")

Julia, 50 bytes
s->print(join(["*"^length(w)for w=split(s)],"\n"))

This creates an unnamed function that takes a string as input and prints to STDOUT.
Ungolfed:
function f(s::String)
    # Construct a vector of horizontal bars
    bars = ["*"^length(w) for w in split(s)]

    # Join the bars with newlines
    j = join(bars, "\n")

    # Print the result to STDOUT
    print(j)
end

Matlab / Octave, 75 bytes
Using an anonymous function:
@(s)char(arrayfun(@(n)repmat('*',1,n),diff([0 find([s 32]==32)])-1,'un',0))

Thanks to Hoki for spotting a mistake which prevented the last word from being detected.
Example use (Matlab):
>> @(s)char(arrayfun(@(n)repmat('*',1,n),diff([0 find([s 32]==32)])-1,'un',0)) % define function
ans =
    @(s)char(arrayfun(@(n)repmat('*',1,n),diff([0,find([s,32]==32)])-1,'un',0))
>> ans('This is an example histogram of word length') % call function
ans =
****
**
**
*******
*********
**
****
******

Or try it online (Octave).

Matlab - 54 bytes
s=input('');o=repmat('*',1,numel(s));o(s==32)=char(10)

This runs from the console, will take a string in input from stdin and will output the horizontal word graph in stdout:
Exemple:
>> s=input('');o=repmat('*',1,numel(s));o(s==32)=char(10)
'This is an example histogram of word length'
o =
****
**
**
*******
*********
**
****
******

Or we could try to make some fancy shapes:
>> s=input('');o=repmat('*',1,numel(s));o(s==32)=char(10)
'a aa aaa aaaaaa aaaaaaaaaa aaaaaaaaaaa aaaaaaaaaa aaaaaa aaa aa a aa aaa aaaaaa aaaaaaaaaa'
o =
*
**
***
******
**********
***********
**********
******
***
**
*
**
***
******
**********

Very clever approach!

SWI-Prolog, 40 bytes
a([A|T]):-(A=32,nl;put(42)),(T=[];a(T)).

Called with code strings, e.g. a(`This is an example histogram of word length`).

STATA, 72 bytes
di _r(a)
token "$a"
while ("`1'")!=""{
di _d(`=length("`1'")')"*"
ma s
}

Ungolfed
display _request(a) //get input via prompt
tokenize "$a" //split a by spaces into the variables 1,2,...
while ("`1'")!=""{ //while the first variable is not empty
display _dup(`=length("`1'")')"*" //display "*" duplicated for every character in variable 1.
macro shift //move variable 2 to 1, 3 to 2, etc.
}

Note that this code does not work in the online interpreter and requires the non-free proprietary STATA interpreter.

C++14, 107 106 bytes
#include<iostream>
main(){std::string s;for(;std::cin>>s;){for(char c:s)std::cout<<'*';std::cout<<'\n';}}

O, 22 bytes
i' /rl{e{'.'*%p}{;}?}d

Explanation
i                         Read the user input
 ' /r                     Split on spaces and reverse
     l{             }d    For each element
       e           ?      If it's not empty
        {'.'*%            Replace every char with an asterick
              p}          And print it
                {;}       Else, just pop it off the stack

K5, 31 bytes
`0:{(#x)#"*"}'f@&0<#:'f:" "\0:`

Beam, 92 Bytes
This isn't a competitive answer at all and really quite late, but I've been playing around with Beam a bit lately and wanted to see if I could get it to do this.  Finally got some success:)
'''''''>`++++++)v
vgLsP-(---`<''P'<
>rnp+v
  >Sv>++v
    (>`v+
    H^ )+
^Sp`@p'<+
^  @++++<

var ITERS_PER_SEC = 100000;
var TIMEOUT_SECS = 50;
var ERROR_INTERRUPT = "Interrupted by user";
var ERROR_TIMEOUT = "Maximum iterations exceeded";
var ERROR_LOSTINSPACE = "Beam is lost in space";

var code, store, beam, ip_x, ip_y, dir, input_ptr, mem;
var input, timeout, width, iterations, running;

function clear_output() {
document.getElementById("output").value = "";
document.getElementById("stderr").innerHTML = "";
}

function stop() {
running = false;
document.getElementById("run").disabled = false;
document.getElementById("stop").disabled = true;
document.getElementById("clear").disabled = false;
document.getElementById("timeout").disabled = false;
}

function interrupt() {
error(ERROR_INTERRUPT);
}

function error(msg) {
document.getElementById("stderr").innerHTML = msg;
stop();
}

function run() {
clear_output();
document.getElementById("run").disabled = true;
document.getElementById("stop").disabled = false;
document.getElementById("clear").disabled = true;
document.getElementById("input").disabled = false;
document.getElementById("timeout").disabled = false;

code = document.getElementById("code").value;
input = document.getElementById("input").value;
timeout = document.getElementById("timeout").checked;

code = code.split("\n");
width = 0;
for (var i = 0; i  width){
  width = code[i].length;
 }
}
console.log(code);
console.log(width);

running = true;
dir = 0;
ip_x = 0;
ip_y = 0;
input_ptr = 0;
beam = 0;
store = 0;
mem = [];

input = input.split("").map(function (s) {
  return s.charCodeAt(0);
 });

iterations = 0;

beam_iter();
}

function beam_iter() {
while (running) {
 var inst;
 try {
  inst = code[ip_y][ip_x];
 }
 catch(err) {
  inst = "";
 }
 switch (inst) {
  case ">":
   dir = 0;
   break;
  case "<":
   dir = 1;
   break;
  case "^":
   dir = 2;
   break;
  case "v":
   dir = 3;
   break;
  case "+":
   ++beam;
   break;
  case "-":
   --beam;
   break;
  case "@":
   document.getElementById("output").value += String.fromCharCode(beam);
   break;
  case ":":
   document.getElementById("output").value += beam+"\n";
   break;
  case "/":
   switch (dir) {
    case 0:
     dir = 2;
     break;
    case 1:
     dir = 3;
     break;
    case 2:
     dir = 0;
     break;
    case 3:
     dir = 1;
     break;
   }
  case "\\":
   switch (dir) {
    case 0:
     dir = 3;
     break;
    case 1:
     dir = 2;
     break;
    case 2:
     dir = 1;
     break;
    case 3:
     dir = 0;
     break;
   }
   break;
  case "!":
   if (beam != 0) {
    switch (dir) {
    case 0:
     dir = 1;
     break;
    case 1:
     dir = 0;
     break;
    case 2:
     dir = 3;
     break;
    case 3:
     dir = 2;
     break;
    }
   }
   break;
  case "?":
   if (beam == 0) {
    switch (dir) {
    case 0:
     dir = 1;
     break;
    case 1:
     dir = 0;
     break;
    case 2:
     dir = 3;
     break;
    case 3:
     dir = 2;
     break;
    }
   }
   break;
  case "|":
   switch (dir) {
   case 0:
    dir = 1;
    break;
   case 1:
    dir = 0;
    break;
   }
   break;
  case "_":
   switch (dir) {
   case 0:
    dir = 1;
    break;
   case 1:
    dir = 0;
    break;
   }
   break;
  case "H":
   stop();
   break;
  case "S":
   store = beam;
   break;
  case "L":
   beam = store;
   break;
  case "s":
   mem[beam] = store;
   break;
  case "g":
   store = mem[beam];
   break;
  case "P":
   mem[store] = beam;
   break;
  case "p":
   beam = mem[store];
   break;
  case "u":
   if (beam != store) {
    dir = 2;
   }
   break;
  case "n":
   if (beam != store) {
    dir = 3;
   }
   break;
  case "`":
   --store;
   break;
  case "'":
   ++store;
   break;
  case ")":
   if (store != 0) {
    dir = 1;
   }
   break;
  case "(":
   if (store != 0) {
    dir = 0;
   }
   break;
  case "r":
   if (input_ptr >= input.length) {
    beam = 0;
   } else
   {
    beam = input[input_ptr];
    ++input_ptr;
   }
   break;
  }
 // Move instruction pointer
 switch (dir) {
  case 0:
   ip_x++;
   break;
  case 1:
   ip_x--;
   break;
  case 2:
   ip_y--;
   break;
  case 3:
   ip_y++;
   break;
 }
 if (running && (ip_x < 0 || ip_y < 0 || ip_x >= width || ip_y >= code.length)) {
  error(ERROR_LOSTINSPACE);
 }
 ++iterations;
 if (iterations > ITERS_PER_SEC * TIMEOUT_SECS) {
  error(ERROR_TIMEOUT);
 }
}
}

Code:

    <textarea id="code" rows="4" style="overflow:scroll;overflow-x:hidden;width:90%;">'''''''>`++++++)v
vgLsP-(---`<''P'<
>rnp+v
  >Sv>++v
    (>`v+
    H^ )+
^Sp`@p'<+
^  @++++<
 </textarea>

Input:

    <textarea id="input" rows="2" style="overflow:scroll;overflow-x:hidden;width:90%;">This is an example histogram of word length</textarea>

Timeout:
        <input id="timeout" type="checkbox" checked="checked">

        <input id="run" type="button" value="Run" onclick="run()">
        <input id="stop" type="button" value="Stop" onclick="interrupt()" disabled="disabled">
        <input id="clear" type="button" value="Clear" onclick="clear_output()">

Output:

    <textarea id="output" rows="6" style="overflow:scroll;width:90%;"></textarea>

Vyxal j, 7 bytes
⌈';vL×*

Try it Online!
Vertical, 17 bytes
⌈';vL:G$×*v↲ÞTṘvṅ

Try it Online!
Vertical flipped, 16 bytes
⌈';vL:G$×*v↲ÞTvṅ

Try it Online!

Wow, I ended up with exact same answer, good stuff

AWK
 awk '{for(i=1;i<=NF;i++){while(k++<length($i)){printf "*"};k=0;print ""}}'

examples
 echo "this is programming" | awk '{for(i=1;i<=NF;i++){while(k++<length($i)){printf "*"};k=0;print ""}}'

output:-
****
**
***********

Bash - 60 26 bytes
new solution (thanks manatwork):
for w;{ echo "${w//?/*}";}

old solution:
for w;do for((i=1;i<=${#w};i++));do printf \*;done;echo;done

~ $ ./l This is an example histogram of word length
****
**
**
*******
*********
**
****
******

The only part that might deserve an explanation is ${#w}: it returns the length of the string w.

Processing separate parameters instead of a single input to avoid completing half of the task, is kind of cheating. Anyway, what you wrote there, can be accomplished in 26 characters: for w;{ echo "${w//?/*}";}

Yeah, I realized this was basically a character substitution just after posting that, so I posted another one in sed: http://codegolf.stackexchange.com/a/57435/7176

sed - 20 bytes
s/[^ ]/*/g;s/ +/\n/g

~ $ sed -re 's/[^ ]/*/g;s/ +/\n/g' <<< 'This is an example histogram of word   length'
****
**
**
*******
*********
**
****
******

@jimmy23013: I edited my answer accordingly, and fixed the multiple space issue :)

Ruby, 29 bytes
puts gets.gsub(/\S/,?*).split


text:
Programming with Bits and Bytes
In this challenge you are going to write an interpreter for a simple language I've made up. The language is based on a single accumulator A, which is exactly one byte in length. At the start of a program, A = 0. These are the languages instructions:
!: Inversion
This instruction simply inverts every bit of the accumulator. Every zero becomes a one and every one becomes a zero. Simple!
>: Shift Right
This instruction shifts every bit in A one place to the right. The leftmost bit becomes a zero and the rightmost bit is discarded.
<: Shift Left
This instruction shifts every bit in A one place to the left. The rightmost bit becomes a zero and the leftmost bit is discarded.
@: Swap Nybbles
This instruction swaps the top four bits of A with the bottom four bits. For example, If A is 01101010 and you execute @, A will be 10100110:
 ____________________
 |                  |
0110 1010    1010 0110
      |_______|

That's all the instructions! Simple, right?
Rules

Your program must accept input once at the beginning. This will be a line of code. This is not an interactive interpreter! You can only accept input once and do not have to loop back to the start once that line has been executed.
Your program must evaluate said input. Every character that is not mentioned above is ignored.
Your program should then print out the final value of the accumulator, in decimal.
Usual rules for valid programming languages apply.
Standard loopholes are disallowed.
This is code-golf, smallest byte count wins.

Here are some small programs to test out your submissions. Before the arrow is the code, after it is the expected result:

! -> 255
!>> -> 63
!<@ -> 239
!nop!&6*! -> 255

Enjoy!

I'm presuming from ! -> 255 that we're to use 8 bits per byte here?  The question isn't explicit.

@TobySpeight A byte, by definition, is 8 bits.

Pyth, 36 35 bytes
u%@[t_G/G2yGi_jGJ16JG)x"!><@"H256z0

Test harness
The internal representation of the accumulator is an integer. This integer is mod-ed by 256 on each iteration, as desired. The operations performed are -G-1, G/2, G*2 and G converted to base 16, reversed, and converted back to base 10, where G is the accumulator.
I missed the line about ignoring everything else. This has been remedied. Thanks, @Dennis.

So -G-1 is shorter than ~G in Pyth? I somewhat doubt that.

The code in question is actually t_G, where _ is negation and t is -1. In Pyth, ~ means something totally different.

I meant Python ~ (bitwise NOT)

@CalculatorFeline My point was there is no 1-character function with that effect in Pyth, so the above code (at least for that operation) is as good as it's going to get.

C, 96
Assuming ASCII (or compatible) input:
a;main(c){while(c=getchar()+1)a=(c^34?c^61?c^63?c^65?a:a*257/16:a/2:a*2:~a)&255;printf("%u",a);}

Tidier:
a;
main(c){
  while(c=getchar()+1)
    a=(c^34?
      c^61?
        c^63?
          c^65?
            a
          :
            a*257/16
        :
          a/2
      :a*2:~a
    )&255;
  printf("%u",a);
}

Basically it's just a collection of nested ternary expressions. I'm incrementing the value obtained from getchar() so that an EOF (-1) results in a value of zero and the program exits.
(ideone link)

I tried the challenge myself and I wrote almost exactly the same code. Btw. your program doesn't drop the bit when shifting upwards (input: !<> should result in 127 and not 255). Either define your a as char, or use the line a&=255 (and use %u) to get the correct effect. Also you can shorten your negation a^255 to ~a. a>>4&15 is also shorter than your (a&240)/16.

Ah, good point. Turns out it was more efficient to mask out the lower 8 bits at each iteration.

In this case you can even use the format string %u instead of %hhu

I just saw it now, but you can also use a/16|a*16 instead of a/16|(a&15)*16. The few bits on top get removed by the &255.

A tiny improvement: a*257/16 is one byte shorter than a/16|a*16.

@TobySpeight Nice one, thanks!

95 bytes

Python 3, 133 bytes
Uses a dictionary to make up for a lack of switch-case syntax in Python. See more here.
a="0"*8
for i in input():a={"!":''.join(str(1-int(b))for b in a),"<":a[1:]+"0",">":"0"+a[:-1],"@":a[4:]+a[:4]}.get(i,a)
print(int(a,2))

The accumulator is a string which is converted into a base 10 number at the end.
Example I/O:
$ python3 bitsnbytes.py
!
255
$ python3 bitsnbytes.py
!>>
63
$ python3 bitsnbytes.py
!<@
239
$ python3 bitsnbytes.py
!nop!&6*!
255

If it was a real, interactive interpreter, it would be for i in sys.stdin: :)

@Zizouz212 I believe you mean if it was interactive; it looks like a real interpreter to me. ;)

Javascript (ES6), 80 91 90 bytes
a=>[...a].reduce((p,c)=>c=='!'?p^255:c=='<'?p*2%256:c=='>'?p>>1:c=='@'?p/16|0+p%16*16:p,0)

Pretty much as short as it can get. Defines an anonymous function which takes the program as input.

For !, takes x XOR 255, as JS's ~ would consider x a 32-bit number.
For <, multiplies x by 2 and takes the result mod 256.
For >, truly shifts the bits of x 1 bit to the right.
For @, floors x/16 and adds it to x%16*16.

Thanks to @vihan for suggesting the use of reduce to save a byte.

You can use < to save around 4 bytes. Using reduce might also save some bytes

@vihan Do you mean < in place of ==? If so, that wouldn't work, as no-op characters would incorrectly perform an operation. I used that in my previous, 80-byte solution.

Isn't ES6 fat arrow standard on PPCG that you have to define it?

@SpeedyNinja I don't know of any such standard, but if you could point me to a post about one, I'll modify my answer.

0+ in p/16|0+p%16*16 does nothing

Java (8), 514 483 411 366 359 239 224 229 198 194 187 186 184 182 181 180 177 characters
Wow, this has been golfed down a LOT! Thanks to everyone who gave me suggestions! I greatly appreciate it!
interface T{static void main(String[]g)throws Exception{int i,a=0;while((i=System.in.read())!=10)a=(i==33?255-a:i==62?a/2:i==60?a*2:i==64?a>>4|a<<4:a)%256;System.out.print(a);}}

Golfed 31 (!) bytes by optimizing the nibble swap with bitwise operations as opposed to lengthy Integer.??? methods.
Golfed 72 (!!!!) chars by removing the unnecessary string created to swap nibbles. Much better than before!?
Golfed 45 (!!) chars by removing use of java.util.Scanner and reading from System.in directly. Note that now that the lambda expression is gone, Java 8 is no longer required! Just merely Java 1 would do!
Golfed 7 chars by making class (default) (removed public keyword), thanks to @bmarks
Golfed 120 (!!!!!!!) chars by turning all those lengthy Integer class operations in the bit flipping to 255 - a. Now that's much shorter!
Golfed 15 (!) chars by converting shifts to multiplication and division, removing the braces from the while statement, and making a local within the main method.
Ungolfed 9 =( chars because of a problem with the left shift not discarding the leftmost byte. Therefore, I now do mod (256). The right shift will make the resulting number one bit shorter than before, so there is no need to use mod on right shift. My nibble-swap thing will swap the last 4 bits and the second-last nibble, and the and (&) truncates all other bits. My inversion program doesn't cause any problems if the original number is less than 256.
Golfed 31 35 chars thanks to @Geobits by converting switch statement to a lot of ternary statements, and also converting chars to ints, shortening the literals.
Golfed 7 chars by removing unnecessary &240 in the nibble swap ((a&240)>>4 to a>>4 and converting (a&15)<<4 to a<<4&240. The last change only golfed one character though.
Golfed 1 char by removing unnecessary = in a /= 2, because a = a /= 2 is equivalent to a = a / 2.
Golfed 2 chars by turning println to print.
Golfed 2 chars by removing accidental a= in a=255-a (a=a=255-a is equivalent to a=255-a)
Golfed 1 char by turning a<<4&240 into a%16<<4.
Golfed 1 char by adding brackets to the outside of the ternary statement and doing %256. That way, the %16 is unnecessary in the left-shift part of the nibble swap. The brackets add 2 chars and the %16 saves 3 chars.
Golfed 3 chars by changing class to interface and removing public using Java 8's static interface method feature. Thanks to @TheNumberOne (no comment, but find his answer on "Tips for golfing in Java"

I don't think the class has to be public.
Also, I think if you make a an Integer instead of an int, you could do a.parseInt, a.toString, etc. instead of Integer.parseInt,Integer.toString, etc.

Thanks for the first suggestion; I'm going to remove all Integer class methods though.

Perhaps you can do while((i=System.in.read())>10) instead of !=10 to save a byte?

Good idea, but then anything below 10 will cause the program to terminate, and I'm supposed to ignore other characters, not make then the end of the world (or at least my program:)) I'll consider it though; perhaps there are no valid ascii characters below 10.

Ah, indeed my suspicions were correct. A tabulator is (char) 9.

It's almost never worth it to use a switch while golfing. The case/break are just too long. You should be able to save a bunch by making the whole thing a ternary; something like a=i=='!'?255-a:i==62?a/2:i=='<'?a*2%256:i=='@'?(a&240)>>4|(a&15)<<4:a;

@Geobits Thanks a lot! You saved me 31 characters!

Whoops, I mean 35 characters.

CJam, 37 bytes
0q{"!><@"#"~ 2/ 2* GmdG*+ "S/=~255&}/

Try it online in the CJam interpreter.
How it works
0                   e# Push 0 (accumulator).
q                   e# Read from STDIN.
{                   e# For each character in the input:
  "!><@"#           e#   Find its index in "!><@" (-1 if not found).
  "~ 2/ 2* GmdG*+ " e#   Push that string.
  S/                e#   Split at spaces to push ["~" "2/" "2*" "GmdG*+" ""].
                    e#     "~"      : signed 64-bit bitwise NOT
                    e#     "2/"     : divide by 2
                    e#     "2*"     : multiply by 2
                    e#     "GmdG*+" : (x) -> (x/16) (x%16) -> (16(x%16) + (x/16))
                    e#     ""       : NOOP
  =~                e#  Select the corresponding string and evaluate it.
  255&              e#  Zero all but the 8 least significant bits.
}/                  e#

HP 41C/CV/CX (77 bytes, 42 steps)
Purely for giggles, here it is for the HP 41C/CV/CX calculator. (Requires either the Extended Functions module, or a 41CX for the ATOX function.)
Put your program into the Alpha register, which is a little tricky, as there's no way to enter ! or @ directly from the keyboard (use XTOA with the ASCII codes 33 and 64 respectively to append them).
Steps 08 and 10 allow for ignoring invalid opcodes; remove them to save 2 steps, but the program will crash on invalid input.
01 LBL"BB
02 0
03 LBL A
04 ATOX
05 X=0?
06 GTO E
07 X<>Y
08 SF 25
09 XEQ IND Y
10 CF 25
11 GTO A
12 LBL 33
13 255
14 X<>Y
15 -
16 RTN
17 LBL 60
18 2
19 *
20 256
21 MOD
22 RTN
23 LBL 62
24 2
25 /
26 INT
27 RTN
28 LBL 64
29 RCL X
30 16
31 /
32 INT
33 X<>Y
34 16
35 *
36 256
37 MOD
38 +
39 RTN
40 LBL E
41 RDN
42 RTN

Rust, 121 115 bytes
fn r(s:&str)->u8{let mut n=0u8;for t in s.chars(){match t{'!'=>n=!n,'>'=>n/=2,'<'=>n<<=1,'@'=>n=n>>4|n<<4,_=>()}}n}

Sample run:
fn main() {
    println!("{}", r("!"));    //=> 255
    println!("{}", r("!>>"));  //=> 63
    println!("{}", r("!<@"));  //=> 239
}

Ungolfed:
fn run_ungolfed(s: &str) -> u8 {
    let mut n = 0u8;
    for t in s.chars() {
        match t {
            '!' => n = !n,
            '>' => n >>= 1,
            '<' => n <<= 1,
            '@' => n = (n >> 4) | (n & 15) << 4,
            _ => ()
        }
    }
    n
}

Surprisingly short for Rust. Nothing else really interesting other than the fact that I learned more precedence rules today—who knew (a>>b)|c is the same as a>>b|c?
Shaved off a byte by changing n>>=1 to n/=2; however, the same cannot be done with multiplication, because arithmetic overflow is a panic (i.e. crash) in Rust.

The precedence thing makes sense when you convince yourself that >> is sort of like division and | is sort of like addition.

Python 2, 79 bytes
I realized that I have done something very similar to this in Python earlier. This is just a port of my Ruby answer, but it is incidentally the shortest Python answer as of now :D
a=0
for i in raw_input():a=[~a,a/2,a*2,a*16+a/16,a]["!><@".find(i)]&255
print a

The difference from the Ruby version is that this one doesn't ignore invalid instructions while iterating over the input. Instead I take advantage of the fact that Python tends to return -1 instead of nil when there is no match -- The current value of a is appended to the back of the result array, so that all invalid instructions maps to the same, unchanged value.

Python 3, 124 94 93 bytes
a=0
for i in input():
 if i in"!><@":a=(i=='!')*(255-a)+(i==">")*a//2+(i=="<")*(a+a)%256+(i=="@")*(16*(a%16)+a//16)
print(a)

"!" is same as subtracting from 255.
"<" is same as multiplying by 2. But 8 bit register means mod 256.
">" is same as integer division by 2.
"@" means shifting last 4 bits (a%16) by 4 bits(*16) and adding the first four bits(a/16).
EDIT (read shameless copying)
Saw the other answer in python (by Beta decay). It uses a really effective way to simulate switch cases using dictionary. Using that we can write
a=0
for i in input():a={"!":255-a,"<":a<<1&255,">":a//2,"@":(a%16)<<4+a>>4}.get(i,a)
print(a)

Thanks, Beta Decay.

No matter what operation you do, you have to reduce mod 256 right?  So why not do that at the end: a={"!":255-a,"<":a*2,">":a//2,"@":(a%16)<<4+a>>4}.get(i,a)%256.  This immediately saves you a byte (because you'll do a*2 instead of a<<1)...but @daniero's answer also shows that if you do it this way then (a%16)<<4 can be shortened to just a<<4, because any bit 16 or larger will be eliminated once you multiply it by 16 and reduce it mod 256. Nice! Also, you can now replace 255-a by -1-a...or better, by just ~a.  Altogether, these suggestions should save you 9 bytes.

JavaScript (ES6), 76 81
As an unnamed function returning the accumulator value
This is a porting of the super clever answers by @daniero (that have way too few upvotes)
Bonus: you can pass an initial value of the accumulator. If not passed, starting value is 0 as by specific.

(p,a)=>(p.replace(/[!<>@]/g,i=>a=(i<'<'?~a:i<'>'?a*2:i<'@'?a/2:a*257/16)&255),a)

Test running the snippet below in any EcmaScript 6 browser (I tested in Firefox)

f=(p,a)=>[...p].map(c=>a=255&[a,~a,a*2,a/2,a*257/16][1+'!<>@'.indexOf(c)])|a

// TEST
out=x=>O.innerHTML+=x+'\n'

function go(x) { out(x+' -> '+f(x)) }

go('!'),go('!>>'),go('!<@'),go('!nop!&6*!')

// LESS GOLFED
F=(p,a)=>// a as a parameter, if not passed its value starts as undefined, then becomes NaN, but the operators '&' and '~' treat it as 0
  [...p].map(c => // execute following function for each character p
    a = 255 & // any intermediate result is converted to numeric and truncate to a byte
   // evaluate all possible results (then choose one bases on the current character)
   [a,   // NOP, if unexpected char 'a' remains the same
    ~a,  // tilde == binary not (will give a result wider than a byte)
    a*2, // < shift left is *2 (can give a result wider than a byte)
    a/2, // > shift right is /2 (can give a non integer result)
    a *257 / 16  // move nibbles around (will give a result wider than a byte)
   ] // array of all results
   [1+'!<>@'.indexOf(c)] // find index to get the correct result
  ) // end map, returns an array in any case
    // eventually a single element array containg a
  | a // return accumulator
Test program:<input id=I><button onclick='go(I.value)'>go</button>

Haskell, 89 bytes
a#'!'=255-a
a#'>'=div a 2
a#'<'=mod(a*2)256
a#'@'=mod(a*16)256+div a 16
a#_=a
f=foldl(#)0

Usage example: f "!>>" -> 63

Ruby, 81 73 bytes
So much simpler -- no eval! For each valid character in the input, it evaluates each instruction, and finds the appropriate instruction through the index of $& (the current character in the input).
a=0
gets.scan(/[!><@]/){a=[~a,a/2,a*2,a*16+a/16]["!><@".index$&]&255}
p a

That's genius. Much shorter that any other way. 2 upvotes by me!

How can you double upvote...?

@JamesSmith He's probably referring to this and my python answer :)

@danerio I see.

Python 3, 127 bytes
Edit: shorting, thanks @Jakube
Edit2: fix, thanks @Anachor
a=0
for i in input():a=(a^255if i=="!"else a>>1if i==">"else a<<1if i=="<"else(a&15)<<4|(a&240)>>4if i=="@"else a)&255
print(a)

Maybe this is because windows' new line. That's plus two bytes. I'll use that byte counter next time. :-) Thanks.

Note that this doesn't discard the leftmost bit when left shifting, so !< gives 510 while it should be 254

I hope now it does. Sorry for my mistakes, this is my first "golf" challenge.

Rust, 111 bytes
More of a comment on @Doorknob's answer, but I don't have any rep for comments as I just created an account.
One can shave 10 bytes off his Rust solution with the following:
fn r(s:&str)->u8{let mut n=0u8;for t in s.chars(){n=match t{'!'=>!n,'>'=>n>>1,'<'=>n<<1,'@'=>n>>4|n<<4,_=>n}}n}

I thought we could get even shorter using fold (https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.fold) but surprisingly makes it a tad longer.

Ceylon, 297 290
shared void y(){value t=process.readLine()else"";variable Byte a=0.byte;for(c in t){switch(c)case('!'){a=a.not;}case('>'){a=a.rightLogicalShift(1);}case('<'){a=a.leftLogicalShift(1);}case('@'){a=a.and(#f0.byte).rightLogicalShift(4).xor(a.and(#f.byte).leftLogicalShift(4));}else{}}print(a);}

Formatted:
shared void y() {
    value t = process.readLine() else "";
    variable Byte a = 0.byte;
    for (c in t) { switch (c)
        case ('!') { a = a.not; }
        case ('>') { a = a.rightLogicalShift(1); }
        case ('<') { a = a.leftLogicalShift(1); }
        case ('@') { a = a.and(#f0.byte).rightLogicalShift(4).xor(a.and(#f.byte).leftLogicalShift(4)); }
        else {} }
    print(a);
}

#f and #f0 are hexadecimal numbers for the nibbles, .byte converts an integer into a byte. I'm lucky that Byte's .string attribute already uses the unsigned representation of a byte.
Ceylon also features a switch statement without fall-through, and a string is a list of characters, which can be iterated.
I also tried to cut those long shift method names down by using an aliasing import, but this actually becomes 7 bytes longer:
import ceylon.language{Byte{r=rightLogicalShift,l=leftLogicalShift}}shared void x(){value t=process.readLine()else"";variable Byte a=0.byte;for(c in t){switch(c)case('!'){a=a.not;}case('>'){a=a.r(1);}case('<'){a=a.l(1);}case('@'){a=a.and(#f0.byte).r(4).xor(a.and(#f.byte).l(4));}else{}}print(a);}

Formatted:
import ceylon.language {
    Byte {
        r=rightLogicalShift,
        l=leftLogicalShift
    }
}
shared void x() {
    value t = process.readLine() else "";
    variable Byte a = 0.byte;
    for (c in t) {
        switch (c)
        case ('!') { a = a.not; }
        case ('>') { a = a.r(1); }
        case ('<') { a = a.l(1); }
        case ('@') { a = a.and(#f0.byte).r(4).xor(a.and(#f.byte).l(4)); }
        else {}
    }
    print(a);
}

This might be useful if we need those methods a bit more often.

STATA, 197 bytes
di _r(a)
gl b=0
forv x=1/`=length("$a")'{
gl c=substr("$a",`x',1)
if"$c"=="!" gl b=255-$b
if"$c"==">" gl b=int($b/2)
if"$c"=="<" gl b=mod($b*2,256)
if"$c"=="@" gl b=mod($b,16)*16+int($b/16)
}
di $b

Ungolfed
display _request(a) //get the input via prompt and put in var a
global b=0 //initialise A to be 0
forv x=1/`=length("$a")'{ //for loop from 1 to last char in a
global c=substr("$a",`x',1) //get the char at index x in a
if "$c"=="!" global b=255-$b //invert is the same as 255-A
if "$c"==">" global b=int($b/2) //right shift is the same as A/2 (with integer division)
if "$c"=="<" global b=mod($b*2,256) //left shift is the same as A*2%256
if "$c"=="@" global b=mod($b,16)*16+int($b/16) //nibble swap is the same as A%16*16+A/16
}
display $b //display the result of A

Does not work with the online interpreter and requires the non-free default interpreter. This would be somewhat easier with actual bitwise operations, but I don't think they're too useful for most of the common uses of STATA.

Why doesn't the online interpreter work?

Julia, 117 94 86 73 bytes
p->(a=0x0;[a=c==33?~a:c==60?a<<1:c==62?a>>1:c!=64?a:a<<4|a>>4for c=p];1a)

This is an anonymous function that accepts a string and returns an integer. To call it, assign it to a variable.
Ungolfed:
function f(p)
    # Initialize the accumulator to 0 as an 8-bit unsigned integer
    a = 0x0

    # Loop over the characters in the input
    for c in p
        a = c == 33 ? ~ a :        # '!'
            c == 60 ? a << 1 :     # '<'
            c == 62 ? a >> 1 :     # '>'
            c != 64 ? a :          # no-op
            a << 4 | a >> 4        # '@'
    end

    # Convert the accumulator to a regular integer and return
    return Int(a)
end

Saved 8 bytes thanks to Sp3000 and 13 thanks to Dennis!

JavaScript, 104
[].reduce.call(prompt(),function(a,i){return(i=='!'?~a:i=='>'?a/2:i=='<'?a*2:i=='@'?a>>4|a<<4:a)&255},0)

Nested ternary operators map to instructions.
BITWISE AND is used to constrain our Number type to a single byte.

Forth (gforth), 217
: o over ; : x 0 begin key dup emit swap o 13 = if . exit else o 33 = if invert else o 62 = if 1 rshift else o 60 = if 1 lshift else o 64 = if dup 4 lshift swap 4 rshift or then then then then then nip 255 and again ;

Not as short as I had hoped but oh well. I'm sure this can be golfed further. There doesn't seem to be any alternatives to if/elseif :/
Formatted / ungolfed:
: x
  0 ( accumulator )
  begin
    key dup emit swap ( read char, print it and stash it away )
         over 13 = if . exit ( on newline, print accumulator and return. )
    else over 33 = if invert ( inversion )
    else over 62 = if 1 rshift ( shift 1 right )
    else over 60 = if 1 lshift ( shift 1 left )
    else over 64 = if dup 4 lshift swap 4 rshift or ( swap )
    then then then then then
    nip ( remove read character )
    255 and ( constrain accumulator to 1 byte after each step )
  again
;

R, 194 bytes
b<-readline();A<-rep(0,8);s<-strsplit(b,"")[[1]];for(r in s){if(r=="!")A<-(A+1)%%2;if(r==">")A<-c(0,A)[1:length(A)];if(r=="<")A<-c(A,0)[-1];if(r=="@")A<-c(A[5:8],A[1:4])};print(sum(A*(2^(7:0))))

ungolfed
b <- readline()
A <- rep(0, 8)
s <- strsplit(b, "")[[1]]
for (r in s) {
    if (r == "!")
        A <- (A + 1) %% 2
    if (r == ">")
        A <- c(0, A)[1:length(A)]
    if (r == "<")
        A <- c(A, 0)[-1]
    if (r == "@")
        A <- c(A[5:8], A[1:4])
}
print(sum(A*(2^(7:0))))

All the <- can be replaced by = here, thus reducing the code by 7 bytes. Additionally you might be able to replace the series of if statements by one call to switch (as in A=switch(r,"!"=(A+1)%%2, ...))

The resulting b=readline();A=rep(0,8);s=strsplit(b,"")[[1]];for(r in s)A=switch(r,"!"=(A+1)%%2,">"=c(0,A)[1:length(A)],"<"=c(A,0)[-1],"@"=c(A[5:8],A[1:4]),A);print(sum(A*(2^(7:0)))) is 167 bytes.

Crystal, 139 bytes
def f x
b=0_u8
x.chars.each do|c|
b=case c
when'!'
~b
when'>'
b>>1
when'<'
b<<1
when'@'
b<<4|b>>4
else raise ""
end
end
puts b
end

C# 193
void Main(){byte a=0;foreach(var c in Console.ReadLine()){if(c=='!')a=(byte)~a;if(c=='>')a=(byte)(a>>1);if(c=='<')a=(byte)(a<<1);if(c=='@')a=(byte)(((a&240)>>4)|((a&15)<<4));}Console.Write(a);}

Don't you need using System; or something like that to access Console.ReadLine and Console.Write without the System. prefix?

Also it seems to me that you shouldn't have to cast to byte for each operation but I could be wrong.

Lua, 344 char
a=string.rep("0",8)
t=io.read()
f={["!"]=function()local s="";for j=1,8 do s=s..(a:sub(j,j)=="0"and"1"or"0") end;return s end,[">"]=function() return "0"..a:sub(1,7) end,["<"]=function()return a:sub(2,8).."0"end,["@"]=function()return a:sub(5,8)..a:sub(1,4)end}
for i=1,#t do a=(f[t:sub(i,i)]or function()return a end)()end
print(tonumber(a,2))

Inspired by @Beta Decay's use of a string accumulator, seeing as lua has no byte type. Could probably be golfed more by using fewer functions.

RPL, 170.5 bytes
The input should be entered as a string on level 1.
\<< DEC 8 STWS \-> S
    \<< #0d 1 S SIZE
        FOR I "!><@" S I DUP SUB POS 1 + { \<< \>> NOT SR SL \<< DUP #16d / SWAP #16d * + \>> } SWAP GET EVAL NEXT \>>
\>>

K, 57 bytes
It's a start:
0{y+2*x}/(8#0){((~:;{-1_0,x};{1_ x,0};4!;{x})"!><@"?y)x}/

tested using Kona:
  f:0{y+2*x}/(8#0){((~:;{-1_0,x};{1_ x,0};4!;{x})"!><@"?y)x}/
...
  f'("!";"!>>";"!<@";"!nop!&6*!")
255 63 239 255

I might be able to do better in k5, but it's a complex series of tradeoffs- for example, converting binary to decimal is as easy as 2/, but the behavior of ? makes it harder to handle a default case for instruction lookup.

PHP, 189 bytes
<? $c='00000000';foreach(str_split($argv[1])as$a){$a=='!'&&$c=strtr($c,'01','10');$a=='<'&&$c=substr($c.'0',1);$a=='>'&&$c=substr('0'.$c,0,8);$a=='@'&&$c=substr($c.$c,4,8);}echo bindec($c);

It's not that it gonna beat many answers, it's only for practice

HPPPL, 302 294 bytes
#pragma mode(separator(.,;)integer(d8))EXPORT b()BEGIN print();local p,j,a;a:=#0d;INPUT({{p,[2]}});for j from 1 to dim(p)do c:=p(j);case if c==33 then a:=BITNOT(a)end if c==62 then a:=BITSR(a,1)end if c==60 then a:=BITSL(a,1)end if c==64 then a:=BITSL(a,4)+BITSR(a,4)end end;end;print(a*1);END;

Ungolfed:
// make sure integers are unsigned 8 bit decimal numbers
#pragma mode( separator(.,;) integer(d8) )
EXPORT b()
BEGIN
  print();
  local p,j,a;
  a:=#0d;                         // set a to integer value 0
  INPUT({{p,[2]}});               // open input dialog treating input as string ( type [2])
  for j from 1 to dim(p) do
    c:=p(j);
    case
      if c==33 then a:=BITNOT(a) end             // !
      if c==62 then a:=BITSR(a,1) end            // >
      if c==60 then a:=BITSL(a,1) end            // <
      if c==64 then a:=BITSL(a,4)+BITSR(a,4) end // @
    end;
  end;
  print(a*1); // converts to proper output by promoting to non integer format
              // print(a) would result in
              // #239:8d for 239 if the default bit size is not set to 8 bits decimal
              // indicating an 8 bit unsigned decimal integer, or
              // #239d if the default bit size is already set to 8 bits decimal

END;

This answer ensures that the HP Prime uses unsigned 8 bit integers even if the mode is set to e.g. 64 bits by the user. If the calculator is set up manually to using unsigned 8 bit decimal integers, then the pragma command can be omitted.
If the output does not need to follow the format strictly then the a*1 at the end can simply be a. Multiplying the result by 1 just ensures the output does not follow the internal output for integer values.
The print command in line 4 can also be omitted if the terminal does not need to be cleared before printing out the result.
If passing the program as a string argument is allowed, then the INPUT command can be omitted as well.
This is the shortest version with input and proper output, without the pragma argument (if the calculator is set to Uint8 by default:
243 bytes:
EXPORT b()BEGIN local p,j,a;a:=#0d;INPUT({{p,[2]}});for j from 1 to dim(p)do c:=p(j);case if c=33 then a:=BITNOT(a)end if c=62 then a:=BITSR(a,1)end if c=60 then a:=BITSL(a,1)end if c=64 then a:=BITSL(a,4)+BITSR(a,4)end end;end;print(a*1);END;

Perl 6, 96 89 bytes
{my $a=0;$a=(+^*,*+<1,*+>1,{$_+<4+$_+>4},{$_})["!<>@".index($_)//4]($a)%256 for .comb;$a}

Old solution:
{my $a=0;$a=(255-*,*+<1+&255,*+>1,{$_+&15+<4+$_+>4},{$_})["!<>@".index($_)//4]($a)for .comb;$a}

C#, 119 bytes
i=>{var a=0;foreach(var c in i){if(c=='!')a=~a;if(c=='>')a>>=1;if(c=='<')a<<=1;if(c=='@')a=a<<4|a>>4;a&=255;}return a;}

Other versions I tried, but need more bytes:
Func<string,int>C=i=>{var a=0;foreach(var c in i){switch(c){case'!':a=~a;break;case'<':a<<=1;break;case'>':a>>=1;break;case'@':a=a<<4|a>>4;break;}a&=255;}return a;};

// This is, despite having the worst score, my personal favourite :D
Func<string,int>D=i=>{var f=new Dictionary<char,Func<int,int>>{{'!',q=>~q},{'<',q=>q<<1},{'>',q=>q>>1},{'@',q=>q<<4|q>>4}};var a=0;foreach(var c in i)if(f.ContainsKey(c))a=f[c](a)&255;return a;};

Python 2.7.3, 104 bytes
Having code in strings to be evaluated looks pretty dirty, but works :D
a=0
for c in raw_input():a=eval({'!':'~a','<':'a<<1','>':'a>>1','@':'a<<4|a>>4'}.get(c,'a'))&255
print a

Here's the output (and input actually..)
And yes, it's really running on a RaspberryPi :)

brainfuck, 316 bytes
->,[>++++[<-------->-]<-[>>]<[>>>>+[->-<]>[-<+>]<<<]++++[<------->-]<+[>>]<[>>>>[->++<]>[-<+>]<<<]<--[>>]<[>>>>[->+>+<<]>>[->>--[--<->]<-<]>[[-]<<->>]<<[--<+>]<<<]<--[>>]<[>>>>[->+>+<<]>>[->>++++[-<++++>]<<]>[->+>+<<]>>[>++++[<---->-]>+<<]>>[-<<<<<<->>>>>>]<<<<<<[>++++[<---->-]>+<<]>>>[-<+>]<[-<<<+>>>]<<<<<]<,]>>>.

Try it online!
Explanation:
->, input to cell 1
[
>++++[<-------->-]<- sub 33= now will be 0 if invert instruction (cell 1)
[>>] if not move to cell 3
<[    runs if !
>>>>+[->-<]>[-<+>]<<<  invert cell 4 to cell 5 back to 4 end 2
]
now ends on cell 2 either way

++++[<------->-]<+ sub 27
[>>]
<[ runs if shl
>>>>[->++<] shl cell 4 to cell 5
>[-<+>]< back to 4
<< to 2
]
ends on 2

<-- sub 2
[>>]
<[    runs if shr (hard)
>>>>[->+>+<<] copy 4 to cell 5 and 6
>>[->>--[--<->]<-<] get evenness of 6 to 7
>[ if odd
[-] zero cell 7
<<->> sub cell 5
]
ends cell 7
<<[--<+>]<<< shr cell 5 to 4
]
ends cell 2 again

<-- sub 2
[>>]
<[ if @ (also very hard)
>>>>[->+>+<<] copy 4 to 5 and 6 (end on 4)
>>[->>++++[-<++++>]<<] mul cell 6 by 16 to 7
>[->+>+<<] copy 7 to 8 and 9
>>[>++++[<---->-]>+<<] div 9 by 16 to 11= chopping off upper bits
>>[-<<<<<<->>>>>>]<<<<<++++[<---->-]>+<<] div 5 by 16 to 7
>>>[-<+>] add 8 to 7
<[-<<<+>>>]<<< move 7 to 4
<<
]
end on 2 again

<,] end on 1

a ends up at cell 4

>>>. print

GBZ80 machine code, 37 bytes
As soon as I saw this challenge, I knew I had to do this for the Game Boy where this maps 1:1.
000000a5: af 47 2a a7 c8 fe 21 28 00 fe 3c 28 00 fe 3e 28  .G*...!(..<(..>(
000000b5: 00 fe 40 20 ed cb 30 18 e9 78 2f 18 e4 cb 20 18  ..@ ..0..x/... .
000000c5: e1 cb 38 18 dd                                   ..8..

Commented assembly (rgbds with # comments instead of ;):
        SECTION ".text",ROM0
        # input: null terminated string in HL
        # output: accumulator final value in B
func::
        # a = 0
        xor     a, a
.with_ld:
        # Save A to B so we can load the next byte from the tape.
        ld      b, a
        # Since not all instructions require the A register, we can skip the
        # ld by jumping here instead.
.no_ld:
        # load byte from HL and increment
        # a = *hl++
        ld      a, [hli]
        # and A against itself to check for zero
        and     a, a
        # return if null terminator
        ret     z
        # just a normal compare and branch chain
        cp      a, "!"
        jr      z, .cpl
        cp      a, "<"
        jr      z, .left
        cp      a, ">"
        jr      z, .right
        cp      a, "@"
        # comment char, skip without ld
        jr      nz, .no_ld
        # b = (b >> 4) | (b << 4)
        swap    b
        jr      .no_ld
.cpl:
        # we need to use A for CPL
        ld      a, b
        # a = ~a
        cpl
        jr      .with_ld
.left:
        # b <<= 1
        sla     b
        jr      .no_ld
.right:
        # b >>= 1
        srl     b
        jr      .no_ld

Here is a version which prints directly using printf (SDCC ABI), satisfying the "must print" requirement (which I don't enjoy doing), 53 bytes
00 00 represents unlinked placeholders for the string below and _printf.
000000e4: af 4f 2a a7 28 00 fe 21 28 00 fe 3c 28 00 fe 3e  .O*.(..!(..<(..>
000000f4: 28 00 fe 40 20 ec cb 31 18 e8 79 2f 18 e3 cb 21  (..@ ..1..y/...!
00000104: 18 e0 cb 39 18 dc 47 c5 21 00 00 e5 cd 00 00 e8  ...9..G.!.......
00000114: 04 c9 25 75 00                                   ..%u.

The only differences is that it uses c instead of b and adds a call to printf.
        # .area _BASE
        SECTION ".text", ROM0
        # input: null terminated string in HL
        # output: decimal printed with printf
func::
        # a = 0
        xor     a, a
.with_ld:
        # save A to C
        ld      c, a
        # since not all instructions require the A register, we can skip the
        # ld by jumping here.
.no_ld:
        # a = *hli++
        ld      a, [hli]
        # and a, a is better than cp a, 0
        and     a, a
        # return if null terminator
        jr      z, .print
        # just a normal compare and branch chain
        cp      a, "!"
        jr      z, .cpl
        cp      a, "<"
        jr      z, .left
        cp      a, ">"
        jr      z, .right
        cp      a, "@"
        # comment char, skip without ld
        jr      nz, .no_ld
        # c = (c >> 4) | (c << 4)
        swap    c
        jr      .no_ld
.cpl:
        # we need to use A for CPL
        ld      a, c
        # a = ~a
        cpl
        jr      .with_ld
.left:
        # c <<= 1
        sla     c
        jr      .no_ld
.right:
        # c >>= 1
        srl     c
        jr      .no_ld
.print:
        # zero extend bc
        # a is known to be zero
        ld      b, a
        # SDCC uses cdecl
        push    bc
        # "%u"
        ld      hl, .str
        push    hl
        # printf("%u", (u16)result);
        call    _printf
        # restore stack and return
        add     sp, 4
        ret
.str:
        db "%u"
        db 0

Screenshot:

PowerShell Core, 98 bytes
switch($args){!{[byte]$a=-bnot$a-band255}`<{$a=$a-shl1}`>{$a=$a-shr1}`@{$a=($a-shl4)+($a-shr4)}}$a

Try it online!

Easyfuck, 106 bytes

Ì¢RGÏCCHçP®óëÊR>hñãåPLD¯[¼ùbë×ZÙ]nSÅ¸␝«¶òëêl%!}yn␅␏APC>|PU1ó␚jPM/|PU1ãÜÏ␔ç[HOPCçÏ¿fSOSCn␅␏APC}ÌùNu¸␔>÷SGCIóå*ï]CCHùóçÏSTSÀ␛á␋çPAD␀␀ÿ

due to lack of unicode representations for c1 control characters, they have been replaced by their superscripted abbreviations
Decompressed:
f(J$>>)g(+^>^)$>4<<>,.^[^>,.^]5Y.[J<-`;+[<]>S0J!>^-`(>>>>$>1S*</>$<=f<)g-`(>>>~f)g-`(>>}f>)g-`(>{f>>)+^]J>>>>>'@␍x!><␀␀