[Question]
  [
Choose your favorite famous computer scientist or [computer science pioneer](http://en.wikipedia.org/wiki/List_of_pioneers_in_computer_science) who was **born in 1942 or earlier** (as 1943 marks the start of the creation of the ['first' computer](http://en.wikipedia.org/wiki/ENIAC)). They should have a Wikipedia page or other site that lists their birth year and tells how their accomplishments relate to computer science. You may choose the same as someone else but choosing someone new is encouraged.
Take a name they are commonly known by. This will most likely be their first and last name but it might include abbreviations or middle names if that is more common. For example, for [Tony Hoare](http://en.wikipedia.org/wiki/Tony_Hoare) both `Tony Hoare` and `C. A. R. Hoare` would be acceptable. 
**All the characters in the name must be [printable ASCII](http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters).** If the name contains characters that aren't printable ASCII it's fine if you choose something approximate. e.g. `Kurt Godel` instead of `Kurt Gödel`. 
Take the set of unique characters in the name (e.g. `C. ARHoare`) and shift them up the printable ASCII scale by the birth year of your scientist, looping around from `~` to space. (Basically add the birth year modulo 95.) This will give you a (most likely) new set of printable ASCII characters.
For example, C. A. R. Hoare was born in 1934, so shifting every character in `C. ARHoare` by 1934 (34 mod 95) characters gives `ePBctj2$5(`.
This Stack Snippet will do all the shifting for you:
```
function go() {var name = document.getElementById("name").value;var year = parseInt(document.getElementById("year").value);var unique = {};for (var i = 0; i < name.length; i++) { unique[name.charAt(i)] = true; } var result = ''; for (var char in unique) { result += String.fromCharCode((char.charCodeAt(0) - 32 + year) % 95 + 32); } document.getElementById("result").value = result; }
```
```
Name: <input type="text" id="name" value="C. A. R. Hoare"><br>
Birth Year: <input type="text" id="year" value="1934"><br>
<button type="button" onclick="go()">Ok</button><br>
Result: <input type="text" id="result" readonly>
```
# Challenge
Using this set **and only this set** (no tabs, no newlines) of shifted printable ASCII characters, write a program that prints `Hello, [name]!` to stdout or closest alternative, where `[name]` is the same exact name you chose above and shifted to get your program characters. You may use multiple characters from the set or not use some at all. For example, the theoretical program `PetBee($25` prints `Hello, C. A. R. Hoare!`.
# Scoring
Your score is your code size in bytes times the number of unique characters in the name you choose. The lowest sore wins.
  
[Answer]
# CJam, ~~230~~ ~~117~~ ~~115~~ ~~114~~ ~~113~~ ~~110~~ ~~107~~ 106 bytes \* 13 = 1378
```
23)3*c11(2#)c111(((c3*))))22 2*c32c23 3*c3))$(113))c1$)))2$)2$(32c3)))$(3)$))1($)1($)3))$)1($)1$(12$(((33c
```
[Test it here.](http://cjam.aditsu.net/)
I chose `Edsger Dijkstra`, born 1930, which gives me `c#2&$1>b()* 3` (whom I really just chose because he was the first one I found whose name yielded useful characters for CJam; I've checked a dozen names since and none looked as promising).
The code basically just builds the ASCII codes using `1`, `2`, `3`, `*`, `#` (exponentiation) and `(`, `)` (decrement, increment) and converts them to a character with `c`. To save some characters I can sometimes copy an earlier character with `$` (`0$` copies the top stack element, `1$` copies the second-to-top stack element and so on).
Here is the breakdown of the code into characters (this is also runnable):
```
23)3*c    "(23+1)*3 -> 72 -> H";
11(2#)c   "(11-1)^2+1 -> 101 -> e";
111(((c   "111-3 -> 108 -> l";
3*)       "Turn l into string lll and split off the third l.";
)))       "l+3 -> o";
22 2*c    "22*2 -> 44 -> ,";
32c       "32 -> Space";
23 3*c    "23*3 -> 69 -> E";
3))$(     "e-1 -> d";
113))c    "113+2 -> 115 -> s";
1$)))     "d+3 -> g";
2$)       "d+1 -> e";
2$(       "s+1 -> r";
32c       "32 -> Space";
3)))$(    "E-1 -> D";
3)$))     "g+2 -> i";
1($)      "i+1 -> j";
1($)      "j+1 -> k";
3))$)     "r+1 -> s";
1($)      "s+1 -> t";
1$(       "s-1 -> r";
12$(((    "d-3 -> a";
33c       "33 -> !";
```
[Answer]
# [Marbelous](https://codegolf.stackexchange.com/questions/40073/making-future-posts-runnable-online-with-stack-snippets/40808#40808), 83 bytes \* 10 = 830
I've chosen `R Kowalski, 1941` which allows me to use: `{It9A+6=53`
```
++63
A66333696A5A696A6A69
A5633A..+3+6+3+9++
A56A+I
AA+6
=3
3653666665
+I+I+6+6+A++
```
This one is a bit more complex than the old answer (below) since many marbles go through multiple devices, all in all most marble just have a few things added to them before being printed though. Because I didn't have subtraction or low numerals, the lower ascii codes had to be formed by adding by merging two high value marbles, since this results in addition modulo. (I've used `=3` as a deflector since it pushes every marble not equal to 3 to the right and looks like a cute cat)
**output:**
`Hello, R Kowalski!`
**old answer:**
**[Marbelous](https://codegolf.stackexchange.com/questions/40073/making-future-posts-runnable-online-with-stack-snippets/40808#40808), 113 \* 17 = 1921**
Marbelous does okay here, since ever marble that falls off the board gets printed, because of its 2D nature though, it needs a few numerals + some arithmetic to not let the borad get too huge.
I've chosen `Philip D. Estridge, 1937` who yields `u./26EiSj9:8*-+` as the available character set. The characters actually used are `.+-245689E`
```
22
6865
4965686866282252686968696E2244666E65686422456E6E6E6964
--..+4+4+9+4-2-2....+4..+2-2..+9..-4+4..-2..+5+6+4
```
The board is pretty simple, the first 3 rows are literals, ever group of two is a hexadecimal value, the fourth row are arithmetic operations to form the ascii codes that could not be written explicitly because of the limited character sets.
**output:**
`Hello, Philip Donald Estridge!`
[You can try it out here!](https://codegolf.stackexchange.com/questions/40073/making-future-posts-runnable-online-with-stack-snippets/40808#40808)
I'll now look for a possible better candidate, since it looks like marbelous might actually be competitive here.
[Answer]
# Insomnia, ~~103~~ ~~99~~ 98 \* 8 = 784
[George Boole](http://en.wikipedia.org/wiki/George_Boole), 1815
All 5 programs below have the same length (98) and same output.
```
oyoooyLyyyyoyLqoyyoyoLL*yyoLqy|oLq*yLyoyyoLqoq*yLyyLoyooLyyy*qL|yqoLq**LoooyoLqy|qLLo*qyLq*oq|L|oL
oyoooyLyyyyoyLqoyyoyoLLy*yyoLq*oqL*LqyyyoyLyooyyoLyyLoyooLyyyL*q|qoL|q*LoooyoLqyq*LLo*qyLq*o|qL|oL
oyoooyLyyyyoyLqoyyoyoLL*yyoLqy|oLq*yLyoyyoLqoq*yLyyLoyooLyyyL*qq|oL|yq*LoooyoLqyq*LLo*qyLq*o|qL|oL
oyoooyLyyyyoyLqoyyoyoLLy*yyoLq*oqL*LqyyyoyLyooyyoLyyLoyooLyyyL*q|qoL|q*LoooyoLqyq*LL|qyyLy*qq*L|oL
oyoooyLyyyyoyLqoyyoyoLL*yyoLq|oLq*yLyoyyoLyq|oLq|yq*LqooLoyyoyLyLoyyoyLoooyoLo|q|LLq|yyLooooyoLqyL
```
Prints `Hello, George Boole!`
**Insomnia, 103 \* 6 = 618** (probably optimal and unique)
If `G Boole` ([George Boole](http://en.wikipedia.org/wiki/George_Boole), 1815) is acceptable...
```
ooyoyoLoyyoyoyyLyoyoooLLoyooyyLoyyyoLooyoyoooooLyoyyoLoyoyyyoLooyyyooLoyoyooooLLyyooyoyoLyoyoooLoyooooL
```
Prints `Hello, G Boole!`
---
# Insomnia, ~~94~~ ~~92~~ ~~89~~ ~~85~~ 83 \* 10 = 830
Kurt Godel, 1906.
```
kukuzkzjzkuxkujx{rxjkjxzjukukzj{ukukzjkrxujzujk{rxujjku{jxuukujrxzjuxjk{urxjxukzj{j
```
Prints `Hello, Kurt Godel!`
I wrote a program to search for the solution. My second version of the program should be closer to optimal than my first version.
As per @Martin Büttner's nitpick (~~100~~ ~~92~~ ~~88~~ 85 characters, same set of characters):
```
kukuzkzjzkuxkujx{rxjkjxzjukukzj{ukukzjkrxujzujk{rxujju{jxuukujrxuxjzxjk{urxjxjxukzj{j
```
Prints `Hello, Kurt Goedel!`
[**Interpreter**](https://codegolf.stackexchange.com/a/41868/6638)
[Answer]
# Brainfuck,1846\*12 = 22152
Just to have a language other than CJam. Requires original spec Brainfuck with byte datatype, that overflows at 256.
Only uses 2 characters: `+` to increment the current cell, and `.` to output the current cell.
```
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++.+++++++++++++++++.++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
```
**Output**
```
Hello, John McCarthy!
```
Credit goes to Coredump for revealing the following in his answer:
```
 "John McCarthy" 1927
 ("John McCarthy" "e+*;h~^|.0$5" 12)
```
[Answer]
# "Hello, Niklaus Emil Wirth!" (Befunge-98, 222×14=3108)
From [Wikipedia](https://en.wikipedia.org/w/index.php?title=Niklaus_Wirth&oldid=1198340176):
> 
> **Niklaus Emil Wirth** (15 February 1934 – 1 January 2024) was a Swiss computer scientist.
> He designed several programming languages, including Pascal, and pioneered several classic topics in software engineering.
> In 1984, he won the Turing Award, generally recognized as the highest distinction in computer science, “for developing a sequence of innovative computer languages”.
> 
> 
> 
With a shift of 34, `Niklaus Emil Wirth` (18 characters, 14 unique) ends up as `p,./$86Bg0,/By,57+`.
## Code ([try it out here](http://www.quirkster.com/iano/js/befunge.html)):
```
88888888+++++++50p50g8+,50g88885+++++00pg,g7+,g7+,g55++,888866+++++,8888+++,50g68++,g886++5/+,g6+,g7+,50g88755+++++,g88++,g77++,8888+++,50g5+,g8+,g886++5/+,g7+,8888+++,50g887+++,g886++5/+,g85++,g87++,g88+5/+,g5/85++,50g00p
```
## Breakdown:
```
88888888+++++++ # Put eight '8's on the stack and add them together (ASCII 64 = `@`)
50p             # Save this value in row 0, column 5 (where the 6th '8' was)
50g8+,          # Fetch the value we just saved, add 8 and print it (ASCII 72 = `H`)
50g88885+++++   # Fetch it again and add 37 (4×8+5) (ASCII 101 = `e`)
00p             # Save this value in row 0, column 0 (the very first character)
g,              # Fetch & print this value (stack is empty, so coordinates will be zero)
g7+,g7+,        # Fetch it again, add 7 (ASCII 108 = `l`) and print. Repeat.
g55++,          # Print `o`
888866+++++,    # Print `,` (4×8+2×6=44)
8888+++,50g68++,g886++5/+,g6+,g7+,50g88755+++++,g  # Continue in a similar fashion,
88++,g77++,8888+++,50g5+,g8+,g886++5/+,g7+,8888++  # using integer division (`/`) in
+,50g887+++,g886++5/+,g85++,g87++,g88+5/+,g5/85++, # a few places
50g00p          # Fetch the `@` character and put it in cell (0,0)
```
The last line places a HALT character (`@`) at the beginning of the line. When the control wraps around back to this point, the program will stop. This shouldn't actually be necessary, because the `@` character at (5,0) is still there and nothing should be output before it is reached. However, [the only online Befunge interpreter that will run this monstrosity](http://www.quirkster.com/iano/js/befunge.html) won't work properly without it.
It *is* actually possible to make a working solution with just `Niklaus Wirth` (12 unique chars, `p,./$86By,57+`), but the code is much, *much* longer.
(Tagged as Befunge-98 because Befunge-93 is limited to a width of 80 characters.)
[Answer]
# CJam, 323 bytes \* 10 = 3230
```
5((e5(((e2(((e2(((e2((e2c525e2e2(e2(((e2(e2((e2(((c525e5(e5(((e2(e2c2(($Be2(e2(((e2(e2e2((e2(e2e2(c2e2e2((e2e2(e2(((e2(e2c2(($((((((((((((B((((($(((((2e2(e2(e2e2((e2(((e2(e2e2((c2$2$((c2$2$525e2(((e2((e2((e2((e2e2(((e2((c2$2$22((((((($22(((((((((($22(((((($((((255((e2((e2(e2((e2(((e2((c22(((($Be2e2(e2(e2((e2(((e2(((e2(((c
```
Output:
```
Hello, C. A. R. Hoare!
```
# CJam, 662 bytes \* 10 = 6620 8700
Not to win but just because it looks possible. It used only `2e(c`.
```
2e2e2((e2e2(((e2(((e2(((e2((e2c2e2e2(((e2e2(e2(((e2(e2((e2(((c2e2e2e2((e2((e2e2(((e2(e2c2e2e2e2((e2((e2e2(((e2(e2c2e2(e2(((e2(e2e2((e2(e2e2(c2e2((e2e2((e2e2(e2(((e2(e2c2e2((e2e2((e2(((e2(((e2((e2e2c2e2((e2(((e2e2(((e2((e2(e2(((e2(c2e2(e2(e2e2((e2(((e2(e2e2((c2e2((e2e2((e2(((e2(((e2((e2e2c2e2((e2(((e2e2(((e2((e2(e2(((e2(((c2e2(e2(e2e2((e2(((e2(e2e2((c2e2((e2e2((e2(((e2(((e2((e2e2c2e2(((e2(((e2((e2((e2((e2e2(((e2((c2e2(e2(e2e2((e2(((e2(e2e2((c2e2((e2e2((e2(((e2(((e2((e2e2c2e2e2((e2e2(((e2(((e2(((e2((e2c2e2(e2(((e2(e2e2((e2(e2e2(c2e2(((e2e2(e2(((e2(e2(((e2(((e2(((c2e2e2e2(((e2((e2(e2((e2(((e2((c2e2e2(((e2e2(e2(((e2(e2((e2(((c2e2(e2e2(e2(e2((e2(((e2(((e2(((c
```
Output:
```
Hello, C. A. R. Hoare!
```
### Generator
```
q{i
[7209 3113 41 41 41 9 1 0]
{
1$3^)4%@1$+@*4/\'(*\
}%W2tW%"e2"*
'c}%
```
The trivial answer `222(((((((((((c` (generated by `q{i222_@-'(*'c}%`) has 3420 bytes.
[Answer]
# CJam, 16 \* ~~307~~ 288 = ~~4912~~ 4608
```
B(7*2+cB(B(*2(+cB(B*((cB(B*((cBB*7-(((c5 8*5(+c8 2*2*cBB*2/5+cBB*7-cBB*5-cBB*Bm5-(cBB*4-cBB*7-c8 2*2*cB7*(((cBB*7-(((cBB*Bm5-(cBB*B-c8 2*2*c8B*2+8-cBB*7-(((c7 2+B*(cBB*8 2*-cBB*B-c8 2*2*cB(7*2(+cBB*7-(((cBB*7-cB(B(*2(+cB(B*((cB(B*((c8 2*2*cB7*cBB*8 2*-cB(B*((cBB*B-cB(B(*2(+cBB*7-c5(8*1+c
```
Displays:
```
Hello, Arthur John Robin Gorell Milner!
```
This is my first answer using CJam, so surely this can better golfed (any hint is welcome).
---
Here is some utility code I used.
Since I computed the character set for some other names, this may be useful for someone who better knows CJam (or maybe for another language).
* Find the character set, along with the number of unique characters
```
(defun character-set (name year)
  (let* ((uniques (remove-duplicates name))
         (size (length uniques))
         (buffer (make-array size 
                             :element-type 'character
                             :fill-pointer 0)))
    (loop for c across uniques
          do (vector-push
              (code-char
               (+ #x20 (mod (- (+ (char-code c) year) #x20) 95)))
              buffer)
          finally (return (values buffer size)))))
```
* Define a list of well-known figures
```
(defparameter *masters*  
  '("Grace Murray Hopper" 1906
    "Augusta Ada King, Countess of Lovelace" 1815
    "Augusta Ada Byron" 1815
    "Ada Lovelace" 1815
    "John von Neumann" 1903
    "Neumann Janos Lajos" 1903
    "Charles Babbage" 1791
    "John McCarthy" 1927
    "Wilhelm Ackermann" 1896
    "George Boole" 1815
    "Kurt Godel" 1906
    "Andrei Nikolaievitch Kolmogorov" 1903
    "Bertrand Arthur William Russell, 3rd Earl Russell" 1872
    "Arthur John Robin Gorell Milner" 1934))
```
* Compute the allowed printable character sets, sort by size of set
```
(sort (loop for (n y) on *masters* by #'cddr
            collect (cons n (multiple-value-list (character-set n y))))
      #'< :key #'caddr)
=>
(("George Boole" "Q|q*Lyvo" 8) 
 ("Ada Lovelace" "Kn*Vy!vkmo" 10)
 ("Kurt Godel" "Q{xz&Mujkr" 10) 
 ("John von Neumann" "Mkyr#Qhxpdq" 11)
 ("Charles Babbage" "5Zd^eq4TSYW" 11)
 ("Grace Murray Hopper" "MiS{g &Nuvkx" 12)
 ("Neumann Janos Lajos" "QhxpMq#Odmrv" 12)
 ("John McCarthy" "e+*;h~^|.0$5" 12)
 ("Augusta Ada Byron" "q }~Knk*L$|yx" 13)
 ("Wilhelm Ackermann" "Sedh{=_gani]j" 13)
 ("Arthur John Robin Gorell Milner" "c78l+t%i2Bo,/1(5" 16)
 ("Andrei Nikolaievitch Kolmogorov" "DqgQndhlwfk#Nopjury" 19)
 ("Augusta Ada King, Countess of Lovelace" "KnUsq6M x~}p*Vy!vkmo" 20)
 ("Bertrand Arthur William Russell, 3rd Earl Russell" "&R%XL;MQovH)EVc6YWIP" 20))
```
[Answer]
# Brainf\_ck - 723 \* 12 = 8676
I did a crawl from Wikipedia's [List of computer scientists](http://en.wikipedia.org/wiki/List_of_computer_scientists) and collected the birthyears and longest names of all the people listed there. I wrote a program to run over all these and find any I could possibly do in a common language. Sadly, I was unable to find any names that could support `echo;`, `alert()`, `console.log()` (I can hope), `print`, or `main`.
I mainly wanted to share my raw crawl data in case anyone wanted to similarly search for other languages (note: may be inaccurate and incomplete): [**Crawl Data**](http://pastebin.com/j2kq3Tys).
**EDIT**: New crawl paste with about 40 new names from [List of computing people](http://en.wikipedia.org/wiki/List_of_computing_people) and [List of pioneers in computer science](http://en.wikipedia.org/wiki/List_of_pioneers_in_computer_science).
**EDIT**: Manually cleaned up the list.
I did find that [Jean David Ichbiah](http://en.wikipedia.org/wiki/Jean_Ichbiah) (1940), chief designer of Ada, provides `+-.` (the shortest of three people to do so). I generated this BF code for him.
```
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.-------------------------------------------------------------------.------------.++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++.----.+++++++++++++.------------------------------------------------------------------------------.++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++++++++++++++++.-------------.-----.--------------------------------------------------------------------.+++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++.+++++.------.+++++++.--------.+++++++.-----------------------------------------------------------------------.
```
[Alexander Keewatin Dewdney](http://en.wikipedia.org/wiki/Alexander_Dewdney) provided the most usable BF characters (`+.<>`), but came in slightly above my answer. No one I found provided `.[]`.
[Answer]
## Ruby 1.8 - 250 × 18 = 4500
```
p''<<24+48<<2+99<<9+99<<9+99<<22+89<<44<<4+28<<24/4+59<<22+88<<2+95<<22+94<<22+89<<9+99<<24/4+99<<24/4+99<<4+28<<24/4+59<<9+99<<2+99<<22+98<<2+99<<2+99<<24+94<<24/4+99<<99<<5+99<<4+28<<84/4+54<<2+95<<22+92<<2+95<<22+94<<84/4+94<<22+95<<98<<2+95<<4+29
```
Characters available:
```
'()+./24589:;<>Efp
```
Output:
```
"Hello, Anatolii Alexeevich Karatsuba!"
```
[Anatolii Karatsuba](http://en.wikipedia.org/wiki/Anatoly_Karatsuba), born 1937, is most well known for his contributions to the field of analytic number theory (a field I personally enjoy), including the [Karatsuba Algorithm](http://en.wikipedia.org/wiki/Karatsuba_algorithm), a method for fast multiplication of arbitrary precision operands.
This is the first and only name I tried.
[Answer]
## GolfScript (125 \* 14 = 1750)
```
9)99.9-&^99)).9^..)))..)~99-&.99&.99)^999)9/.(((-9-..9(/-.((9^99((.9-9-^.).9-^).)).~--999~9/.9^.((.9^99(.(.9.~-^.))..9-^))](-
```
[Online demo](http://golfscript.apphb.com/?c=OSk5OS45LSZeOTkpKS45Xi4uKSkpLi4pfjk5LSYuOTkmLjk5KV45OTkpOS8uKCgoLTktLi45KC8tLigoOV45OSgoLjktOS1eLikuOS1eKS4pKS5%2BLS05OTl%2BOS8uOV4uKCguOV45OSguKC45Ln4tXi4pKS4uOS1eKSldKC0%3D)
[Douglas Engelbart](http://en.wikipedia.org/wiki/Douglas_Engelbart) (1925 - 2013) is perhaps most famous for the ["Mother of All Demos"](http://en.wikipedia.org/wiki/The_Mother_of_All_Demos). His name and year of birth give characters `!&(),-./9]^z{~`, of which this solution uses `&()-./9]^~`
The basic structure of the code is `build list of numbers](-` which puts a lot of numbers in an array with the empty string that starts on the stack, then pulls out that string and uses it with the type promotion of `-` to turn the array of numbers into a string.
Since there's no access to elements below the top of the stack I wrote a C# program to find short snippets that take a given integer on the top of the stack and add the next integer required. This created one small problem, when the snippet for `69` (`E`) ended with `-` and the snippet for `110` (`n`) started with `9`: it cost one char to use a longer snippet for `110`.
[Answer]
# [CaneCode](http://esolangs.org/wiki/CaneCode), ~~458~~ 410 \* 16 = ~~7328~~ 6560
```
11111111111111111111111111111111111111111111111111111111111111111111111184111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111118111111188111841111111111111111111111111111111111111111111182222222222228331184222222222222228118111111118483322222841811111111822222828483322284111182222222222222811111111111111822222222222222811111111182222228222222281111111111118418
```
Corresponding BF:
```
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++..+++.>++++++++++++++++++++++++++++++++++++++++++++.------------.<<++.>--------------.++.++++++++.>.<<-----.>+.++++++++.-----.-.>.<<---.>++++.-------------.++++++++++++++.--------------.+++++++++.------.-------.++++++++++++.>+.
```
Outputs:
```
Hello, Jack Elton Bresenham!
```
CaneCode is just a direct symbol substitution of Brainfuck, where `12348` correspond to `+-><.` respectively. I spent about 2 hours trying to look for a short name which gave `+-.` for normal Brainfuck, with no success.
[Jack Elton Bresenham](https://en.wikipedia.org/wiki/Jack_Elton_Bresenham), inventor of Bresenham's line algorithm and born 1937, gives the following characters:
```
o')1Ej2:54g8+9.3
```
Unfortunately, while `5` (`[`) is available, the lack of `6` (`]`) means that the code still had to increment up the 100-ish area (for lowercase chars) the slow way.
[Answer]
# [><> (Fish)](http://esolangs.org/wiki/Fish), 163 \* 15 = 2445
```
47*5+:56+7*+:42)+:4+55*66*:++66+6*o:4+::o7+:oo25*+o56+:4*o42*4*o6*7+o:7+7+7+o:o:25*7++o42*:4*o45+*o:45++o:o:6+:5+o6+o:o:25*7++o24*4*o25*7*4+o:o:2+o:27*+o42)+ooooo;
```
Outputs:
```
Hello, Ivar Hjalmar Jacobson!
```
[Ivar Hjalmar Jacobson](https://en.wikipedia.org/wiki/Ivar_Jacobson), born 1939, was found thanks to [BMac's crawl data](https://codegolf.stackexchange.com/a/41783/21487). He provides the chars
```
)*+24567:;>Gopq
```
><>, like Befunge, is a 2D stack-based language. The useful ><> commands are:
* `*+24567` for arithmetic (note that `47` pushes a `4` and a `7` on the stack, not `47`)
* `)` for greater than (useful for getting `1`)
* `:` for duplicating the top of the stack
* `o` for output
* `;` for program termination
`p` is also good for reflection, but I was unable to think of a good use for it. `>` is another ><> command, directing program flow rightwards, but since the program already executes in that direction it was not needed.
]